Useful #define statements - script para MetaTrader 5

Definición de variables

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

Además, puede obtener los valores ASK y BID utilizando MqlTick como hice a continuación, o puede llamar a SymbolInfoDouble(_Symbol,SYMBOL_ASK) si lo prefiere. No hay ninguna diferencia en el valor devuelto.

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

Por último, también se definen arrays para medias móviles, atr, o cualquier array adicional que necesites. Ejemplo: para utilizar el Average True Range de la vela 1, utilice ATR(1).
IMPORTANTE: se asume que las matrices son AsSeries ( por ejemplo,ArraySetAsSeries(g_MA20_arr, true); ). Esto es crítico en las declaraciones #define que se muestran más adelante.

// define estas matrices como: double g_MA20_arr[];
// Medias móviles y 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 vez definidas las sentencias anteriores, no debería ser necesario cambiar nada más. Declaraciones #define adicionales que se ajusten a su EA también podrían ser añadidas si lo necesita.

Características de la vela

Las velas tienen características que son útiles cuando se desarrolla un EA, especialmente si el EA está basado en la acción del precio. Los nombres de las siguientes definiciones indican lo que representan. WICK se refiere a la sombra de la vela superior y TAIL a la sombra de la vela inferior. Ejemplo: para obtener el precio en la mitad del cuerpo de la última vela, utilice CANDLEBODYMIDDLE(1).

// características de la vela
#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))

Además, definimos dos tamaños utilizando el ATR como referencia. Ejemplo: quieres saber cómo de grande es la vela 4 respecto al Atr, usa ATRCANDLESIZE(4).

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

Además, se dice que las velas que van hacia arriba (cierre>apertura) tienen una dirección +1, mientras que las velas que van hacia abajo tienen -1. Si cierre==apertura, dirección = 0. Ejemplo: if(CANDLEDIRECTION(10)==1) Print("La vela 10 es una vela alcista");

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

Se definen dos tipos de "ejecuciones": ARRIBA y ABAJO. El runUP se define en una vela alcista como Close-Low, en caso contrario 0. El runDOWN se define en una vela bajista como High-Close, en caso contrario 0; Los "Runs" se utilizan para capturar movimientos fuertes del precio en una dirección. Ejemplo, para obtener el run-up de la vela 3, utilice 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)

Consultas sobre las características de las velas

Estas definiciones son variables booleanas que nos indican el comportamiento de una o un grupo de velas. Utilizan declaraciones #define previas para que su longitud sea corta.

isCANDLERIGHTDIR(i,dir) será verdadero si la dirección de la vela(i) es igual a dir, en caso contrario será falso;

Hay dos tipos de fractales: uno que utiliza cinco velas y otro (el fractal débil) que utiliza tres velas. En las #definiciones de fractal de abajo la vela(i) es la vela del medio que tiene el máximo más alto (TOP) o el mínimo más bajo (BOT). Asegúrese de que hay datos para las velas i-2,i-1,i,i+1,i+2 para los fractales de cinco velas. También hay otras variaciones utilizando la desigualdad estricta ">" o "<", y utilizando "<=" o ">=". Por último, hay #definiciones para identificar fractales superiores (TOP) o inferiores (BOT). Mirando las definiciones puedes averiguar qué definición usar.

is3CANDLEGAPUP(i,gap,size) se utiliza para encontrar un gap UP (donde el máximo de una vela está por debajo del mínimo de dos velas más tarde). Candle(i) será la más reciente de las tres velas en cuestión. De nuevo, se asume que las velas son "AsSeries". "gap" es la mínima delta de precio del gap, y "size" es la mínima delta de precio del tamaño del cuerpo de la vela del medio.

is3CANDLEGAPDOWN(i,gap,size) se utiliza para encontrar un gap ABAJO utilizando la misma lógica.

is3CANDLEGAPUPTREND(i,gap,size) es igual que is3CANDLEGAPUP(i,gap,size) pero añade una condición adicional para que sea cierto: que la más antigua de las tres velas sea de dirección positiva.

Hay dos formas de averiguar si una vela es un doji: isCANDLEDOJIPOINTS(i,n) y isCANDLEDOJIFRACTION(i,f). La primera versión utiliza n*_Punto y la segunda utiliza f*CANDLESIZE(i) para determinar si (verdadero o falso) la vela es un Doji.

Ejemplo: si quiere saber si la vela 20 es un tope fractal no estricto (usando igualdades) use isCANDLEFRACTALEQTOP(20), y la salida será verdadero o falso.

Como puede ver, las definiciones son una forma comprimida de las consultas, haciendo su código EA más corto y fácil de leer.

// consulta de características de las velas (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))

Funciones y operaciones matemáticas

Ahora definimos algunas funciones y operaciones matemáticas que son útiles en el EA. Algunas de ellas son específicas para los EAs que he desarrollado, pero usted puede cambiarlas o eliminarlas si así lo desea.

BRACKET(x,minV,maxV) devolverá un valor de x dentro del intervalo [minV,maxV]. Esto es útil para limitar las variables de entrada en el EA.

CONVEXCOMB(a,x1,x2) es una combinación convexa de x1 y x2 como a*x1+x2. Esta función es útil cuando se calcula un valor intermedio entre x1 y x2, pero se desea algo más que la media (a=0.5).

EVALLINE(x,x1,y1,x2,y2,ymin,ymax) es la evaluación de una recta definida por dos puntos [x1,y1] y [x2,y2]. Una vez evaluada en x, devuelve un valor entre corchetes dentro de [ymin, ymax].

MAPAB11(x,A,B) mapea el valor x desde un corchete [A,B] a un corchete [-1,1]. MAP11AB(x,A,B) asigna el valor x de un corchete [-1,1] a un corchete [A,B]. Estas dos funciones son útiles para trabajar con variables normalizadas en el rango de [-1,1].

Las últimas cuatro funciones se utilizan en mis EAs y no necesariamente pueden ser genéricamente útiles para todo el mundo, pero las he dejado ahí, por si acaso.

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

También, como función y operaciones, hay cálculos de diferencias (como proxy de pendientes).

MA20DIFF(i,n) da la diferencia entre los dos valores de la media móvil de 20 periodos separados por n velas. El resto de funciones siguen la misma lógica. Ejemplo: para calcular la diferencia entre la media móvil de 200 periodos en la vela 3 y en la vela 13, utilice 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))

Las consultas también se incluyen como funciones matemáticas. El horquillado y la convexidad se comprueban a continuació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)

Constantes

Defino algunas constantes que utilizo. Es tu elección utilizarlas.

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

Depuración

Cualquier programador experimentado sabe que la mejor herramienta para depurar su código es la sentencia Print. Las siguientes definiciones permiten configurar sentencias Print por todo tu programa, y activarlas/desactivarlas dependiendo del valor del nivel de depuración que te interese.

Primero, necesitas definir el nivel de depuración usando #define DEBUG_LEVEL0, #define DEBUG_LEVEL1, o #define DEBUG_LEVEL2. Cuando se utiliza DEBUG_LEVEL0, no habrá impresión en la pestaña Journal del terminal Metatrader 5. Con DEBUG_LEVEL1, sólo las sentencias PRINTVARn estarán activas y se imprimirán en la pestaña Journal. Con DEBUG_LEVEL2, tanto la sentencia PRINTVARn como la sentencia VPRINTVARn se imprimirán en la pestaña Diario. El DEBUG_LEVEL2 es el caso "V "erbose utilizando VPRINTVARn.

PRINTVARn imprimirá n variables. Por ejemplo, si desea imprimir i, x y z, utilice PRINTVAR3(i,x,z); Para imprimir una cadena, utilice PRINTTEXT("cualquier cadena"); La impresión incluirá el nombre de la función y el número de línea del fichero donde se inserta la sentencia PRINTVARn.

// Depuración con Print 
// Al principio de tu código define el nivel de depuración x={0,1,2} como: #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