Рецепты MQL5 - Как не получить ошибку при установке/изменении торговых уровней?
Anatoli Kazharski | 2 апреля, 2013
Введение
Продолжая работу над экспертом из предыдущей статьи Рецепты MQL5 - Изучение свойств позиции в тестере MetaTrader 5, на этот раз внедрим в него еще целый ряд полезных функций, а также усовершенствуем и оптимизируем уже имеющиеся.
Очень часто на форуме-(ах) по программированию на MQL можно увидеть вопросы от новичков, касающиеся ошибок при установке/модификации торговых уровней (Stop Loss, Take Profit, отложенные ордера). Думаю, уже многие знакомы с сообщением в журнале, в котором в конце строки содержится [Invalid stops]. В этой статье мы создадим функции, в которых нормализуются и проверяются на корректность значения торговых уровней перед открытием/модификацией позиции.
На этот раз эксперт будет снабжен внешними параметрами, которые можно будет оптимизировать в тестере MetaTrader 5. Это уже будет немного похоже на простую торговую систему. До настоящей торговой системы, конечно же, пока еще довольно далеко, но не все сразу - нам предстоит еще много работы.
Оптимизацию кода в уже имеющихся функциях будем рассматривать по ходу статьи. Информационную панель со свойствами позиции пока оставим, так как еще нужно рассмотреть некоторые свойства позиции, которые не получить стандартными идентификаторами (нужно обращаться к истории сделок). Но это тема будет раскрыта в одной из последующих статей.
Процесс разработки эксперта
Приступим. Начнем, как всегда, с добавления в начале файла дополнительных перечислений, переменных, массивов и с вспомогательных функций. Нам понадобится функция, которая позволит легко и просто получить свойства символа. Так же легко и просто нужно будет получать и свойства позиции.
В предыдущих статьях в функции GetPositionProperties глобальным переменным присваивались сразу все свойства позиции. Теперь мы сделаем так, чтобы можно было получать каждое свойство по отдельности. Ниже приведены два перечисления для реализации задуманного, а сами функции рассмотрим чуть позже.
//--- Перечисление свойств позиции enum ENUM_POSITION_PROPERTIES { P_SYMBOL = 0, P_MAGIC = 1, P_COMMENT = 2, P_SWAP = 3, P_COMMISSION = 4, P_PRICE_OPEN = 5, P_PRICE_CURRENT = 6, P_PROFIT = 7, P_VOLUME = 8, P_SL = 9, P_TP = 10, P_TIME = 11, P_ID = 12, P_TYPE = 13, P_ALL = 14 }; //--- Перечисление свойств символа enum ENUM_SYMBOL_PROPERTIES { S_DIGITS = 0, S_SPREAD = 1, S_STOPSLEVEL = 2, S_POINT = 3, S_ASK = 4, S_BID = 5, S_VOLUME_MIN = 6, S_VOLUME_MAX = 7, S_VOLUME_LIMIT = 8, S_VOLUME_STEP = 9, S_FILTER = 10, S_UP_LEVEL = 11, S_DOWN_LEVEL = 12, S_ALL = 13 };
Перечисление ENUM_SYMBOL_PROPERTIES содержит далеко не все свойства символа, но его в любой момент можно будет дополнить по мере необходимости. В перечислении присутствуют также пользовательские свойства (10, 11, 12), которые будут рассчитываться из показателей других свойств символа. Так же как и в перечислении свойств позиции, есть идентификатор, с помощью которого можно получить сразу все свойства из перечисления.
Далее идут внешние параметры эксперта:
//--- Внешние параметры эксперта input int NumberOfBars=2; // Кол-во Бычьих/Медвежьих баров для покупки/продажи input double Lot =0.1; // Лот input double StopLoss =50; // Стоп Лосс input double TakeProfit =100; // Тейк Профит input double TrailingStop=10; // Трейлинг Стоп input bool Reverse =true; // Разворот позиции
Рассмотрим подробнее внешние параметры:
- NumberOfBars - в этом параметре задается количество однонаправленных баров для открытия позиции;
- Lot - объем позиции;
- TakeProfit - уровень фиксации прибыли в пунктах. Нулевое значение означает, что Take Profit устанавливать не нужно.
- StopLoss - защитный уровень в пунктах. Нулевое значение означает, что Stop Loss устанавливать не нужно.
- TrailingStop - шаг защитного уровня Трейлинг Стоп в пунктах. Для позиции BUY расчет производится от минимума бара (минимум минус количество пунктов из параметра StopLoss). Для позиции SELL расчет производится от максимума бара (максимум плюс количество пунктов из параметра StopLoss). Нулевое значение означает, что трейлинг отключен.
- Reverse - включает/выключает переворот позиции.
Уточнения требует только параметр NumberOfBars. Не имеет смысла устанавливать в этом параметре значение, например, больше 5, так как это уже довольно редкое явление и открывать позицию уже поздно после такого движения. Поэтому понадобится переменная, с помощью которой можно будет корректировать значение этого параметра:
//--- Для проверки значения внешнего параметра NumberOfBars int AllowedNumberOfBars=0;
От этого параметра также будет зависеть, сколько данных баров будет приниматься в ценовые массивы. Об этом будет рассказано подробнее немного ниже, когда начнем модифицировать пользовательские функции.
Для свойств символа, так же как и для свойств позиции, объявим переменные на глобальном уровне, чтобы можно было получить доступ из любой функции:
//--- Свойства символа int sym_digits=0; // Количество знаков в цене после запятой int sym_spread=0; // Размер спреда в пунктах int sym_stops_level=0; // Ограничитель установки Stop ордеров double sym_point=0.0; // Значение одного пункта double sym_ask=0.0; // Цена ask double sym_bid=0.0; // Цена bid double sym_volume_min=0.0; // Минимальный объем для заключения сделки double sym_volume_max=0.0; // Максимальный объем для заключения сделки double sym_volume_limit=0.0; // Максимально допустимый объем для позиции и ордеров в одном направлении double sym_volume_step=0.0; // Минимальный шаг изменения объема для заключения сделки double sym_offset=0.0; // Отступ от максимально возможной цены для операции double sym_up_level=0.0; // Цена верхнего уровня stop level double sym_down_level=0.0; // Цена нижнего уровня stop level
Так как трейлинг должен рассчитываться от максимума и минимума баров, нам понадобятся массивы для этих данных баров:
//--- Массивы ценовых данных double close_price[]; // Close (цены закрытия бара) double open_price[]; // Open (цены открытия бара) double high_price[]; // High (цены максимума бара) double low_price[]; // Low (цены минимума бара)
Теперь приступим к модификации и созданию функций. У нас уже есть функция GetBarsData, в которой в ценовые массивы копируются цены открытия и закрытия баров. Теперь нам нужны еще максимумы и минимумы. Кроме того, нужно проводить корректировку значения из параметра NumberOfBars. Вот как выглядит эта функция после модификации:
//+------------------------------------------------------------------+ //| Получает значения баров | //+------------------------------------------------------------------+ void GetBarsData() { //--- Скорректируем значение количества баров для условия открытия позиции if(NumberOfBars<=1) AllowedNumberOfBars=2; // Нужно не менее двух баров if(NumberOfBars>=5) AllowedNumberOfBars=5; // и не более 5 else AllowedNumberOfBars=NumberOfBars+1; // и всегда на один больше //--- Установим обратный порядок индексации (... 3 2 1 0) ArraySetAsSeries(close_price,true); ArraySetAsSeries(open_price,true); ArraySetAsSeries(high_price,true); ArraySetAsSeries(low_price,true); //--- Получим цену закрытия бара // Если полученных значений меньше, чем запрошено, вывести сообщение об этом if(CopyClose(_Symbol,Period(),0,AllowedNumberOfBars,close_price)<AllowedNumberOfBars) { Print("Не удалось скопировать значения (" +_Symbol+", "+TimeframeToString(Period())+") в массив цен Close! " "Ошибка "+IntegerToString(GetLastError())+": "+ErrorDescription(GetLastError())); } //--- Получим цену открытия бара // Если полученных значений меньше, чем запрошено, вывести сообщение об этом if(CopyOpen(_Symbol,Period(),0,AllowedNumberOfBars,open_price)<AllowedNumberOfBars) { Print("Не удалось скопировать значения (" +_Symbol+", "+TimeframeToString(Period())+") в массив цен Open! " "Ошибка "+IntegerToString(GetLastError())+": "+ErrorDescription(GetLastError())); } //--- Получим цену максимума бара // Если полученных значений меньше, чем запрошено, вывести сообщение об этом if(CopyHigh(_Symbol,Period(),0,AllowedNumberOfBars,high_price)<AllowedNumberOfBars) { Print("Не удалось скопировать значения (" +_Symbol+", "+TimeframeToString(Period())+") в массив цен High! " "Ошибка "+IntegerToString(GetLastError())+": "+ErrorDescription(GetLastError())); } //--- Получим цену минимума бара // Если полученных значений меньше, чем запрошено, вывести сообщение об этом if(CopyLow(_Symbol,Period(),0,AllowedNumberOfBars,low_price)<AllowedNumberOfBars) { Print("Не удалось скопировать значения (" +_Symbol+", "+TimeframeToString(Period())+") в массив цен Low! " "Ошибка "+IntegerToString(GetLastError())+": "+ErrorDescription(GetLastError())); } }
Не менее двух баров и всегда на один больше нужно потому, что ориентироваться будем только на сформировавшиеся бары, которые начинаются с индекса [1]. Корректировку в этом случае на самом деле можно и не делать, ведь данные баров можно начать копировать с указанного индекса в третьем параметре функций CopyOpen, CopyClose, CopyHigh и CopyLow. Ограничение в пять сформировавшихся баров тоже можно изменить (больше/меньше) на ваше усмотрение.
Функция GetTradingSignal теперь немного усложнилась, так как в зависимости от того, сколько баров указано в параметре NumberOfBars, условие будет формироваться иначе. Кроме того, теперь используется более правильный тип возвращаемого значения - тип ордера:
//+------------------------------------------------------------------+ //| Определяет торговые сигналы | //+------------------------------------------------------------------+ ENUM_ORDER_TYPE GetTradingSignal() { //--- Сигнал на покупку (ORDER_TYPE_BUY) : if(AllowedNumberOfBars==2 && close_price[1]>open_price[1]) return(ORDER_TYPE_BUY); if(AllowedNumberOfBars==3 && close_price[1]>open_price[1] && close_price[2]>open_price[2]) return(ORDER_TYPE_BUY); if(AllowedNumberOfBars==4 && close_price[1]>open_price[1] && close_price[2]>open_price[2] && close_price[3]>open_price[3]) return(ORDER_TYPE_BUY); if(AllowedNumberOfBars==5 && close_price[1]>open_price[1] && close_price[2]>open_price[2] && close_price[3]>open_price[3] && close_price[4]>open_price[4]) return(ORDER_TYPE_BUY); if(AllowedNumberOfBars>=6 && close_price[1]>open_price[1] && close_price[2]>open_price[2] && close_price[3]>open_price[3] && close_price[4]>open_price[4] && close_price[5]>open_price[5]) return(ORDER_TYPE_BUY); //--- Сигнал на продажу (ORDER_TYPE_SELL) : if(AllowedNumberOfBars==2 && close_price[1]<open_price[1]) return(ORDER_TYPE_SELL); if(AllowedNumberOfBars==3 && close_price[1]<open_price[1] && close_price[2]<open_price[2]) return(ORDER_TYPE_SELL); if(AllowedNumberOfBars==4 && close_price[1]<open_price[1] && close_price[2]<open_price[2] && close_price[3]<open_price[3]) return(ORDER_TYPE_SELL); if(AllowedNumberOfBars==5 && close_price[1]<open_price[1] && close_price[2]<open_price[2] && close_price[3]<open_price[3] && close_price[4]<open_price[4]) return(ORDER_TYPE_SELL); if(AllowedNumberOfBars>=6 && close_price[1]<open_price[1] && close_price[2]<open_price[2] && close_price[3]<open_price[3] && close_price[4]<open_price[4] && close_price[5]<open_price[5]) return(ORDER_TYPE_SELL); //--- Отсутствие сигнала (WRONG_VALUE): return(WRONG_VALUE); }
Теперь модифицируем функцию GetPositionProperties. В предыдущих статьях в ней можно было получить все свойства сразу. Но иногда нужно получить только одно из них. Для этого можно, конечно же, пользоваться и стандартными функциями языка, но это не так удобно, как хотелось бы. Ниже представлен код модифицированной функции GetPositionProperties. Теперь, передавая тот или иной идентификатор из пользовательского перечисления ENUM_POSITION_PROPERTIES, можно получить либо отдельное свойство позиции, либо все сразу.
//+------------------------------------------------------------------+ //| Получает свойства позиции | //+------------------------------------------------------------------+ void GetPositionProperties(ENUM_POSITION_PROPERTIES position_property) { //--- Узнаем, есть ли позиция pos_open=PositionSelect(_Symbol); //--- Если позиция есть, получим её свойства if(pos_open) { switch(position_property) { case P_SYMBOL : pos_symbol=PositionGetString(POSITION_SYMBOL); break; case P_MAGIC : pos_magic=PositionGetInteger(POSITION_MAGIC); break; case P_COMMENT : pos_comment=PositionGetString(POSITION_COMMENT); break; case P_SWAP : pos_swap=PositionGetDouble(POSITION_SWAP); break; case P_COMMISSION : pos_commission=PositionGetDouble(POSITION_COMMISSION); break; case P_PRICE_OPEN : pos_price=PositionGetDouble(POSITION_PRICE_OPEN); break; case P_PRICE_CURRENT : pos_cprice=PositionGetDouble(POSITION_PRICE_CURRENT); break; case P_PROFIT : pos_profit=PositionGetDouble(POSITION_PROFIT); break; case P_VOLUME : pos_volume=PositionGetDouble(POSITION_VOLUME); break; case P_SL : pos_sl=PositionGetDouble(POSITION_SL); break; case P_TP : pos_tp=PositionGetDouble(POSITION_TP); break; case P_TIME : pos_time=(datetime)PositionGetInteger(POSITION_TIME); break; case P_ID : pos_id=PositionGetInteger(POSITION_IDENTIFIER); break; case P_TYPE : pos_type=(ENUM_POSITION_TYPE)PositionGetInteger(POSITION_TYPE); break; case P_ALL : pos_symbol=PositionGetString(POSITION_SYMBOL); pos_magic=PositionGetInteger(POSITION_MAGIC); pos_comment=PositionGetString(POSITION_COMMENT); pos_swap=PositionGetDouble(POSITION_SWAP); pos_commission=PositionGetDouble(POSITION_COMMISSION); pos_price=PositionGetDouble(POSITION_PRICE_OPEN); pos_cprice=PositionGetDouble(POSITION_PRICE_CURRENT); pos_profit=PositionGetDouble(POSITION_PROFIT); pos_volume=PositionGetDouble(POSITION_VOLUME); pos_sl=PositionGetDouble(POSITION_SL); pos_tp=PositionGetDouble(POSITION_TP); pos_time=(datetime)PositionGetInteger(POSITION_TIME); pos_id=PositionGetInteger(POSITION_IDENTIFIER); pos_type=(ENUM_POSITION_TYPE)PositionGetInteger(POSITION_TYPE); break; default: Print("Переданное свойство позиции не учтено в перечислении!"); return; } } //--- Если позиции нет, обнулим переменные свойств позиции else ZeroPositionProperties(); }
Аналогичным образом реализуем функцию GetSymbolProperties для получения свойств символа:
//+------------------------------------------------------------------+ //| Получает свойства символа | //+------------------------------------------------------------------+ void GetSymbolProperties(ENUM_SYMBOL_PROPERTIES symbol_property) { int lot_offset=1; // Количество пунктов для отступа от уровней stops level //--- switch(symbol_property) { case S_DIGITS : sym_digits=(int)SymbolInfoInteger(_Symbol,SYMBOL_DIGITS); break; case S_SPREAD : sym_spread=(int)SymbolInfoInteger(_Symbol,SYMBOL_SPREAD); break; case S_STOPSLEVEL : sym_stops_level=(int)SymbolInfoInteger(_Symbol,SYMBOL_TRADE_STOPS_LEVEL); break; case S_POINT : sym_point=SymbolInfoDouble(_Symbol,SYMBOL_POINT); break; //--- case S_ASK : sym_digits=(int)SymbolInfoInteger(_Symbol,SYMBOL_DIGITS); sym_ask=NormalizeDouble(SymbolInfoDouble(_Symbol,SYMBOL_ASK),sym_digits); break; case S_BID : sym_digits=(int)SymbolInfoInteger(_Symbol,SYMBOL_DIGITS); sym_bid=NormalizeDouble(SymbolInfoDouble(_Symbol,SYMBOL_BID),sym_digits); break; //--- case S_VOLUME_MIN : sym_volume_min=SymbolInfoDouble(_Symbol,SYMBOL_VOLUME_MIN); break; case S_VOLUME_MAX : sym_volume_max=SymbolInfoDouble(_Symbol,SYMBOL_VOLUME_MAX); break; case S_VOLUME_LIMIT : sym_volume_limit=SymbolInfoDouble(_Symbol,SYMBOL_VOLUME_LIMIT); break; case S_VOLUME_STEP : sym_volume_step=SymbolInfoDouble(_Symbol,SYMBOL_VOLUME_STEP); break; //--- case S_FILTER : sym_digits=(int)SymbolInfoInteger(_Symbol,SYMBOL_DIGITS); sym_point=SymbolInfoDouble(_Symbol,SYMBOL_POINT); sym_offset=NormalizeDouble(CorrectValueBySymbolDigits(lot_offset*sym_point),sym_digits); break; //--- case S_UP_LEVEL : sym_digits=(int)SymbolInfoInteger(_Symbol,SYMBOL_DIGITS); sym_stops_level=(int)SymbolInfoInteger(_Symbol,SYMBOL_TRADE_STOPS_LEVEL); sym_point=SymbolInfoDouble(_Symbol,SYMBOL_POINT); sym_ask=NormalizeDouble(SymbolInfoDouble(_Symbol,SYMBOL_ASK),sym_digits); sym_up_level=NormalizeDouble(sym_ask+sym_stops_level*sym_point,sym_digits); break; //--- case S_DOWN_LEVEL : sym_digits=(int)SymbolInfoInteger(_Symbol,SYMBOL_DIGITS); sym_stops_level=(int)SymbolInfoInteger(_Symbol,SYMBOL_TRADE_STOPS_LEVEL); sym_point=SymbolInfoDouble(_Symbol,SYMBOL_POINT); sym_bid=NormalizeDouble(SymbolInfoDouble(_Symbol,SYMBOL_BID),sym_digits); sym_down_level=NormalizeDouble(sym_bid-sym_stops_level*sym_point,sym_digits); break; //--- case S_ALL : sym_digits=(int)SymbolInfoInteger(_Symbol,SYMBOL_DIGITS); sym_spread=(int)SymbolInfoInteger(_Symbol,SYMBOL_SPREAD); sym_stops_level=(int)SymbolInfoInteger(_Symbol,SYMBOL_TRADE_STOPS_LEVEL); sym_point=SymbolInfoDouble(_Symbol,SYMBOL_POINT); sym_ask=NormalizeDouble(SymbolInfoDouble(_Symbol,SYMBOL_ASK),sym_digits); sym_bid=NormalizeDouble(SymbolInfoDouble(_Symbol,SYMBOL_BID),sym_digits); sym_volume_min=SymbolInfoDouble(_Symbol,SYMBOL_VOLUME_MIN); sym_volume_max=SymbolInfoDouble(_Symbol,SYMBOL_VOLUME_MAX); sym_volume_limit=SymbolInfoDouble(_Symbol,SYMBOL_VOLUME_LIMIT); sym_volume_step=SymbolInfoDouble(_Symbol,SYMBOL_VOLUME_STEP); sym_offset=NormalizeDouble(CorrectValueBySymbolDigits(lot_offset*sym_point),sym_digits); sym_up_level=NormalizeDouble(sym_ask+sym_stops_level*sym_point,sym_digits); sym_down_level=NormalizeDouble(sym_bid-sym_stops_level*sym_point,sym_digits); break; //--- default: Print("Переданное свойство символа не учтено в перечислении!"); return; } }
Обратите внимание, что для получения некоторых свойств символа нужно запросить некоторые другие свойства.
Также появилась новая функция CorrectValueBySymbolDigits. В зависимости от того, сколько знаков в цене после запятой, она возвращает соответствующее значение. В функцию можно передавать целое или вещественное число. В зависимости от типа переданных данных используется соответствующий вариант функции. Такое явление называется перегрузкой функций.
//+------------------------------------------------------------------+ //| Коррекция значения по количеству знаков в цене (int) | //+------------------------------------------------------------------+ int CorrectValueBySymbolDigits(int value) { return (sym_digits==3 || sym_digits==5) ? value*=10 : value; } //+------------------------------------------------------------------+ //| Коррекция значения по количеству знаков в цене (double) | //+------------------------------------------------------------------+ double CorrectValueBySymbolDigits(double value) { return (sym_digits==3 || sym_digits==5) ? value*=10 : value; }
В нашем эксперте будет внешний параметр для указания объема (Lot) открываемой позиции. Сделаем функцию CalculateLot, которая будет корректировать объем в соответствии со спецификацией символа:
//+------------------------------------------------------------------+ //| Рассчитывает объем для позиции | //+------------------------------------------------------------------+ double CalculateLot(double lot) { //--- Для корректировки с учетом шага double corrected_lot=0.0; //--- GetSymbolProperties(S_VOLUME_MIN); // Получим минимально возможный лот GetSymbolProperties(S_VOLUME_MAX); // Получим максимально возможный лот GetSymbolProperties(S_VOLUME_STEP); // Получим шаг увеличения/уменьшения лота //--- Скорректируем с учетом шага лота corrected_lot=MathRound(lot/sym_volume_step)*sym_volume_step; //--- Если меньше минимального, вернем минимальный if(corrected_lot<sym_volume_min) return(NormalizeDouble(sym_volume_min,2)); //--- Если больше максимального, вернем максимальный if(corrected_lot>sym_volume_max) return(NormalizeDouble(sym_volume_max,2)); //--- return(NormalizeDouble(corrected_lot,2)); }
Теперь займемся функциями, которые имеют прямое отношение к названию статьи. Они довольно простые и по комментариям в коде будет не сложно разобраться в их назначении.
Функция CalculateTakeProfit предназначена для расчета значения уровня фиксации прибыли:
//+------------------------------------------------------------------+ //| Рассчитывает уровень Take Profit | //+------------------------------------------------------------------+ double CalculateTakeProfit(ENUM_ORDER_TYPE order_type) { //--- Если Take Profit нужен if(TakeProfit>0) { //--- Для рассчитанного значения Take Profit double tp=0.0; //--- Если нужно рассчитать значение для позиции SELL if(order_type==ORDER_TYPE_SELL) { //--- Рассчитаем уровень tp=NormalizeDouble(sym_bid-CorrectValueBySymbolDigits(TakeProfit*sym_point),sym_digits); //--- Вернем рассчитанное значение, если оно ниже нижней границы stops level // Если значение выше или равно, вернем скорректированное значение return(tp<sym_down_level ? tp : sym_down_level-sym_offset); } //--- Если нужно рассчитать значение для позиции BUY if(order_type==ORDER_TYPE_BUY) { //--- Рассчитаем уровень tp=NormalizeDouble(sym_ask+CorrectValueBySymbolDigits(TakeProfit*sym_point),sym_digits); //--- Вернем рассчитанное значение, если оно выше верхней границы stops level // Если значение ниже или равно, вернем скорректированное значение return(tp>sym_up_level ? tp : sym_up_level+sym_offset); } } //--- return(0.0); }
Функция CalculateStopLoss предназначена для расчета значения защитного уровня:
//+------------------------------------------------------------------+ //| Рассчитывает уровень Stop Loss | //+------------------------------------------------------------------+ double CalculateStopLoss(ENUM_ORDER_TYPE order_type) { //--- Если Stop Loss нужен if(StopLoss>0) { //--- Для рассчитанного значения Stop Loss double sl=0.0; //--- Если нужно рассчитать значение для позиции BUY if(order_type==ORDER_TYPE_BUY) { // Рассчитаем уровень sl=NormalizeDouble(sym_ask-CorrectValueBySymbolDigits(StopLoss*sym_point),sym_digits); //--- Вернем рассчитанное значение, если оно ниже нижней границы stops level // Если значение выше или равно, вернем скорректированное значение return(sl<sym_down_level ? sl : sym_down_level-sym_offset); } //--- Если нужно рассчитать значение для позиции SELL if(order_type==ORDER_TYPE_SELL) { //--- Рассчитаем уровень sl=NormalizeDouble(sym_bid+CorrectValueBySymbolDigits(StopLoss*sym_point),sym_digits); //--- Вернем рассчитанное значение, если оно выше верхней границы stops level // Если значение ниже или равно, вернем скорректированное значение return(sl>sym_up_level ? sl : sym_up_level+sym_offset); } } //--- return(0.0); }
Функция CalculateTrailingStop предназначена для расчета значения трейлинга защитного уровня:
//+------------------------------------------------------------------+ //| Рассчитывает уровень Trailing Stop | //+------------------------------------------------------------------+ double CalculateTrailingStop(ENUM_POSITION_TYPE position_type) { //--- Переменные для расчётов double level =0.0; double buy_point =low_price[1]; // Значение Low для Buy double sell_point =high_price[1]; // Значение High для Sell //--- Рассчитаем уровень для позиции BUY if(position_type==POSITION_TYPE_BUY) { //--- Минимум бара минус указанное количество пунктов level=NormalizeDouble(buy_point-CorrectValueBySymbolDigits(StopLoss*sym_point),sym_digits); //--- Если рассчитанный уровень ниже, чем нижний уровень ограничения (stops level), // то расчет закончен, вернем текущее значение уровня if(level<sym_down_level) return(level); //--- Если же не ниже, то попробуем рассчитать от цены bid else { level=NormalizeDouble(sym_bid-CorrectValueBySymbolDigits(StopLoss*sym_point),sym_digits); //--- Если рассчитанный уровень ниже ограничителя, вернем текущее значение уровня // Иначе установим максимально возможный близкий return(level<sym_down_level ? level : sym_down_level-sym_offset); } } //--- Рассчитаем уровень для позиции SELL if(position_type==POSITION_TYPE_SELL) { // Максимум бара плюс указанное кол-во пунктов level=NormalizeDouble(sell_point+CorrectValueBySymbolDigits(StopLoss*sym_point),sym_digits); //--- Если рассчитанный уровень выше, чем верхний уровень ограничения (stops level), // то расчёт закончен, вернем текущее значение уровня if(level>sym_up_level) return(level); //--- Если же не выше, то попробуем рассчитать от цены ask else { level=NormalizeDouble(sym_ask+CorrectValueBySymbolDigits(StopLoss*sym_point),sym_digits); //--- Если рассчитанный уровень выше ограничителя, вернем текущее значение уровня // Иначе установим максимально возможный близкий return(level>sym_up_level ? level : sym_up_level+sym_offset); } } //--- return(0.0); }
Мы подошли к тому, что у нас есть все необходимые функции, которые возвращают корректные значения для торговых операций. Далее напишем функцию ModifyTrailingStop, в которой будет производиться проверка условия на модификацию трейлинга и его модификация, если это условие выполняется. Ниже представлен код этой функции с подробными комментариями.
Обратите внимание, как используются все те функции, которые были созданы/модифицированы выше. С помощью переключателя switch в зависимости от того, какой тип у текущей позиции, определяется соответствующее условие, результат которого сохраняется в переменной condition. Для модификации позиции используется метод PositionModify из торгового класса CTrade стандартной библиотеки.
//+------------------------------------------------------------------+ //| Изменяет уровень Trailing Stop | //+------------------------------------------------------------------+ void ModifyTrailingStop() { //--- Если включен трейлинг и StopLoss if(TrailingStop>0 && StopLoss>0) { double new_sl=0.0; // Для расчета нового уровня Stop loss bool condition=false; // Для проверки условия на модификацию //--- Получим флаг наличия/отсутствия позиции pos_open=PositionSelect(_Symbol); //--- Если есть позиция if(pos_open) { //--- Получим свойства символа GetSymbolProperties(S_ALL); //--- Получим свойства позиции GetPositionProperties(P_ALL); //--- Получим уровень для Stop Loss new_sl=CalculateTrailingStop(pos_type); //--- В зависимости от типа позиции проверим соответствующее условие на модификацию Trailing Stop switch(pos_type) { case POSITION_TYPE_BUY : //--- Если новое значение для Stop Loss выше, // чем текущее значение плюс установленный шаг condition=new_sl>pos_sl+CorrectValueBySymbolDigits(TrailingStop*sym_point); break; case POSITION_TYPE_SELL : //--- Если новое значение для Stop Loss ниже, // чем текущее значение минус установленный шаг condition=new_sl<pos_sl-CorrectValueBySymbolDigits(TrailingStop*sym_point); break; } //--- Если Stop Loss есть, то сравним значения перед модификацией if(pos_sl>0) { //--- Если выполняется условие на модификацию ордера, т.е. новое значение ниже/выше, // чем текущее, модифицируем защитный уровень позиции if(condition) { if(!trade.PositionModify(_Symbol,new_sl,pos_tp)) Print("Ошибка при модификации позиции: ",GetLastError()," - ",ErrorDescription(GetLastError())); } } //--- Если Stop Loss нет, то просто установим его if(pos_sl==0) { if(!trade.PositionModify(_Symbol,new_sl,pos_tp)) Print("Ошибка при модификации позиции: ",GetLastError()," - ",ErrorDescription(GetLastError())); } } } }
Теперь приведем в порядок функцию TradingBlock в соответствии со всеми изменениями выше. Так же, как и в функции ModifyTrailingStop, будем определять все значения переменных для торгового приказа с помощью переключателя switch. Это значительно сокращает объем кода и упрощает последующие модификации, так как вместо одной ветки для двух типов позиции остается одна.
//+------------------------------------------------------------------+ //| Торговый блок | //+------------------------------------------------------------------+ void TradingBlock() { ENUM_ORDER_TYPE signal=WRONG_VALUE; // Переменная для приема сигнала string comment="hello :)"; // Комментарий для позиции double tp=0.0; // Take Profit double sl=0.0; // Stop Loss double lot=0.0; // Объем для расчета позиции в случае переворота позиции double position_open_price=0.0; // Цена открытия позиции ENUM_ORDER_TYPE order_type=WRONG_VALUE; // Тип ордера для открытия позиции ENUM_POSITION_TYPE opposite_position_type=WRONG_VALUE; // Противоположный тип позиции //--- Получим сигнал signal=GetTradingSignal(); //--- Если сигнала нет, выходим if(signal==WRONG_VALUE) return; //--- Узнаем, есть ли позиция pos_open=PositionSelect(_Symbol); //--- Получим все свойства символа GetSymbolProperties(S_ALL); //--- Определим значения торговым переменным switch(signal) { //--- Присвоим переменным значения для BUY case ORDER_TYPE_BUY : position_open_price=sym_ask; order_type=ORDER_TYPE_BUY; opposite_position_type=POSITION_TYPE_SELL; break; //--- Присвоим переменным значения для SELL case ORDER_TYPE_SELL : position_open_price=sym_bid; order_type=ORDER_TYPE_SELL; opposite_position_type=POSITION_TYPE_BUY; break; } //--- Рассчитаем уровни Take Profit и Stop Loss sl=CalculateStopLoss(order_type); tp=CalculateTakeProfit(order_type); //--- Если позиции нет if(!pos_open) { //--- Скорректируем объём lot=CalculateLot(Lot); //--- Откроем позицию // Если позиция не открылась, вывести сообщение об этом if(!trade.PositionOpen(_Symbol,order_type,lot,position_open_price,sl,tp,comment)) { Print("Ошибка при открытии позиции: ",GetLastError()," - ",ErrorDescription(GetLastError())); } } //--- Если позиция есть else { //--- Получим тип позиции GetPositionProperties(P_TYPE); //--- Если позиция противоположна сигналу и включен переворот позиции if(pos_type==opposite_position_type && Reverse) { //--- Получим объём позиции GetPositionProperties(P_VOLUME); //--- Скорректируем объём lot=pos_volume+CalculateLot(Lot); //--- Откроем позицию. Если позиция не открылась, вывести сообщение об этом if(!trade.PositionOpen(_Symbol,order_type,lot,position_open_price,sl,tp,comment)) { Print("Ошибка при открытии позиции: ",GetLastError()," - ",ErrorDescription(GetLastError())); } } } //--- return; }
Еще нужно внести одно довольно важное исправление в функцию SetInfoPanel, но для начала подготовим несколько вспомогательных функций, которые показывают, как/где в текущий момент используется программа:
//+------------------------------------------------------------------+ //| Возвращает флаг тестирования | //+------------------------------------------------------------------+ bool IsTester() { return(MQL5InfoInteger(MQL5_TESTER)); } //+------------------------------------------------------------------+ //| Возвращает флаг оптимизации | //+------------------------------------------------------------------+ bool IsOptimization() { return(MQL5InfoInteger(MQL5_OPTIMIZATION)); } //+------------------------------------------------------------------+ //| Возвращает флаг визуального режима тестирования | //+------------------------------------------------------------------+ bool IsVisualMode() { return(MQL5InfoInteger(MQL5_VISUAL_MODE)); } //+------------------------------------------------------------------+ //| Возвращает флаг режима реального времени вне тестера, | //| если все условия выполняются | //+------------------------------------------------------------------+ bool IsRealtime() { if(!IsTester() && !IsOptimization() && !IsVisualMode()) return(true); else return(false); }
В функции SetInfoPanel теперь нужно всего лишь добавить условие, которое будет говорить программе, что информационную панель нужно выводить только в режимах визуализации и реального времени. Если этого не сделать, то время тестирования будет возрастет примерно в 4-5 раз. Это особенно актуально, когда проводится оптимизация параметров.
//+------------------------------------------------------------------+ //| Устанавливает информационную панель | //|------------------------------------------------------------------+ void SetInfoPanel() { //--- Режим визуализации или реального времени if(IsVisualMode() || IsRealtime()) { // Остальной код функции SetInfoPanel() // ... } }
Осталось только внести изменения в главные функции программы, и можно будет начинать оптимизировать параметры и тестировать эксперта.
//+------------------------------------------------------------------+ //| Expert initialization function | //+------------------------------------------------------------------+ int OnInit() { //--- Инициализируем новый бар CheckNewBar(); //--- Получим свойства и установим панель GetPositionProperties(P_ALL); //--- Установим информационную панель SetInfoPanel(); //--- return(0); }
//+------------------------------------------------------------------+ //| Expert tick function | //+------------------------------------------------------------------+ void OnTick() { //--- Если бар не новый, выходим if(!CheckNewBar()) return; //--- Если есть новый бар else { GetBarsData(); // Получим данные баров TradingBlock(); // Проверим условия и торгуем ModifyTrailingStop(); // Изменим уровень Trailing Stop } //--- Получим свойства и обновим значения на панели GetPositionProperties(P_ALL); //--- Обновим информационную панель SetInfoPanel(); }
//+------------------------------------------------------------------+ //| Торговое событие | //+------------------------------------------------------------------+ void OnTrade() { //--- Получить свойства позиции и обновить значения на панели GetPositionProperties(P_ALL); //--- Обновим информационную панель SetInfoPanel(); }
Оптимизация параметров и тестирование эксперта
Теперь произведем оптимизацию параметров. Настройки тестера установим, например так, как на рисунке ниже:
Рис. 1. Настройки тестера для оптимизации параметров.
Настройки эксперта установим с широкими диапазонами параметров:
Рис. 2. Настройки эксперта для оптимизации параметров.
На двухъядерном процессоре (Intel Core2 Duo P7350 @ 2.00GHz) время оптимизации заняло около 7 минут. Результат по максимальному фактору восстановления получился вот таким:
Рис. 3. Результат теста по максимальному фактору восстановления.
Заключение
На этом закончим. Разбирайтесь, тестируйте, оптимизируйте, экспериментируйте и отпадайте. В конце статьи вы можете скачать исходный код этого эксперта для изучения.