Useful #define statements - script per MetaTrader 5

Definizione delle variabili

// Candela (definire g_rates come: 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

Inoltre, è possibile ottenere i valori ASK e BID utilizzando MqlTick, come ho fatto di seguito, oppure chiamare SymbolInfoDouble(_Symbol,SYMBOL_ASK) se si preferisce. Il valore restituito non fa alcuna differenza.

// Prezzi (definire g_tick come: MqlTick g_tick;))
#define  ASK             g_tick.ask
#define  BID             g_tick.bid

Infine, vengono definiti anche gli array per le medie mobili, gli atr o qualsiasi altro array necessario. Esempio: per utilizzare l'Average True Range della candela 1, utilizzare ATR(1).
IMPORTANTE: si presume che gli array siano AsSeries (ad esempio,ArraySetAsSeries(g_MA20_arr, true); ). Questo è fondamentale nelle dichiarazioni #define mostrate in seguito.

// definire questi array come: double g_MA20_arr[];
// Medie mobili e 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]

Una volta definite le dichiarazioni di cui sopra, non dovrebbe essere necessario modificare nient'altro. Se necessario, si possono aggiungere altre dichiarazioni #define adatte al proprio EA.

Caratteristiche delle candele

Le candele hanno caratteristiche utili per lo sviluppo di un EA, soprattutto se l'EA è basato sull'azione dei prezzi. I nomi delle seguenti definizioni indicano cosa rappresentano. WICK si riferisce all'ombra della candela superiore e TAIL all'ombra della candela inferiore. Esempio: per ottenere il prezzo al centro del corpo dell'ultima candela, utilizzare CANDLEBODYMIDDLE(1).

// caratteristiche della candela
#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))

Inoltre, definiamo due dimensioni utilizzando l'ATR come riferimento. Esempio: per sapere quanto è grande la candela 4 rispetto all'ATR, utilizzare ATRCANDLESIZE(4).

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

Inoltre, le candele che salgono (chiusura>apertura) hanno una direzione +1, mentre le candele che scendono hanno una direzione -1. Se chiusura==apertura, direzione = 0. Esempio: if(CANDLEDIRECTION(10)==1) Print("La candela 10 è una candela up");

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

Sono definiti due tipi di "corse": UP e DOWN. Il runUP è definito in una candela in salita come Close-Low, altrimenti 0. Il runDOWN è definito in una candela in discesa come High-Close, altrimenti 0. I "run" sono utili per catturare un forte movimento del prezzo in una direzione. Ad esempio, per ottenere il run-up della candela 3, utilizzare 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)

Inchieste sulle caratteristiche delle candele

Queste definizioni sono variabili booleane che indicano il comportamento di una o di un gruppo di candele. Utilizzano le precedenti dichiarazioni #define per renderle di lunghezza ridotta.

isCANDLERIGHTDIR(i,dir) sarà vero se la direzione della candela(i) è uguale a dir, altrimenti falso;

Esistono due tipi di frattali: uno che utilizza cinque candele e un altro (il frattale debole) che utilizza tre candele. Nelle #definizioni dei frattali qui sotto, la candela(i) è la candela centrale che ha il massimo (TOP) o il minimo (BOT). Assicuratevi che ci siano dati per le candele i-2,i-1,i,i+1,i+2 per i frattali a cinque candele. Esistono anche altre varianti che utilizzano la disuguaglianza rigorosa ">" o "<", e che utilizzano "<=" o ">=". Infine, ci sono delle #definizioni per identificare i frattali superiori (TOP) o inferiori (BOT). Osservando le definizioni si può capire quale definizione utilizzare.

is3CANDLEGAPUP(i,gap,size) viene utilizzato per trovare un gap UP (dove il massimo di una candela è inferiore al minimo di due candele successive). La candela(i) sarà la più recente delle tre candele in questione. Anche in questo caso, si presume che le candele siano "AsSeries". "gap" è il prezzo-delta minimo del gap e "size" è il prezzo-delta minimo del corpo della candela centrale.

is3CANDLEGAPDOWN(i,gap,size) viene utilizzato per trovare un gap DOWN utilizzando la stessa logica.

is3CANDLEGAPUPTREND(i,gap,size) è uguale a is3CANDLEGAPUP(i,gap,size) ma aggiunge un'ulteriore condizione per essere vero: la più vecchia delle tre candele deve avere una direzione positiva.

Esistono due modi per verificare se una candela è una doji: isCANDLEDOJIPOINTS(i,n) e isCANDLEDOJIFRACTION(i,f). La prima versione utilizza n*Punto e la seconda utilizza f*CANDLESIZE(i) per determinare se la candela sia o meno (vera o falsa) una Doji.

Esempio: se si vuole sapere se la candela 20 è un top frattale non rigido (che utilizza le uguaglianze), utilizzare isCANDLEFRACTALEQTOP(20) e il risultato sarà vero o falso.

Come potete vedere, le definizioni sono una forma compressa delle richieste, che rende il codice dell'EA più breve e più facile da leggere.

// ricerca della caratteristica della candela (booleano)
#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))

Funzioni e operazioni matematiche

Definiamo ora alcune funzioni e operazioni matematiche utili per l'EA. Alcune di esse sono specifiche per gli EA che ho sviluppato, ma potete modificarle o eliminarle se lo desiderate.

BRACKET(x,minV,maxV) restituisce un valore di x all'interno dell'intervallo [minV,maxV]. È utile per limitare le variabili di input nell'EA.

CONVEXCOMB(a,x1,x2) è una combinazione convessa di x1 e x2 come a*x1+x2. Questa funzione è utile quando si calcola un valore intermedio tra x1 e x2, ma non si vuole solo la media (a=0,5).

EVALLINE(x,x1,y1,x2,y2,ymin,ymax) è la valutazione di una retta definita da due punti [x1,y1] e [x2,y2]. Una volta valutata su x, restituisce un valore tra parentesi all'interno di [ymin, ymax].

MAPAB11(x,A,B) mappa il valore x da una parentesi [A,B] a una parentesi [-1,1]. MAP11AB(x,A,B) mappa il valore x da una parentesi [-1,1] a una parentesi [A,B]. Queste due funzioni sono utili per lavorare con variabili normalizzate nell'intervallo [-1,1].

Le ultime quattro funzioni sono utilizzate nei miei EA e non è detto che siano genericamente utili per tutti, ma le ho lasciate lì, per sicurezza.

#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)

Inoltre, come funzioni e operazioni, sono presenti i calcoli delle differenze (come proxy delle pendenze).

MA20DIFF(i,n) fornisce la differenza tra i due valori della media mobile a 20 periodi separati da n candele. Le altre funzioni seguono la stessa logica. Esempio: per calcolare la differenza tra la media mobile a 200 periodi alla candela 3 e alla candela 13, utilizzare 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))

Anche le indagini sono incluse come funzioni matematiche. La parentesi e la convessità vengono controllate di seguito.

#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)

Costanti

Definisco alcune costanti che utilizzo. La scelta di usarle è vostra.

// Costanti
#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)

Debug

Ogni programmatore esperto sa che il miglior strumento per il debug del codice è l'istruzione Print. Le seguenti definizioni consentono di impostare gli statement Print in tutto il programma e di attivarli/disattivarli a seconda del livello di debug desiderato.

Innanzitutto, è necessario definire il livello di debug utilizzando #define DEBUG_LEVEL0, #define DEBUG_LEVEL1 o #define DEBUG_LEVEL2. Quando si utilizza DEBUG_LEVEL0, non ci sarà alcuna stampa nella scheda Journal del terminale Metatrader 5. Con DEBUG_LEVEL1, solo le istruzioni PRINTVARn saranno attive e verranno stampate sulla scheda Journal. Con DEBUG_LEVEL2, entrambe le istruzioni PRINTVARn e VPRINTVARn verranno stampate sulla scheda Journal. DEBUG_LEVEL2 è il caso "V "erboso che utilizza VPRINTVARn.

PRINTVARn stamperà n variabili. Ad esempio, se si desidera stampare i, x e z, utilizzare PRINTVAR3(i,x,z); per stampare una stringa, utilizzare PRINTTEXT("qualsiasi stringa"); la stampa includerà il nome della funzione e il numero di riga del file in cui è inserita l'istruzione PRINTVARn.

// Debug con la stampa 
// All'inizio del codice, definire il livello di debug x={0,1,2} come: #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