Useful #define statements - Skript für den MetaTrader 5

Definition der Variablen

// Kerze (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

Sie können auch die ASK- und BID-Werte mit MqlTick ermitteln, wie ich es unten getan habe, oder Sie können SymbolInfoDouble(_Symbol,SYMBOL_ASK) aufrufen, wenn Sie dies bevorzugen. Der zurückgegebene Wert ändert sich dadurch nicht.

// Preise (define g_tick as: MqlTick g_tick;))
#define  ASK             g_tick.ask
#define  BID             g_tick.bid

Schließlich werden auch Arrays für gleitende Durchschnitte, atr oder jedes zusätzliche Array, das Sie benötigen, definiert. Beispiel: Um die Average True Range von Kerze 1 zu verwenden, verwenden Sie ATR(1).
WICHTIG: Es wird angenommen, dass Arrays AsSeries sind ( z.B.ArraySetAsSeries(g_MA20_arr, true); ). Dies ist bei den später gezeigten #define-Anweisungen von entscheidender Bedeutung.

// Definieren Sie diese Arrays als: double g_MA20_arr[];
// Gleitende Durchschnitte und 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]

Sobald Sie die oben genannten Anweisungen definiert haben, sollten Sie nichts mehr ändern müssen. Zusätzliche #define-Anweisungen, die zu Ihrem EA passen, können Sie bei Bedarf hinzufügen.

Eigenschaften der Kerze

Kerzen verfügen über Funktionen, die bei der Entwicklung eines EA nützlich sind, insbesondere wenn der EA auf Kursbewegungen basiert. Die Namen der folgenden Definitionen geben an, wofür sie stehen. WICK bezieht sich auf den Schatten der oberen Kerze und TAIL auf den Schatten der unteren Kerze. Beispiel: Um den Preis in der Mitte des Körpers der letzten Kerze zu erhalten, verwenden Sie CANDLEBODYMIDDLE(1).

// Merkmale der Kerze
#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))

Darüber hinaus definieren wir zwei Größen, indem wir die ATR als Referenz verwenden. Beispiel: Wenn Sie wissen möchten, wie groß die Kerze 4 in Bezug auf die ATR ist, verwenden Sie ATRCANDLESIZE(4).

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

Außerdem haben Kerzen, die nach oben gehen (close>open), eine Richtung von +1, während Kerzen, die nach unten gehen, eine Richtung von -1 haben. Wenn close==open, ist die Richtung = 0. Beispiel: if(CANDLEDIRECTION(10)==1) Print("Candle 10 is an up candle");

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

Es werden zwei Arten von "Läufen" definiert: UP und DOWN. Der runUP ist bei einer aufsteigenden Kerze als Close-Low definiert, sonst 0. Der runDOWN ist bei einer absteigenden Kerze als High-Close definiert, sonst 0; "Runs" sind nützlich, um starke Kursbewegungen in einer Richtung zu erfassen. Beispiel: Um den Anstieg von Kerze 3 zu ermitteln, verwenden Sie 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)

Kerzenfunktion Abfragen

Bei diesen Definitionen handelt es sich um boolesche Variablen, die uns das Verhalten einer oder einer Gruppe von Kerzen mitteilen. Sie verwenden vorherige #define-Anweisungen, um sie kurz zu halten.

isCANDLERIGHTDIR(i,dir) ist wahr, wenn die Richtung der Kerze(i) gleich dir ist, sonst falsch;

Es gibt zwei Arten von Fraktalen: eines mit fünf Kerzen und ein anderes (das schwache Fraktal) mit drei Kerzen. In den folgenden Fraktal-Definitionen ist die Kerze(i) die mittlere Kerze mit dem höchsten Hoch (TOP) oder dem niedrigsten Tief (BOT). Stellen Sie sicher, dass die Daten für die Kerzen i-2,i-1,i,i+1,i+2 für die Fünf-Kerzen-Fraktale vorhanden sind. Es gibt auch andere Varianten, bei denen die strenge Ungleichheit ">" oder "<" verwendet wird, sowie die Verwendung von "<=" oder ">=". Schließlich gibt es noch #Definitionen zur Kennzeichnung von Top- (TOP) oder Bottom-Fraktalen (BOT). Anhand der Definitionen können Sie herausfinden, welche Definition Sie verwenden sollten.

is3CANDLEGAPUP(i,gap,size) wird verwendet, um eine UP-Lücke zu finden (bei der der Höchststand einer Kerze unter dem Tiefststand von zwei Kerzen später liegt). Kerze(i) ist die jüngste der drei in Frage kommenden Kerzen. Auch hier wird davon ausgegangen, dass die Kerzen "AsSeries" sind. "Lücke" ist das minimale Preis-Delta der Lücke, und "Größe" ist das minimale Preis-Delta der mittleren Kerzenkörpergröße.

is3CANDLEGAPDOWN(i,gap,size) wird verwendet, um eine DOWN-Lücke mit der gleichen Logik zu finden.

is3CANDLEGAPUPTREND(i,gap,size) entspricht is3CANDLEGAPUP(i,gap,size), fügt jedoch eine zusätzliche Bedingung hinzu: Die älteste der drei Kerzen muss in eine positive Richtung weisen.

Es gibt zwei Möglichkeiten, um festzustellen, ob eine Kerze ein Doji ist: isCANDLEDOJIPOINTS(i,n) und isCANDLEDOJIFRACTION(i,f). Die erste Version verwendet n*_Point und die zweite verwendet f*CANDLESIZE(i), um festzustellen, ob die Kerze ein Doji ist oder nicht (wahr oder falsch).

Beispiel: Wenn Sie wissen möchten, ob die Kerze 20 ein nicht-striktes (unter Verwendung von Gleichheiten) fraktales Top ist, verwenden Sie isCANDLEFRACTALEQTOP(20), und die Ausgabe wird wahr oder falsch sein.

Wie Sie sehen, sind die Definitionen eine komprimierte Form der Anfragen, wodurch Ihr EA-Code kürzer und leichter zu lesen ist.

// Kerzenmerkmal Abfragen (boolesch)
#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))

Mathematische Funktionen und Operationen

Wir definieren nun einige mathematische Funktionen und Operationen, die im EA nützlich sind. Einige von ihnen sind spezifisch für die von mir entwickelten EAs, aber Sie können sie ändern oder löschen, wenn Sie es wünschen.

BRACKET(x,minV,maxV) gibt einen Wert von x innerhalb des Intervalls [minV,maxV] zurück. Dies ist nützlich, um die Eingabevariablen im EA einzugrenzen.

CONVEXCOMB(a,x1,x2) ist eine konvexe Kombination von x1 und x2 als a*x1+x2. Diese Funktion ist nützlich, wenn man einen Zwischenwert zwischen x1 und x2 berechnen will, aber mehr als nur den Durchschnitt (a=0,5).

EVALLINE(x,x1,y1,x2,y2,ymin,ymax) ist die Auswertung einer Geraden, die durch zwei Punkte [x1,y1] und [x2,y2] definiert ist. Nach der Auswertung an der Stelle x gibt sie einen Klammerwert innerhalb von [ymin, ymax] zurück.

MAPAB11(x,A,B) bildet den Wert x von einer Klammer [A,B] auf eine Klammer [-1,1] ab. MAP11AB(x,A,B) bildet den Wert x von einer Klammer [-1,1] auf eine Klammer [A,B] ab. Diese beiden Funktionen sind nützlich, um mit normalisierten Variablen im Bereich von [-1,1] zu arbeiten.

Die letzten vier Funktionen werden in meinen EAs verwendet und sind vielleicht nicht unbedingt für jeden nützlich, aber ich habe sie für den Fall der Fälle dort gelassen.

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

Außerdem gibt es als Funktion und Operationen Berechnungen von Differenzen (als Ersatz für Steigungen).

MA20DIFF(i,n) gibt die Differenz zwischen den beiden Werten des gleitenden Durchschnitts über 20 Perioden im Abstand von n Kerzen an. Die übrigen Funktionen folgen der gleichen Logik. Beispiel: Um die Differenz zwischen dem gleitenden 200-Perioden-Durchschnitt bei Kerze 3 und bei Kerze 13 zu berechnen, verwenden Sie 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))

Abfragen sind ebenfalls als mathematische Funktionen enthalten. Die Klammerung und Konvexität wird unten überprüft.

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

Konstanten

Ich definiere einige Konstanten, die ich verwende. Es ist Ihre Entscheidung, sie zu verwenden.

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

Fehlersuche

Jeder erfahrene Programmierer weiß, dass das beste Werkzeug zum Debuggen Ihres Codes die Print-Anweisung ist. Mit den folgenden Definitionen können Sie Print-Anweisungen in Ihrem gesamten Programm einrichten und sie je nach gewünschtem Debugging-Level ein- und ausschalten.

Zunächst müssen Sie den Debugging-Level mit #define DEBUG_LEVEL0, #define DEBUG_LEVEL1 oder #define DEBUG_LEVEL2 definieren . Wenn Sie DEBUG_LEVEL0 verwenden , wird auf der Registerkarte "Journal" des Metatrader 5-Terminals kein Ausdruck erfolgen. Mit DEBUG_LEVEL1 sind nur die PRINTVARn-Anweisungen aktiv und werden auf der Registerkarte Journal gedruckt. Mit DEBUG_LEVEL2 werden sowohl die PRINTVARn- als auch die VPRINTVARn-Anweisungen auf der Journal-Registerkarte gedruckt. DEBUG_LEVEL2 ist der "V "erbose-Fall mit VPRINTVARn.

PRINTVARn druckt n Variablen. Wenn Sie beispielsweise i, x und z ausdrucken möchten, verwenden Sie PRINTVAR3(i,x,z); um eine Zeichenkette zu drucken, verwenden Sie PRINTTEXT("beliebige Zeichenkette"); Der Ausdruck enthält den Funktionsnamen und die Zeilennummer der Datei, in die die PRINTVARn-Anweisung eingefügt wurde.

// Fehlersuche mit Print 
// Definieren Sie am Anfang Ihres Codes den Debug-Level x={0,1,2} als: #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