Navigation:Home > Content >

b-PSI@STOPs_Light.mq4

Time: 2018-02-06 | Download file:b-PSI@STOPs_Light.mq4

//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
//|                                                             b-PSI@STOPs_Light.mqh |
//|                                    Copyright © 2011-14, Igor Stepovoi aka TarasBY |
//|                                                                taras_bulba@tut.by |
//|   20.05.2012  Библиотека создания и контроля СТОПов.                              |
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
//|   Данный продукт предназначен для некоммерческого использования. Публикация раз-  |
//|решена только при указании имени автора (TarasBY). Редактирование исходного кода   |
//|допустима только при  условии сохранения данного текста,  ссылок и  имени автора.  |
//|Продажа библиотеки или отдельных её частей ЗАПРЕЩЕНА.                              |
//|   Автор не несёт ответственности за возможные убытки, полученные в результате ис- |
//|пользования библиотеки.                                                            |
//|   По всем вопросам, связанным с работой библиотеки, замечаниями или предложениями |
//|по её доработке обращаться на Skype: TarasBY или e-mail.                           |
//+-----------------------------------------------------------------------------------+
//|   This product is intended for non-commercial use.  The publication is only allo- |
//|wed when you specify the name of the author (TarasBY). Edit the source code is va- |
//|lid only under condition of preservation of the text, links and author's name.     |
//|   Selling a module or(and) parts of it PROHIBITED.                                |
//|   The author is not liable for any damages resulting from the use of a module.    |
//|   For all matters relating to the work of the module, comments or suggestions for |
//|their improvement in the contact Skype: TarasBY or e-mail.                         |
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
#property copyright "Copyright © 2008-14, TarasBY WM R418875277808; Z670270286972"
#property link      "taras_bulba@tut.by"
//IIIIIIIIIIIIIIIIIII==================CONSTANS=================IIIIIIIIIIIIIIIIIIIIII+
//IIIIIIIIIIIIIIIIIII================ПЕРЕЧИСЛЕНИЯ================IIIIIIIIIIIIIIIIIIIII+
enum ENUM_N_STOP
{
    STOP_STATIC = 0,      // Static
    STOP_EXTREMUM,        // Extremum
    STOP_ATR,             // ATR
    STOP_ZZ               // ZigZag
};
enum ENUM_LEVEL_FIBO
{
    LevelMinus_2 = -2,    // -2
    LevelMinus_1 = -1,    // -1
    LevelZero    = 0,     // 0
    Level_1      = 1,     // 1
    Level_2      = 2,     // 2
    Level_3      = 3,     // 3
    Level_4      = 4,     // 4
    Level_5      = 5,     // 5
};
//IIIIIIIIIIIIIIIIIII==========Внешние параметры модуля=========IIIIIIIIIIIIIIIIIIIIII+
sinput string SETUP_STOPs           = "================ Make STOP`s ==================";
extern ENUM_N_STOP N_STOPs             = STOP_STATIC;      // N (номер) используемых СТОПов (0 - 3)
extern bool   USE_Dinamic_SL           = TRUE;             // Динамический SL
extern bool   USE_Dinamic_TP           = FALSE;            // Динамический TP
extern ENUM_TIMEFRAMES TF_STOPs        = PERIOD_H1;        // Таймфрейм на котором рассчитываем СТОПы
extern int    MIN_StopLoss             = 30;               // Минимальный SL
extern int    MIN_TakeProfit           = 30;               // Минимальный TP
extern ENUM_LEVEL_FIBO LevelFIBO_SL    = LevelZero;        // уровень по FIBO выше\ниже пика (-2 - 5)
extern ENUM_LEVEL_FIBO LevelFIBO_TP    = LevelZero;        // уровень по FIBO выше\ниже пика (-2 - 5)
#include      "b-PSI@VirtualSTOPs.mq4"                     // Библиотека виртуальных СТОпов
sinput string Setup_STATIC          = "***************** N0 - STATIC *****************";
extern int    StopLoss                 = 100;
extern int    TakeProfit               = 500;
//IIIIIIIIIIIIIIIIIII=========Подключение внешних модулей=======IIIIIIIIIIIIIIIIIIIIII+
#include      "b-PSI@LEVELs_Light.mq4"                     // Библиотека расчёта уровней
//IIIIIIIIIIIIIIIIIII========Глобальные переменные модуля=======IIIIIIIIIIIIIIIIIIIIII+
double        bd_MIN_SL, bd_MIN_TP;
int           bia_LevelFIBO[2];
//IIIIIIIIIIIIIIIIIII===========Перечень функций модуля=========IIIIIIIIIIIIIIIIIIIIII+
//bool fInit_STOPs()                - Инициализация модуля
/*IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
bool fCreat_STOPs (                 - Рассчитываем и модифицируем СТОПы
//+-----------------------------------------------------------------------------------+
    int fi_NSTOPs,                  // N (номер) расчитываемых СТОПов
    int fi_Ticket,                  // Ticket ордера
    double fd_Price,                // текущая цена по инструменту
    int fi_Period,                  // TF с которого производятся расчёты
    bool fb_NewBar,                 // флаг прихода нового бара
    bool fb_USE_VirtualSTOPs = false,// флаг использования виртуальных СТПов
    bool fb_IsNET = false           // флаг построения сетки (SL не ставим)
)*/
/*IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
bool fUSE_STOP (                    - Производим установку СТОПов
//+-----------------------------------------------------------------------------------+
    int fi_Ticket,                  // Ticket ордера
    double fd_Price,                // текущая цена по инструменту
    bool fb_NewBar,                 // флаг прихода нового бара
    bool fb_USE_VirtualSTOPs = false,// флаг использования виртуальных СТОПов
    bool fb_IsNET = false           // флаг построения сетки (SL не ставим)
)*/
/*IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
void fCreat_LevelsByFIBO (          - Расчитываем СТОПы с учётом уровней FIBO (заданные в настройках).
//+-----------------------------------------------------------------------------------+
    double ar_Extrem[],             // массив экстремумов
    double& ar_STOPs[],             // возвращаемый массив СТОПов
    int ar_LevelFIBO[]              // массив номеров уровней (0 - для SL; 1 - для TP)
)*/
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
//bool fCheck_STOPsParameters()     - Проверяем переданные в библиотеку внешние параметры
//|***********************************************************************************|
//| РАЗДЕЛ: ОБЩИХ ФУНКЦИЙ                                                             |
/*|***********************************************************************************|
void fSet_ValuesSTOPs (             - Получаем рабочие переменные в соответствии с разрядностью
//+-----------------------------------------------------------------------------------+
    string fs_Symbol                // Инструмент
)*/
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
//void fCheck_DecimalSTOPs()        - Учитываем разрядность котировок
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
//bool fSet_ContinueSTOPs()         - Для оптимизации убираем "пустые" варианты
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
//|  Автор : TarasBY, taras_bulba@tut.by                                              |
//+-----------------------------------------------------------------------------------+
//         Инициализация модуля                                                       |
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
bool fInit_STOPs()
{
//----
    //---- Производим проверку передаваемых в библиотеку значений
    if (!fCheck_STOPsParameters())
    {
        bs_ERROR = StringConcatenate ("Проверьте параметры выбранного Вами СТОПа !!!", " || ", bs_ERROR);
        bb_OptimContinue = true;
        return (false);
    }
    //---- При оптимизации пропускаем бесполезные варианты настроек
    if (fSet_ContinueSTOPs()) {bb_OptimContinue = true; return (false);}
    //---- Инициализируем библиотеку виртуальных СТОПов
    fInit_VirtualSTOPs();
    //---- Инициализируем библиотеку расчёта уровней
    if (!fInit_LEVELs (N_STOPs)) return (false);
    //---- Приводим внешние переменные в соответствии с разрядностью котировок ДЦ
    fCheck_DecimalSTOPs();
    bia_LevelFIBO[0] = LevelFIBO_SL;
    bia_LevelFIBO[1] = LevelFIBO_TP;
    bb_ClearGV = true;
    string lsa_Array[1];
    lsa_Array[0] = "_#STOP";
    fCreat_ArrayGV (bsa_prefGV, lsa_Array);
    //---- Контролируем возможные ошибки
	   fGet_LastErrorInArray ("fInit_STOPs()", bi_indERR);
//----
    return (true);
}
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
//|  Автор : TarasBY, taras_bulba@tut.by                                              |
//+-----------------------------------------------------------------------------------+
//|        Рассчитываем и модифицируем СТОПы                                          |
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
bool fCreat_STOPs (
    int fi_NSTOPs,                  // N (номер) рассчитываемых СТОПов
    int fi_Ticket,                  // Ticket ордера
    double fd_Price,                // текущая цена по инструменту
    int fi_Period,                  // TF с которого производятся расчёты
    bool fb_NewBar,                 // флаг прихода нового бара
    bool fb_USE_VirtualSTOPs = false,// флаг использования виртуальных СТОПов
    bool fb_IsNET = false)          // флаг построения сетки (SL не ставим)
//+...................................................................................+
{
    //---- Если не нужна динамическая модификация - выходим
    string ls_Name = StringConcatenate (fi_Ticket, "_#STOP");
    if (GlobalVariableCheck (ls_Name))
    {
        if (!fb_NewBar) return (false);
        if (GlobalVariableGet (ls_Name) == 1) return (false);
    }
//----
    int    err = GetLastError();
    double lda_STOPs[] = {0.0,0.0}, lda_Levels[2];
    static string lsa_NameSTOPs[] = {"Classic","Extremum","ATR","ZZ"};
    bool   lba_Modify[] = {false,false};
//----
    bs_libNAME = "b-STOPs";
    bs_fName = lsa_NameSTOPs[fi_NSTOPs];
    //ArrayInitialize (ar_STOPs, 0.0);
    //---- Получаем актуальные параметры по инструменту
    fSet_ValuesSTOPs (OrderSymbol());
    //---- Определяем текущие СТОПы
    fRead_STOPs (fi_Ticket, fb_USE_VirtualSTOPs);
    //---- Формируем СТОПы
    switch (fi_NSTOPs)
    {
        case 0: // Классические СТОПы
            if (StopLoss > 0)
            {
                if (bd_curSL > 0.0) lba_Modify[0] = true;
                lda_STOPs[0] = bd_OpenPrice - bi_cmd * bd_SL;
            }
            if (TakeProfit > 0)
            {
                if (bd_curTP > 0.0) lba_Modify[1] = true;
                lda_STOPs[1] = bd_OpenPrice + bi_cmd * (bd_TP + bd_Spread);
            }
            //---- Ничего модифицировать не нужно
            if (lba_Modify[0]) if (lba_Modify[1]) {GlobalVariableSet (StringConcatenate (fi_Ticket, "_#STOP"), 1); return (false);}
            break;
        case 1: // СТОПы по экстремумам на fi_Period за S.cnt_Bars барах
        case 2: // СТОПы по ATR на fi_Period
        case 3: // СТОПы по ZZP (ZigZag) на fi_Period
            //---- Рассчитываем минимальные СТОПы
            lda_STOPs[0] = bd_OpenPrice - bi_cmd * bd_MIN_SL;
            lda_STOPs[1] = bd_OpenPrice + bi_cmd * (bd_MIN_TP + bd_Spread);
            //---- Получаем экстремумы
            if (fi_NSTOPs == 1) if (!fGet_Extremum (lda_Levels, bs_Symbol, fi_Period, E_cnt_Bars)) return (false);
            if (fi_NSTOPs == 2) if (!fGet_ATR (lda_Levels, bs_Symbol, fi_Period, E_cnt_Bars)) return (false);
            if (fi_NSTOPs == 3) if (!fGet_ZZP (lda_Levels, bs_Symbol, fi_Period)) return (false);
            //---- Корректируем СТОПы с учётом уровней FIBO
            fCreat_LevelsByFIBO (lda_Levels, lda_STOPs, bia_LevelFIBO);
            break;
    }
    //---- При формировании сети (до момента её сформирования) SL не ставим
    if (fb_IsNET) lda_STOPs[0] = 0.0;
    //---- Вычисляем расстояние от SL до текущей цены
    else bd_Trail = MathAbs (fd_Price - lda_STOPs[0]);
    bd_Price = fd_Price;
    ArrayInitialize (lba_Modify, False);
    //---- Заполняем СТОПы новыми значениями
    if (bd_curSL == 0.0 || (USE_Dinamic_SL && bi_cmd * (bd_OpenPrice - bd_curSL) > 0.0))
    {
        //---- Проверяем SL на корректность
        if (bi_cmd * (fd_Price - lda_STOPs[0]) > 0.0)
        {
            bd_NewSL = NDD (lda_STOPs[0]);
            //---- Если SL изменился фиксируем этот факт
            if (NDD (bd_NewSL - bd_curSL) != 0.0) lba_Modify[0] = true;
        }
    }
    //if (bd_NewSL == bd_curSL) lba_Modify[0] = false;
    if (bd_curTP == 0.0 || USE_Dinamic_TP)
    {
        //---- Проверяем TP на корректность
        if (bi_cmd * (lda_STOPs[1] - fd_Price) > 0.0)
        {
            bd_NewTP = NDD (lda_STOPs[1]);
            //---- Если TP изменился фиксируем этот факт
            if (NDD (bd_NewTP - bd_curTP) != 0.0) lba_Modify[1] = true;
        }
    }
    //---- Если ничего модифицировать не нужно - выходим
    if (!lba_Modify[0]) if (!lba_Modify[1]) return (false);
    int li_result = 0;
    //---- Организуем возможность первоначальной (внеочередной) модификации
    if (!USE_Dinamic_SL) if (!USE_Dinamic_TP) li_result = 1;
    //---- При виртуальных СТОПах устанавливаем реальные классические СТОПы
    if (fb_USE_VirtualSTOPs) {if (fi_NSTOPs == 0) if (bd_curSL == 0.0) if (bd_curTP == 0.0) fb_USE_VirtualSTOPs = false;}
    //---- Двигаем СТОПы с модификацией или без
    if (!fb_USE_VirtualSTOPs)
    {
        //---- Модифицируем СТОПы
        int li_modify = fOrderModify (fi_Ticket, bd_OpenPrice, bd_NewSL, bd_NewTP);
        if (li_modify >= 0) fSet_Comment (bdt_curTime, fi_Ticket, 20, "fCreat_STOPs()", li_modify != 0, (bd_curSL == 0.0 && bd_curTP == 0.0));
        //---- Помечаем "последствия" первичной модификации
        if (li_modify == 1) {GlobalVariableSet (StringConcatenate (fi_Ticket, "_#STOP"), li_result);}
        return (li_modify == 1);
    }
    else
    {
        //---- Если SL изменился вносим изменения в GV-переменную
        if (lba_Modify[0]) {GlobalVariableSet (StringConcatenate (fi_Ticket, "_#VirtSL"), bd_NewSL);}
        //---- Если TP изменился вносим изменения в GV-переменную
        if (lba_Modify[1]) {GlobalVariableSet (StringConcatenate (fi_Ticket, "_#VirtTP"), bd_NewTP);}
        if (!bb_VirtualTrade)
        {
            fSet_Comment (bdt_curTime, fi_Ticket, 20, "b-STOPs[Virt]", true, (bd_curSL == 0.0 && bd_curTP == 0.0));
            if (bb_CreatVStopsInChart)
            {
                if (lba_Modify[0]) fDraw_VirtSTOP (fi_Ticket, bs_NameGV, bi_cmd, 0, bd_NewSL);
                if (lba_Modify[1]) fDraw_VirtSTOP (fi_Ticket, bs_NameGV, bi_cmd, 1, bd_NewTP);
            }
        }
        //---- Помечаем "последствия" первичной модификации
        GlobalVariableSet (StringConcatenate (fi_Ticket, "_#STOP"), li_result);
    }
    bs_fName = "";
    //---- Контролируем возможные ошибки
    fGet_LastErrorInArray ("fCreat_STOPs()", bi_indERR);
//----
    return (false);
}
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
//|  Автор : TarasBY, taras_bulba@tut.by                                              |
//+-----------------------------------------------------------------------------------+
//         Расчитываем СТОПы с учётом уровней FIBO (заданные в настройках)            |
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
void fCreat_LevelsByFIBO (
    double& ar_Extrem[],            // массив экстремумов
    double& ar_STOPs[],             // возвращаемый массив СТОПов
    int& ar_LevelFIBO[])            // массив номеров уровней (0 - для SL; 1 - для TP)
//+...................................................................................+
{
    int    li_CMD, li_Level;
    double ld_Delta = (ar_Extrem[0] - ar_Extrem[1]);
//----
    for (int li_IND = 0; li_IND < 2; li_IND++)
    {
        if (bi_Type == 0) {if (li_IND == 0) li_CMD = 1; else li_CMD = 0;} else {li_CMD = li_IND;}
        li_Level = MathAbs (ar_LevelFIBO[li_IND]);
        int li_cmd = 1;
        if (ar_LevelFIBO[li_IND] < 0) {if (li_CMD == 0) li_cmd = -1;} else {if (li_CMD == 1) li_cmd = -1;}
        if (bi_Type == li_IND)
        {ar_STOPs[li_IND] = MathMin (ar_STOPs[li_IND], ar_Extrem[li_CMD] + li_cmd * ld_Delta * bda_FIBO[li_Level]);}
        else {ar_STOPs[li_IND] = MathMax (ar_STOPs[li_IND], ar_Extrem[li_CMD] + li_cmd * ld_Delta * bda_FIBO[li_Level]);}
        //if (li_IND == 0) Print (fGet_NameOP (bi_Type), ": SL[", ar_LevelFIBO[li_IND], "] = ", DSD (ar_STOPs[li_IND]), " | HIGH = ", DSD (ar_Extrem[li_IND]));
        //if (li_IND == 1) Print (fGet_NameOP (bi_Type), ": TP[", ar_LevelFIBO[li_IND], "] = ", DSD (ar_STOPs[li_IND]), " | LOW = ", DSD (ar_Extrem[li_IND]));
    }
//----
}
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
//|  Автор : TarasBY, taras_bulba@tut.by                                              |
//+-----------------------------------------------------------------------------------+
//         Проверяем переданные в библиотеку внешние параметры.                       |
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
bool fCheck_STOPsParameters()
{
    int err = GetLastError();
//----
    //if (N_STOPs < 0 || N_STOPs > 3) {bs_ERROR = "Поставьте 0 <= N_STOPs <= 3 !!!"; return (false);}
    if (N_STOPs == 0)
    {
        if (StopLoss < 0) {bs_ERROR = "Поставьте StopLoss >= 0 !!!"; return (false);}
        if (TakeProfit < 0) {bs_ERROR = "Поставьте TakeProfit >= 0 !!!"; return (false);}
    }
    /*else
    {
        if (LevelFIBO_SL < -2 || LevelFIBO_SL > 5) {bs_ERROR = "Поставьте -2 <= LevelFIBO_SL <= 5 !!!"; return (false);}
        if (LevelFIBO_TP < -2 || LevelFIBO_TP > 5) {bs_ERROR = "Поставьте -2 <= LevelFIBO_TP <= 5 !!!"; return (false);}
    }*/
    //---- Производим проверку на правильность задания TF
    if (TF_STOPs == 0) TF_STOPs = (ENUM_TIMEFRAMES) Period();
    if (fGet_NumPeriods (TF_STOPs) < 0) {return (false);}
    if (N_STOPs == 0)
    {
        USE_Dinamic_SL = false;
        USE_Dinamic_TP = false;
    }
    //---- Контролируем возможные ошибки
	   fGet_LastErrorInArray ("fCheck_STOPsParameters()", bi_indERR);
//----
    return (true);
}
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
//+===================================================================================+
//|***********************************************************************************|
//| РАЗДЕЛ: ОБЩИХ ФУНКЦИЙ                                                             |
//|***********************************************************************************|
//+===================================================================================+
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
//|  Автор : TarasBY, taras_bulba@tut.by                                              |
//+-----------------------------------------------------------------------------------+
//|         Получаем рабочие переменные в соответствии с разрядностью                 |
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
void fSet_ValuesSTOPs (string fs_Symbol)
{
    //static string ls_Symbol = "";
//----
	   if (bs_Symbol != fs_Symbol)
	   {
		      bs_Symbol = fs_Symbol;
		      bd_SL = NDP (StopLoss);
		      bd_TP = NDP (TakeProfit);
		      bd_MIN_SL = NDP (MIN_StopLoss);
		      bd_MIN_TP = NDP (MIN_TakeProfit);
	   }
    //bd_Spread = NDP (MarketInfo (bs_Symbol, MODE_SPREAD));
//----
}
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
//|  Автор : TarasBY, taras_bulba@tut.by                                              |
//+-----------------------------------------------------------------------------------+
//|        Учитываем разрядность котировок                                            |
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
void fCheck_DecimalSTOPs()
{
//----
    if (StopLoss > 0) StopLoss *= bi_Decimal;
    if (TakeProfit > 0) TakeProfit *= bi_Decimal;
    if (MIN_StopLoss > 0) MIN_StopLoss *= bi_Decimal;
    if (MIN_TakeProfit > 0) MIN_TakeProfit *= bi_Decimal;
    //---- Инициализируем используемые переменные библиотеки
    bs_Symbol = "";
    fSet_ValuesSTOPs (Symbol());
//----
}
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
//|  Автор : TarasBY, taras_bulba@tut.by                                              |
//+-----------------------------------------------------------------------------------+
//         Запускаем в работу рабочие индикаторы.                                     |
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
/*void fCheck_MyIndicatorsSTOP (string fs_Symbol)
{
//----
    switch (N_STOPs)
    {
        case 2: 
            //iATR (fs_Symbol, TF_STOPs, E.ATR_Period1, 0);
            //iATR (fs_Symbol, TF_STOPs, E.ATR_Period2, 0);
            break;
        case 3: iCustom (fs_Symbol, TF_STOPs, "XLab_ZZP", E.ChannelPercent, 0, 0); break;
        default: return;
    }
//----
}*/
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
//|  Автор : TarasBY, taras_bulba@tut.by                                              |
//+-----------------------------------------------------------------------------------+
//|        Для оптимизации убираем "пустые" варианты                                  |
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
bool fSet_ContinueSTOPs()
{
//----
    //if (N_STOPs == 0) {if (Percent_F.SINUS != 0.5) return (true);}
//----
    return (false);
}
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+

Recommend