Useful #define statements - MetaTrader 5 için komut dosyası

Değişkenlerin tanımı

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

Ayrıca, ASK ve BID değerlerini aşağıda yaptığım gibi MqlTick kullanarak alabilir veya tercih ederseniz SymbolInfoDouble(_Symbol,SYMBOL_ASK) çağırabilirsiniz. Döndürülen değerde herhangi bir fark yaratmaz.

// Fiyatlar (g_tick as: MqlTick g_tick;) olarak tanımlayın)
#define  ASK             g_tick.ask
#define  BID             g_tick.bid

Son olarak, diziler hareketli ortalamalar, atr veya ihtiyacınız olan herhangi bir ek dizi için de tanımlanır. Örnek: Mum 1'in Ortalama GerçekAralığını kullanmak için ATR(1) kullanın.
ÖNEMLİ: dizilerin AsSeries olduğu varsayılır (örneğin,ArraySetAsSeries(g_MA20_arr, true); ). Bu, daha sonra gösterilen #define ifadelerinde kritik öneme sahiptir.

// bu dizileri şu şekilde tanımlayın: double g_MA20_arr[];
// Hareketli ortalamalar ve 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]

Yukarıdaki ifadeleri tanımladıktan sonra, başka bir şeyi değiştirmeniz gerekmeyecektir. Gerekirse EA'nıza uygun ek #define ifadeleri de eklenebilir.

Mum Özellikleri

Mumlar, özellikle EA fiyat-eylem tabanlı ise, bir EA geliştirirken yararlı olan özelliklere sahiptir. Aşağıdaki tanımların adları neyi temsil ettiklerini anlatır. WICK üst mumun gölgesini ve TAIL alt mumun gölgesini ifade eder. Örnek: son mumun gövdesinin ortasındaki fiyatı almak için CANDLEBODYMIDDLE(1) kullanın.

// mum özellikleri
#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))

Ek olarak, ATR'yi referans olarak kullanarak iki boyut tanımlarız. Örnek: 4 numaralı mumun Atr'ye göre ne kadar büyük olduğunu bilmek istiyorsanız ATRCANDLESIZE(4) kullanın.

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

Ayrıca, yukarı giden mumların (kapanış>açık) +1 yöne sahip olduğu söylenirken, aşağı giden mumlar -1'dir. kapanış==açık ise, yön = 0. Örnek: 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))

İki tür "çalışma" tanımlanmıştır: YUKARI ve AŞAĞI. YUKARI koşu, yukarı giden bir mumda Kapanış-Düşük olarak tanımlanır, aksi takdirde 0. AŞAĞI koşu, aşağı giden bir mumda Yüksek-Kapanış olarak tanımlanır, aksi takdirde 0; "Koşular", fiyatta tek yönde güçlü hareketi yakalamak için kullanışlıdır. Örnek olarak, 3 numaralı mumun yükselişini almak için CANDLERUNUP(3) kullanın.

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

Mum Özelliği Soruları

Bu tanımlar, bize bir veya bir grup mumun davranışını söyleyen Boolean değişkenleridir. Kısa olması için önceki #define ifadelerini kullanırlar.

isCANDLERIGHTDIR(i,dir), mum(i) yönü dir'e eşitse doğru, aksi takdirde yanlış olacaktır;

İki tür fraktal vardır: biri beş mum kullanan ve diğeri (zayıf fraktal) üç mum kullanan. Aşağıdaki fraktal #tanımlarında mum (i), en yüksek (TOP) veya en düşük (BOT) olan ortadaki mumdur. Beş mumluk fraktallar için i-2,i-1,i,i+1,i+2 mumları için veri olduğundan emin olun. ">" veya "<" katı eşitsizliğini kullanan ve "<=" veya ">=" kullanan başka varyasyonlar da vardır. Son olarak, üst (TOP) veya alt (BOT) fraktalları tanımlamak için #tanımlar vardır. Tanımlara bakarak hangi tanımı kullanacağınızı anlayabilirsiniz.

is3CANDLEGAPUP(i,gap,size) bir YUKARI boşluk bulmak için kullanılır (bir mumun en yüksek değeri iki mum sonrasının en düşük değerinin altındadır). Candle(i), söz konusu üç mumdan en yenisi olacaktır. Yine, mumların "AsSeries" olduğu varsayılmaktadır. "boşluk" boşluğun minimum fiyat-deltasıdır ve "boyut" orta mum gövde boyutunun minimum fiyat-deltasıdır.

is3CANDLEGAPDOWN(i,gap,size) aynı mantığı kullanarak bir AŞAĞI boşluk bulmak için kullanılır.

is3CANDLEGAPUPTREND(i,gap,size ) is3CANDLEGAPUP(i,gap,size) ile aynıdır ancak doğru olması için ek bir koşul ekler: üç mumdan en eskisinin pozitif yönde olması gerekir.

Bir mumun doji olup olmadığını sorgulamanın iki yolu vardır: isCANDLEDOJIPOINTS(i,n) ve isCANDLEDOJIFRACTION(i,f). İlk versiyonda n*_Point, ikincisinde ise f*CANDLESIZE(i) kullanılarak mumun Doji olup olmadığı (doğru ya da yanlış) belirlenir.

Örnek: 20 numaralı mumun katı olmayan (eşitlikler kullanılarak) bir fraktal tepe olup olmadığını bilmek istiyorsanız isCANDLEFRACTALEQTOP(20) kullanın; çıktı doğru veya yanlış olacaktır.

Gördüğünüz gibi, tanımlar sorgulamaların sıkıştırılmış bir şeklidir ve EA kodunuzu daha kısa ve okunması kolay hale getirir.

// mum özelliği sorgulamaları (boolean)
#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))

Matematik Fonksiyonları ve İşlemleri

Şimdi EA'da yararlı olan bazı matematiksel fonksiyonları ve işlemleri tanımlıyoruz. Bazıları benim geliştirdiğim EA'lara özeldir, ancak isterseniz bunları değiştirebilir veya silebilirsiniz.

BRACKET(x,minV,maxV) [minV,maxV] aralığı içinde bir x değeri döndürür. Bu, EA'daki girdi değişkenlerini kutularla sınırlamak için kullanışlıdır.

CONVEXCOMB(a,x1,x2), x1 ve x2'nin a*x1+x2 şeklinde konveks bir kombinasyonudur. Bu fonksiyon, x1 ve x2 arasında bir ara değer hesaplarken kullanışlıdır, ancak ortalamadan daha fazlasını istersiniz (a=0,5).

EVALLINE(x,x1,y1,x2,y2,ymin,ymax) iki nokta [x1,y1] ve [x2,y2] tarafından tanımlanan düz bir çizginin değerlendirilmesidir. x'te değerlendirildikten sonra, [ymin, ymax] içinde parantezli bir değer döndürür.

MAPAB11(x,A,B) x değerini [A,B] köşeli ayraçtan [-1,1] köşeli ayraçla eşler. MAP11AB(x,A,B) x değerini [-1,1] parantezinden [A,B] parantezine eşler. Bu iki fonksiyon [-1,1] aralığında normalleştirilmiş değişkenlerle çalışmak için kullanışlıdır.

Son dört işlev benim EA'larımda kullanılır ve herkes için genel olarak yararlı olmayabilir, ancak her ihtimale karşı onları orada bıraktım.

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

Ayrıca, fonksiyon ve işlemler olarak, fark hesaplamaları (eğimler için bir vekil olarak) vardır.

MA20DIFF(i,n), 20 dönemlik hareketli ortalamanın n mumla ayrılmış iki değeri arasındaki farkı verir. Diğer fonksiyonlar da aynı mantığı izler. Örnek: 3. mumdaki 200 dönemlik hareketli ortalama ile 13. mumdaki hareketli ortalama arasındaki farkı hesaplamak için MA200DIFF(3,10) kullanın.

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

Sorgular da matematiksel fonksiyonlar olarak dahil edilmiştir. Parantezleme ve dışbükeylik aşağıda kontrol edilmiştir.

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

Sabitler

Ben kullandığım bazı sabitleri tanımlıyorum. Bunları kullanmak sizin seçiminizdir.

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

Hata Ayıklama

Her deneyimli programcı, kodunuzda hata ayıklamak için en iyi aracın Print deyimi olduğunu bilir. Aşağıdaki tanımlar, programınızın her yerinde Print deyimlerini ayarlamanıza ve ilgilendiğiniz hata ayıklama seviyesinin değerine bağlı olarak bunları AÇIK/KAPALI hale getirmenize olanak tanır.

Öncelikle, #define DEBUG_LEVEL0, #define DEBUG_LEVEL1 veya #define DEBUG_LEVEL2 kullanarak hata ayıklama düzeyini tanımlamanız gerekir. DEBUG_LEVEL0 kullanıldığında , Metatrader 5 terminalinin Journal sekmesinde herhangi bir yazdırma olmayacaktır. DEBUG_LEVEL1 ile, yalnızca PRINTVARn ifadeleri etkin olacak ve Journal sekmesine yazdırılacaktır. DEBUG_LEVEL2 ile , hem PRINTVARn hem de VPRINTVARn ifadeleri günlük sekmesine yazdırılır. DEBUG_LEVEL2, VPRINTVARn kullanan "V "erbose durumudur.

PRINTVARn n adet değişkeni yazdıracaktır. Örneğin, i, x ve z değerlerini yazdırmak istiyorsanız PRINTVAR3(i,x,z); Bir dize yazdırmak için PRINTTEXT("any string"); Çıktı, işlev adını ve PRINTVARn deyiminin eklendiği dosyanın satır numarasını içerecektir.

// Print ile Hata Ayıklama 
// Kodunuzun başında hata ayıklama seviyesini x={0,1,2} olarak tanımlayın: #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