Useful #define statements - скрипт для MetaTrader 5

Определение переменных

// Candle (define g_rates as: MqlRates g_rates[];)
#define  CANDLELOW(i)    g_rates[i].low
#define  CANDLEHIGH(i)   g_rates[i].high
#define  CANDLEOPEN(i)   g_rates[i].open
#define  CANDLECLOSE(i)  g_rates[i].close
#define CANDLETIME(i)   g_rates[i].time

Также вы можете получить значения ASK и BID с помощью MqlTick, как я сделал ниже, или вызвать SymbolInfoDouble(_Symbol,SYMBOL_ASK), если вам так удобнее. Это не имеет никакого значения для возвращаемого значения.

// Цены (определить g_tick как: MqlTick g_tick;))
#define  ASK             g_tick.ask
#define  BID             g_tick.bid

Наконец, массивы также определяются для скользящих средних, atr или любого другого дополнительного массива, который вам нужен. Пример: чтобы использовать Average True Range свечи 1, используйте ATR(1).
ВАЖНО: предполагается, что массивы являются AsSeries (например,ArraySetAsSeries(g_MA20_arr, true); ). Это очень важно в операторах #define, показанных далее.

// определите эти массивы так: double g_MA20_arr[];
// Скользящие средние и ATR
#define  MOVAVG20(i)     g_MA20_arr[i]
#define  MOVAVG40(i)     g_MA40_arr[i]
#define  MOVAVG50(i)     g_MA50_arr[i]
#define  MOVAVG200(i)    g_MA200_arr[i]
#define  ATR(i)          g_atr_arr[i]

После того как вы определили приведенные выше операторы, вам больше не придется ничего менять. При необходимости можно добавить дополнительные #define-утверждения, подходящие для вашего эксперта.

Особенности свечи

У свечей есть особенности, которые полезны при разработке советника, особенно если советник основан на ценовом действии. Названия следующих определений говорят о том, что они собой представляют. WICK относится к тени верхней свечи, а TAIL - к тени нижней свечи. Пример: чтобы получить цену в середине тела последней свечи, используйте CANDLEBODYMIDDLE(1).

// особенности свечи
#define  CANDLEBODYTOP(i)      fmax(CANDLEOPEN(i),CANDLECLOSE(i))
#define  CANDLEBODYBOT(i)      fmin(CANDLEOPEN(i),CANDLECLOSE(i))
#define  CANDLEMEDIAN(i)       (0.5*(CANDLEHIGH(i)+CANDLELOW(i)))
#define  CANDLEWEIGHTED(i)     (0.25*(CANDLEHIGH(i)+CANDLELOW(i)+2*CANDLECLOSE(i)))
#define  CANDLETYPICAL(i)      (1./3.*(CANDLEHIGH(i)+CANDLELOW(i)+CANDLECLOSE(i)))
#define  CANDLEBODYMIDDLE(i)   (0.5*(CANDLEBODYTOP(i)+CANDLEBODYBOT(i)))
#define  CANDLESIZE(i)         (CANDLEHIGH(i)-CANDLELOW(i))
#define  CANDLEBODYSIZE(i)     fabs(CANDLECLOSE(i)-CANDLEOPEN(i))
#define  CANDLEWICKSIZE(i)     (CANDLEHIGH(i)-CANDLEBODYTOP(i))
#define  CANDLETAILSIZE(i)     (CANDLEBODYBOT(i)-CANDLELOW(i))

Кроме того, мы определяем два размера, используя ATR в качестве ссылки. Пример: вы хотите узнать, насколько велика свеча 4 по отношению к ATR, используйте ATRCANDLESIZE(4).

#define  ATRCANDLESIZE(i)      (CANDLESIZE(i)/ATR(i))
#define  ATRCANDLEBODYSIZE(i)  (CANDLEBODYSIZE(i)/ATR(i))

Кроме того, свечи, которые идут вверх (close>open), имеют направление +1, а свечи, идущие вниз, -1. Если close==open, направление = 0. Пример: if(CANDLEDIRECTION(10)==1) Print("Свеча 10 - свеча вверх");

#define  CANDLEDIRECTION(i)    (CANDLECLOSE(i)>CANDLEOPEN(i)?1:(CANDLECLOSE(i)<CANDLEOPEN(i)?-1:0))

Определены два типа "прогонов": UP и DOWN. RunUP определяется на восходящей свече как Close-Low, иначе 0. RunDOWN определяется на нисходящей свече как High-Close, иначе 0; "Прогоны" полезны для фиксации сильного движения цены в одном направлении. Например, чтобы получить разбег свечи 3, используйте CANDLERUNUP(3).

#define  CANDLERUNUP(i)        ((CANDLECLOSE(i)>CANDLEOPEN(i))?(CANDLECLOSE(i)-CANDLELOW(i)):0)
#define  CANDLERUNDOWN(i)      ((CANDLECLOSE(i)<CANDLEOPEN(i))?(CANDLEHIGH(i)-CANDLECLOSE(i)):0)

Запросы по функциям свечей

Эти определения представляют собой булевы переменные, которые сообщают нам о поведении одной или группы свечей. Они используют предыдущие операторы #define, чтобы сделать их короткими по длине.

isCANDLERIGHTDIR(i,dir) будет истиной, если направление свечи(i) равно dir, иначе - ложью;

Существует два типа фракталов: один использует пять свечей, а другой (слабый фрактал) - три свечи. В приведенных ниже определениях фракталов свеча(i) - это средняя свеча, имеющая самый высокий максимум (TOP) или самый низкий минимум (BOT). Убедитесь, что есть данные для свечей i-2,i-1,i,i+1,i+2 для фракталов с пятью свечами. Существуют также другие вариации с использованием строгих неравенств ">" или "<", а также с использованием "<=" или ">=". Наконец, есть #определения для идентификации верхних (TOP) или нижних (BOT) фракталов. Посмотрев на определения, вы сможете понять, какое определение использовать.

is3CANDLEGAPUP(i,gap,size) используется для поиска UP-гэпа (когда максимум свечи находится ниже минимума двух свечей позже). Свеча(i) будет самой новой из трех рассматриваемых свечей. Опять же, предполагается, что свечи являются "AsSeries". "gap" - это минимальная цена-дельта гэпа, а "size" - минимальная цена-дельта среднего размера тела свечи.

is3CANDLEGAPDOWN(i,gap,size) используется для поиска разрыва ВНИЗ, используя ту же логику.

is3CANDLEGAPUPTREND(i,gap,size) - то же самое, что и is3CANDLEGAPUP(i,gap,size), но добавляется дополнительное условие: самая старая из трех свечей должна быть положительного направления.

Есть два способа узнать, является ли свеча дожи: isCANDLEDOJIPOINTS(i,n) и isCANDLEDOJIFRACTION(i,f). В первом варианте используется n*_Point, а во втором - f*CANDLESIZE(i), чтобы определить, является ли свеча доджи (истинной или ложной).

Пример: если вы хотите узнать, является ли свеча 20 нестрогой (с использованием равенств) фрактальной вершиной, используйте isCANDLEFRACTALEQTOP(20), и результатом будет true или false.

Как видите, определения представляют собой сжатую форму запросов, что делает код вашего советника короче и легче для чтения.

// Запросы о свойствах свечи (булево)
#define  isCANDLEUP(i)               (CANDLEDIRECTION(i)==1)
#define  isCANDLEDOWN(i)             (CANDLEDIRECTION(i)==-1)
#define  isCANDLEFLAT(i)             (CANDLEDIRECTION(i)==0)
#define  isCANDLEWICKLESS(i)         (CANDLEWICKSIZE(i)==0)
#define  isCANDLETAILLESS(i)         (CANDLETAILSIZE(i)==0)
#define  isCANDLESOLID(i)            (CANDLEWICKSIZE(i)==0 && CANDLETAILSIZE(i)==0)
#define  isCANDLERIGHTDIR(i,dir)     (dir*(CANDLECLOSE(i) - CANDLEOPEN(i))>0)
#define  isCANDLEFRACTALTOP(i)       (CANDLEHIGH(i) > CANDLEHIGH(i-1) && CANDLEHIGH(i-1) > CANDLEHIGH(i-2) && CANDLEHIGH(i) > CANDLEHIGH(i+1) && CANDLEHIGH(i+1) > CANDLEHIGH(i+2))
#define  isCANDLEFRACTALBOT(i)       (CANDLELOW(i) < CANDLELOW(i-1) && CANDLELOW(i-1) < CANDLELOW(i-2) && CANDLELOW(i) < CANDLELOW(i+1) && CANDLELOW(i+1) < CANDLELOW(i+2))
#define  isCANDLEFRACTALEQTOP(i)     (CANDLEHIGH(i) >= CANDLEHIGH(i-1) && CANDLEHIGH(i-1) >= CANDLEHIGH(i-2) && CANDLEHIGH(i) >= CANDLEHIGH(i+1) && CANDLEHIGH(i+1) >= CANDLEHIGH(i+2))
#define  isCANDLEFRACTALEQBOT(i)     (CANDLELOW(i) <= CANDLELOW(i-1) && CANDLELOW(i-1) <= CANDLELOW(i-2) && CANDLELOW(i) <= CANDLELOW(i+1) && CANDLELOW(i+1) <= CANDLELOW(i+2))
#define  isCANDLEWEAKFRACTALTOP(i)   (CANDLEHIGH(i) > CANDLEHIGH(i-1) && CANDLEHIGH(i) > CANDLEHIGH(i+1))
#define  isCANDLEWEAKFRACTALBOT(i)   (CANDLELOW(i) < CANDLELOW(i-1) && CANDLELOW(i) < CANDLELOW(i+1))
#define  isCANDLEWEAKFRACTALEQBOT(i) (CANDLELOW(i) <= CANDLELOW(i-1) && CANDLELOW(i) <= CANDLELOW(i+1))
#define  isCANDLEWEAKFRACTALEQTOP(i) (CANDLEHIGH(i) >= CANDLEHIGH(i-1) && CANDLEHIGH(i) >= CANDLEHIGH(i+1))
#define  is3CANDLEGAPUP(i,gap,size)  (CANDLELOW(i)-CANDLEHIGH(i+2)>gap && CANDLEBODYSIZE(i+1)>=size)
#define  is3CANDLEGAPDOWN(i,gap,size) (CANDLELOW(i+2)-CANDLEHIGH(i)>gap && CANDLEBODYSIZE(i+1)>=size)
#define  is3CANDLEGAPUPTREND(i,gap,size)  (CANDLELOW(i)-CANDLEHIGH(i+2)>gap && CANDLEBODYSIZE(i+1)>=size &&  isCANDLEUP(i+2))
#define  is3CANDLEGAPDOWNTREND(i,gap,size) (CANDLELOW(i+2)-CANDLEHIGH(i)>gap && CANDLEBODYSIZE(i+1)>=size &&  isCANDLEDOWN(i+2))
#define  isCANDLEDOJIPOINTS(i,n)     (CANDLEBODYSIZE(i) <= n*_Point)
#define  isCANDLEDOJIFRACTION(i,f)   (CANDLEBODYSIZE(i) <= f*CANDLESIZE(i))

Математические функции и операции

Теперь мы определим некоторые математические функции и операции, которые пригодятся в советнике. Некоторые из них характерны для разработанных мною советников, но вы можете изменить их или удалить по своему усмотрению.

BRACKET(x,minV,maxV) вернет значение x внутри интервала [minV,maxV]. Это полезно для ограничения входных переменных в советнике.

CONVEXCOMB(a,x1,x2) - выпуклая комбинация x1 и x2 в виде a*x1+x2. Эта функция полезна при вычислении промежуточного значения между x1 и x2, но вам нужно больше, чем просто среднее (a=0,5).

EVALLINE(x,x1,y1,x2,y2,ymin,ymax) - это оценка прямой линии, заданной двумя точками [x1,y1] и [x2,y2]. После оценки в точке x она возвращает заключенное в скобки значение внутри [ymin, ymax].

MAPAB11(x,A,B) переводит значение x из скобки [A,B] в скобку [-1,1]. MAP11AB(x,A,B) переводит значение x из скобки [-1,1] в скобку [A,B]. Эти две функции полезны для работы с нормализованными переменными в диапазоне [-1,1].

Последние четыре функции используются в моих советниках и, возможно, не всегда полезны для всех, но я оставил их на всякий случай.

#define  BRACKET(x,minV,maxV)                 (x<minV?minV:(x>maxV?maxV:x))
#define  CONVEXCOMB(a,x1,x2)                  (a*x1+(1.0-a)*x2)
#define  EVALLINE(x,x1,y1,x2,y2,ymin,ymax)    BRACKET((y2-y1)/(x2-x1)*(x-x1)+y1,ymin,ymax)
#define  MAPAB11(x,A,B)                       (2./(B-A)*(BRACKET(x,A,B)-A)-1.)
#define  MAP11AB(x,A,B)                       ((B-A)/2.*(BRACKET(x,-1,1)-1)+B)
#define  SIGMOID(x,a)                         (1.0/(1.0 + exp(-a*x)))
#define  NN1(x,w,b)                           (w*x+b)
#define  EVALPOLY(X,X0,X1,Y0,Y1,EX,ymin,ymax) BRACKET(Y1*pow((X-X0)/(X1-X0),EX)+Y0,ymin,ymax)
#define  EVALPOLY2P(X,X0,X1,Y0,Y1,EX,ymn,ymx) BRACKET((Y1-Y0)*pow((X-X0)/(X1-X0),EX)+Y0,ymn,ymx)

Также, в качестве функций и операций, есть расчеты разностей (как косвенный показатель наклонов).

MA20DIFF(i,n) дает разницу между двумя значениями 20-периодной скользящей средней, разделенными n свечами. Остальные функции работают по той же логике. Пример: чтобы вычислить разницу между 200-периодной скользящей средней на свече 3 и на свече 13, используйте MA200DIFF(3,10).

#define  MA20DIFF(i,n)                        (MOVAVG20(i)-MOVAVG20(i+n))
#define  MA40DIFF(i,n)                        (MOVAVG40(i)-MOVAVG40(i+n))
#define  MA50DIFF(i,n)                        (MOVAVG50(i)-MOVAVG50(i+n))
#define  MA200DIFF(i,n)                       (MOVAVG200(i)-MOVAVG200(i+n))
#define  CANDLECLOSEDIFF(i,n)                 (CANDLECLOSE(i)-CANDLECLOSE(i+n))
#define  CANDLEOPENDIFF(i,n)                  (CANDLEOPEN(i)-CANDLEOPEN(i+n))
#define  CANDLEHIGHDIFF(i,n)                  (CANDLEHIGH(i)-CANDLEHIGH(i+n))
#define  CANDLELOWDIFF(i,n)                   (CANDLELOW(i)-CANDLELOW(i+n))
#define  CANDLEMEDIANDIFF(i,n)                (CANDLEMEDIAN(i)-CANDLEMEDIAN(i+n))
#define  CANDLEWEIGHTEDDIFF(i,n)              (CANDLEWEIGHTED(i)-CANDLEWEIGHTED(i+n))
#define  CANDLETYPICALDIFF(i,n)               (CANDLETYPICAL(i)-CANDLETYPICAL(i+n))
#define  CANDLEBODYMIDDLEDIFF(i,n)            (CANDLEBODYMIDDLE(i)-CANDLEBODYMIDDLE(i+n))

Запросы также включены как математические функции. Брекетинг и выпуклость проверяются ниже.

#define  isINBRACKET(x,minV,maxV)             (x<=maxV && x>=minV)
#define  isINBRACKETSTRICT(x,minV,maxV)       (x<maxV && x> minV)
#define  isOUTBRACKET(x,minV,maxV)            (x>=maxV || x<=minV)
#define  isOUTBRACKETSTRICT(x,minV,maxV)      (x> maxV || x< minV)
#define  isCONVEX(yl,yc,yr)                   (yl>=yc && yc<=yr)
#define  isCONCAVE(yl,yc,yr)                  (yl<=yc && yc>=yr)
#define  isCONVEXTSTRICT(yl,yc,yr)            (yl>yc && yc<yr)
#define  isCONCAVESTRICT(yl,yc,yr)            (yl<yc && yc> yr)

Константы

Я определяю некоторые константы, которые я использую. Вам решать, использовать их или нет.

// Константы
#define  PIVALUE                              (M_PI)
#define  MINSTOPPOINTS                        (30)
#define  MINFREEZEPOINTS                      (30)
#define  STOPLEVEL                            (fmax(MINSTOPPOINTS,(double)SymbolInfoInteger(_Symbol,SYMBOL_TRADE_STOPS_LEVEL))*_Point)
#define  FREEZELEVEL                          (fmax(MINFREEZEPOINTS,(double)SymbolInfoInteger(_Symbol,SYMBOL_TRADE_FREEZE_LEVEL))*_Point)

Отладка

Любой опытный программист знает, что лучшим инструментом для отладки кода является оператор Print. Следующие определения позволяют установить операторы Print по всей вашей программе и включать/выключать их в зависимости от значения интересующего вас уровня отладки.

Сначала необходимо определить уровень отладки с помощью #define DEBUG_LEVEL0, #define DEBUG_LEVEL1 или #define DEBUG_LEVEL2. При использовании DEBUG_LEVEL0 печать на вкладке Journal в терминале Metatrader 5 будет отсутствовать. При использовании DEBUG_LEVEL1 будут активны только операторы PRINTVARn, которые будут печататься на вкладке Journal. При DEBUG_LEVEL2 на вкладке журнала будут печататься оба утверждения - PRINTVARn и VPRINTVARn. DEBUG_LEVEL2 - это "V"-разборчивый случай использования VPRINTVARn.

PRINTVARn выводит n переменных. Например, если вы хотите вывести i, x и z, используйте PRINTVAR3(i,x,z); Чтобы вывести строку, используйте PRINTTEXT("любая строка"); Распечатка будет включать имя функции и номер строки файла, в который вставлен оператор PRINTVARn.

// Отладка с помощью Print 
// В начале кода определите уровень отладки x={0,1,2}: #define DEBUG_LEVELx 
#ifdef  DEBUG_LEVEL0
#define  PRINTTEXT(text)
#define  PRINTVAR(x1)
#define  PRINTVAR1(x1)
#define  PRINTVAR2(x1,x2)
#define  PRINTVAR3(x1,x2,x3)
#define  PRINTVAR4(x1,x2,x3,x4)
#define  PRINTVAR5(x1,x2,x3,x4,x5)
#define  PRINTVAR6(x1,x2,x3,x4,x5,x6)

#define  VPRINTTEXT(text)
#define  VPRINTVAR(x1)
#define  VPRINTVAR1(x1)
#define  VPRINTVAR2(x1,x2)
#define  VPRINTVAR3(x1,x2,x3)
#define  VPRINTVAR4(x1,x2,x3,x4)
#define  VPRINTVAR5(x1,x2,x3,x4,x5)
#define  VPRINTVAR6(x1,x2,x3,x4,x5,x6)

#endif
                                                                                                
#ifdef  DEBUG_LEVEL1
#define  PRINTTEXT(text)           Print("*/*/*/* ",__FUNCTION__,"(",__LINE__,") :",text)
#define  PRINTVAR(x1)              Print("*/*/*/* ",__FUNCTION__,"(",__LINE__,") :", #x1 + "=", (x1))
#define  PRINTVAR1(x1)             Print("*/*/*/* ",__FUNCTION__,"(",__LINE__,") :", #x1 + "=", (x1))
#define  PRINTVAR2(x1,x2)          Print("*/*/*/* ",__FUNCTION__,"(",__LINE__,") :", #x1 + "=", (x1),", " #x2 + "=", (x2))
#define  PRINTVAR3(x1,x2,x3)       Print("*/*/*/* ",__FUNCTION__,"(",__LINE__,") :", #x1 + "=", (x1),", " #x2 + "=", (x2),", " #x3 + "=", (x3))
#define  PRINTVAR4(x1,x2,x3,x4)    Print("*/*/*/* ",__FUNCTION__,"(",__LINE__,") :", #x1 + "=", (x1),", " #x2 + "=", (x2),", " #x3 + "=", (x3),", " #x4 + "=", (x4))
#define  PRINTVAR5(x1,x2,x3,x4,x5) Print("*/*/*/* ",__FUNCTION__,"(",__LINE__,") :", #x1 + "=", (x1),", " #x2 + "=", (x2),", " #x3 + "=", (x3),", " #x4 + "=", (x4),", " #x5 + "=", (x5))
#define  PRINTVAR6(x1,x2,x3,x4,x5,x6) Print("*/*/*/* ",__FUNCTION__,"(",__LINE__,") :", #x1 + "=", (x1),", " #x2 + "=", (x2),", " #x3 + "=", (x3),", " #x4 + "=", (x4),", " #x5 + "=", (x5),", " #x6 + "=", (x6))

#define  VPRINTTEXT(text)
#define  VPRINTVAR(x1)
#define  VPRINTVAR1(x1)
#define  VPRINTVAR2(x1,x2)
#define  VPRINTVAR3(x1,x2,x3)
#define  VPRINTVAR4(x1,x2,x3,x4)
#define  VPRINTVAR5(x1,x2,x3,x4,x5)
#define  VPRINTVAR6(x1,x2,x3,x4,x5,x6)
#endif

#ifdef   DEBUG_LEVEL2
#define  PRINTTEXT(text)           Print("*/*/*/* ",__FUNCTION__,"(",__LINE__,") :",text)
#define  PRINTVAR(x1)              Print("*/*/*/* ",__FUNCTION__,"(",__LINE__,") :", #x1 + "=", (x1))
#define  PRINTVAR1(x1)             Print("*/*/*/* ",__FUNCTION__,"(",__LINE__,") :", #x1 + "=", (x1))
#define  PRINTVAR2(x1,x2)          Print("*/*/*/* ",__FUNCTION__,"(",__LINE__,") :", #x1 + "=", (x1),", " #x2 + "=", (x2))
#define  PRINTVAR3(x1,x2,x3)       Print("*/*/*/* ",__FUNCTION__,"(",__LINE__,") :", #x1 + "=", (x1),", " #x2 + "=", (x2),", " #x3 + "=", (x3))
#define  PRINTVAR4(x1,x2,x3,x4)    Print("*/*/*/* ",__FUNCTION__,"(",__LINE__,") :", #x1 + "=", (x1),", " #x2 + "=", (x2),", " #x3 + "=", (x3),", " #x4 + "=", (x4))
#define  PRINTVAR5(x1,x2,x3,x4,x5) Print("*/*/*/* ",__FUNCTION__,"(",__LINE__,") :", #x1 + "=", (x1),", " #x2 + "=", (x2),", " #x3 + "=", (x3),", " #x4 + "=", (x4),", " #x5 + "=", (x5))
#define  PRINTVAR6(x1,x2,x3,x4,x5,x6) Print("*/*/*/* ",__FUNCTION__,"(",__LINE__,") :", #x1 + "=", (x1),", " #x2 + "=", (x2),", " #x3 + "=", (x3),", " #x4 + "=", (x4),", " #x5 + "=", (x5),", " #x6 + "=", (x6))

#define  VPRINTTEXT(text)           Print("V/*/*/* ",__FUNCTION__,"(",__LINE__,") :",text)
#define  VPRINTVAR(x1)              Print("V/*/*/* ",__FUNCTION__,"(",__LINE__,") :", #x1 + "=", (x1))
#define  VPRINTVAR1(x1)             Print("V/*/*/* ",__FUNCTION__,"(",__LINE__,") :", #x1 + "=", (x1))
#define  VPRINTVAR2(x1,x2)          Print("V/*/*/* ",__FUNCTION__,"(",__LINE__,") :", #x1 + "=", (x1),", " #x2 + "=", (x2))
#define  VPRINTVAR3(x1,x2,x3)       Print("V/*/*/* ",__FUNCTION__,"(",__LINE__,") :", #x1 + "=", (x1),", " #x2 + "=", (x2),", " #x3 + "=", (x3))
#define  VPRINTVAR4(x1,x2,x3,x4)    Print("V/*/*/* ",__FUNCTION__,"(",__LINE__,") :", #x1 + "=", (x1),", " #x2 + "=", (x2),", " #x3 + "=", (x3),", " #x4 + "=", (x4))
#define  VPRINTVAR5(x1,x2,x3,x4,x5) Print("V/*/*/* ",__FUNCTION__,"(",__LINE__,") :", #x1 + "=", (x1),", " #x2 + "=", (x2),", " #x3 + "=", (x3),", " #x4 + "=", (x4),", " #x5 + "=", (x5))
#define  VPRINTVAR6(x1,x2,x3,x4,x5,x6) Print("V/*/*/* ",__FUNCTION__,"(",__LINE__,") :", #x1 + "=", (x1),", " #x2 + "=", (x2),", " #x3 + "=", (x3),", " #x4 + "=", (x4),", " #x5 + "=", (x5),", " #x6 + "=", (x6))
#endif