Lite_EXPERT2.mqh: Un conjunto operativo para los desarrolladores de Asesores Expertos

Introducción

Los artículos 1, 2, 3, 4, 5, 6 y 7 de la serie "Asesores Expertos basados en sistemas populares de trading, y un poco de alquimia en la optimización de robots", han introducido los principiantes en el desarrollo de Asesores Expertos a mi método de escritura de Asesores Expertos que permite transformar de manera fácil y rápida las estrategias de trading en códigos sencillos mediante las funciones personalizadas que ya existen en el archivo Lite_EXPERT1.mqh. Como es natural, para simplificar al máximo la información, el número de funciones personalizadas en este archivo era el mínimo, pero lo suficiente para entenderlas sin ningún problema.

Sin embargo, la operatividad de este archivo no es suficiente para trabajar con el código del programa a una escala más amplia El archivo Lite_EXPERT2.mqh fue escrito para solucionar este problema y contiene un conjunto de funciones personalizadas más versátiles y más complejas para un usuario principiante. Se supone que el lector ya está familiarizado con el contenido del artículo "Asesores Expertos basados en sistemas populares de trading, y un poco de alquimia en la optimización de robots" y considera este artículo como el siguiente paso para desarrollar y mejorar sus habilidades para utilizar estas funciones personalizadas.

Contenido del archivo Lite_EXPERT2.mqh

En general, se pueden representar todas las funciones disponibles en Lite_EXPERT2.mqh en el siguiente diagrama:

Además de la funciones, Lite_EXPERT2.mqh contiene la variable LastTime de tipo int (entera) que se declara a nivel global y se usa en todas las funciones de trading, además de la variable externa Slippage_ de tipo int para la desviación en puntos y que será visible desde los parámetros externos del Asesor Experto.

1. Funciones de apertura de posiciones

Se pueden dividir todas las funciones de este bloque en dos grupos: Los nombres de las funciones del primer grupo empiezan con "Open", mientras que las funciones del segundo grupo empiezan con "dOpen". Las funciones del primer grupo al igual que las variables externas Stop Loss y Take Profit usan la distancia relativa desde el punto de apertura de la posición expresada en puntos, es decir que se representan mediante variables enteras.

bool OpenBuyOrder1_
        (bool& BUY_Signal, int MagicNumber, datetime TimeLevel,
                           double Money_Management, int Margin_Mode, 
                                         int STOPLOSS, int TAKEPROFIT)
                                         
bool OpenSellOrder1_
        (bool& SELL_Signal, int MagicNumber, datetime TimeLevel, 
                            double Money_Management, int Margin_Mode, 
                                          int STOPLOSS, int TAKEPROFIT)
                                          
bool OpenBuyOrder2_
        (bool& BUY_Signal, int MagicNumber, datetime TimeLevel,
                           double Money_Management, int Margin_Mode, 
                                          int STOPLOSS, int TAKEPROFIT)
                                          
bool OpenSellOrder2_
        (bool& SELL_Signal, int MagicNumber, datetime TimeLevel, 
                            double Money_Management, int Margin_Mode, 
                                          int STOPLOSS, int TAKEPROFIT)

En las funciones del segundo grupo se representan Stop Loss y Take Profit mediante variables de coma flotante. En este caso, los valores de estas variables son los valores absolutos de las órdenes correspondientes obtenidas a partir del gráfico de precios. Esto hace más cómoda la escritura del código de un Asesor Experto con una finalidad específica.

bool dOpenBuyOrder1_
        (bool& BUY_Signal, int MagicNumber, datetime TimeLevel,
                           double Money_Management, int Margin_Mode, 
                                  double dSTOPLOSS, double dTAKEPROFIT)
                                  
bool dpenSellOrder1_
        (bool& SELL_Signal, int MagicNumber, datetime TimeLevel,
                           double Money_Management, int Margin_Mode, 
                                  double dSTOPLOSS, double dTAKEPROFIT)
                                  
bool dOpenBuyOrder2_
        (bool& BUY_Signal, int MagicNumber, datetime TimeLevel,
                           double Money_Management, int Margin_Mode, 
                                   double dSTOPLOSS, double dTAKEPROFIT)
                                   
bool dOpenSellOrder2_
        (bool& SELL_Signal, int MagicNumber, datetime TimeLevel, 
                            double Money_Management, int Margin_Mode, 
                                   double dSTOPLOSS, double dTAKEPROFIT)

Todas las funciones cuyo nombre acaba en "1_" están diseñadas para los brokers que permiten colocar el Stop Loss y el Take Profit justo al ejecutar una transacción. Se usan las funciones cuyo nombre contiene "2_" por los brokers que permiten colocar estas órdenes en unas posiciones ya abiertas.

En comparación con las funciones de Lite_EXPERT1.mqh, estas ochos funciones contienen dos nuevas variables externas (TimeLevel de tipo datetime y Margin_Mode de tipo int). Así que primero vamos a analizar estas variables. El valor de la variable TimeLevel representa un determinado límite de tiempo después de la ejecución de la transacción actual. Ninguna función de trading de este archivo va a abrir nuevas posiciones u órdenes con el número mágico actual mientras no se alcanza el límite. Durante la ejecución de una transacción se almacena el valor de esta variable externa en una variable global en el disco duro del ordenador y por lo tanto no se perderá al reiniciar el terminal de trading o el sistema operativo Windows. Se usa esta variable principalmente para impedir la reapertura de una posición o la colocación de una orden pendiente en la misma barra.

//----
   static datetime TimeLevel;
   TimeLevel = Time[0] + Period() * 60;
   
   //---- 
   if (!OpenBuyOrder1_
        (BUY_Signal, MagicNumber, TimeLevel,
                           Money_Management, Margin_Mode, 
                                         STOPLOSS, TAKEPROFIT))
                                                          return(-1);

Se supone que la inicialización de la variable estática TimeLevel no se va a llevar a cabo en el mismo bloque que la variable BUY_Signal. La función OpenBuyOrder1_() abre una posición y almacenará el valor de TimeLevel en la variable global en el disco duro. Las funciones del archivo Lite_EXPERT2.mqh que abren posiciones u órdenes pendientes no van a abrir ninguna orden con este número mágico hasta que el tiempo de la última cotización no sea superior o igual a este valor.

Así que las funciones de trading no ponen a cero la variable externa BUY_Signal de tipo bool por referencia ya que no es necesario. ¡Sólo se hará la puesta a cero si se inicializa la variable TimeLevel a "-1"! Si ponemos a cero esta variable, la función de apertura de posiciones no inicializará ni guardará nada y abrirá posiciones en base a las señales de la variable externa BUY_Signal durante el tiempo en el que no existan órdenes con el número mágico igual a la variable externa de tipo int MagicNumber.

Se genera el nombre de la cadena usada por la variable global almacenada en el disco duro para la prueba y la optimización mediante la siguiente fórmula:

string G_Name_ = "TimeLevel", "_", AccountNumber(), "_", 
                                "_Test_", OrderSymbol(), "_", OrderMagicNumber());

En los demás casos:

string G_Name_ = "TimeLevel", "_", AccountNumber(), 
                                     "_", OrderSymbol(), "_", OrderMagicNumber());

¡Las otras variables globales no deben utilizar este nombre!

Las funciones de trading disponibles en el archivo Lite_EXPERT1.mqh usan un sólo método de cálculo del tamaño del lote (MM basado en el margen disponible de la cuenta). Este método de cálculo del tamaño del lote puede no ser el adecuado con todas las estrategias. Las funciones de trading proporcionadas en Lite_EXPERT2.mqh han tenido en cuenta este detalle, y se determina el método de cálculo del tamaño del lote mediante la variable externa Margin_Mode de tipo int. Los valores de la variable externa Margin_Mode pueden estar entre cero y cinco:

• 0 - MM basado en el margen disponible
• 1 - MM basado en el balance de la cuenta
• 2 - MM basado en las pérdidas del el margen disponible
• 3 - MM basado en las pérdidas del balance de la cuenta
• 4 - lote mínimo entre 0 y 2
• 5 - lote mínimo entre 1 y 3
• por defecto - MM basado en el margen disponible

Cabe señalar que si usa el segundo o tercer método de cálculo del tamaño del lote y su Stop Loss es dinámico, es decir que cambia de una transacción a otra, es necesario tener cuenta los valores límite de Stop Loss y MM. Si por ejemplo las variables tienen estos valores: Money_Management = 0.1, Margin_Mode = 3 y STOPLOSS = 100 (cinco decimales), el Asesor Experto usará todo el depósito para abrir una posición.

En cualquier caso, voy a explicar una vez más estas dos opciones de la variable Margin_Mode (2 y 3). Aquí, la función de cálculo del tamaño del lote toma el valor del margen disponible o el balance de la cuenta y lo multiplica por el valor de la variable Money_Management. El valor resultante representa las pérdidas que se pueden producir si se cierra la posición en el nivel Stop Loss. Estas pérdidas no dependen del tamaño de Stop Loss. Por lo tanto, la función de cálculo del tamaño del lote determina el volumen de la posición en base al tamaño de Stop Loss de modo que las pérdidas a partir de Stop Loss sean inadmisibles.

Cuando la variable Margin_Mode vale 4 o 5, las funciones de trading pueden calcular el tamaño del lote mediante dos opciones al mismo tiempo y elegir el valor más pequeño. Por ejemplo, si Margin_Mode = 5, una función de trading calculará el tamaño del lote en base al balance de la cuenta y en base a las pérdidas en el balance de la cuenta y luego usará el valor más pequeño.

Me gustaría recordar una vez más que si el valor de la variable Money_Management es negativo, todas estas funciones ignorarán el valor de la variable Margin_Mode variable y usarán el valor de la variable Money_Management como tamaño del lote. Al usar estos valores, se descarta su signo negativo y se redondean al valor estándar más próximo y que no puede ser superior al valor disponible. En el cálculo del tamaño del lote, estas ocho funciones comprueban siempre que el margen disponible es suficiente para la ejecución de una transacción determinada y si es necesario, reduce el valor calculado del lote hasta el valor tolerable.

2. Funciones para colocar órdenes pendiente

Este es el segundo gran bloque de funciones que al igual que el bloque anterior están divididas en dos grupos.

bool OpenBuyLimitOrder1_
        (bool& Order_Signal, int MagicNumber, datetime TimeLevel,
                            double Money_Management, int Margin_Mode, 
                                           int STOPLOSS, int TAKEPROFIT,
                                              int LEVEL, datetime Expiration) 
bool OpenBuyStopOrder1_
        (bool& Order_Signal, int MagicNumber, datetime TimeLevel, 
                             double Money_Management, int Margin_Mode, 
                                           int STOPLOSS, int TAKEPROFIT,
                                               int LEVEL, datetime Expiration)
bool OpenSellLimitOrder1_
        (bool& Order_Signal, int MagicNumber, datetime TimeLevel, 
                            double Money_Management, int Margin_Mode, 
                                           int STOPLOSS, int TAKEPROFIT,
                                               int LEVEL, datetime Expiration)
bool OpenSellStopOrder1_
        (bool& Order_Signal, int MagicNumber, datetime TimeLevel,
                            double Money_Management, int Margin_Mode,
                                           int STOPLOSS, int TAKEPROFIT,
                                               int LEVEL, datetime Expiration)

bool dOpenBuyLimitOrder1_
        (bool& Order_Signal, int MagicNumber, datetime TimeLevel,
                            double Money_Management, int Margin_Mode, 
                                    double dSTOPLOSS, double dTAKEPROFIT,
                                           double dLEVEL, datetime Expiration)
bool dOpenBuyStopOrder1_
        (bool& Order_Signal, int MagicNumber, datetime TimeLevel, 
                             double Money_Management, int Margin_Mode, 
                                    double dSTOPLOSS, double dTAKEPROFIT,
                                            double dLEVEL, datetime Expiration)
bool dOpenSellLimitOrder1_
        (bool& Order_Signal, int MagicNumber, datetime TimeLevel, 
                            double Money_Management, int Margin_Mode, 
                                    double dSTOPLOSS, double dTAKEPROFIT,
                                            double dLEVEL, datetime Expiration)
bool dOpenSellStopOrder1_
        (bool& Order_Signal, int MagicNumber, datetime TimeLevel,
                            double Money_Management, int Margin_Mode,
                                    double dSTOPLOSS, double dTAKEPROFIT,
                                            double dLEVEL, datetime Expiration)

Todo lo mencionado en relación a las funciones anteriores es válido también con estas ocho funciones. Exceptuando dos cosas. Es prácticamente imposible calcular el tamaño del lote en base a lo que sucede durante la colocación de una orden. ¿Y cómo se hace si se calcula el tamaño del lote en el momento de colocación de la orden pendiente? Es difícil esperar que el cálculo se ajuste exactamente al valor de la variable Money_Management. Por el mismo motivo estas funciones no comprueban si hay recursos suficientes para el tamaño del lote.

3. Funciones para cerrar posiciones abiertas

Este bloque incluye cuatro funciones.

bool CloseBuyOrder1_(bool& CloseStop, int MagicNumber)

bool CloseSellOrder1_(bool& CloseStop, int MagicNumber)

bool CloseAllBuyOrders1_(bool CloseStop)

bool CloseAllSellOrders1_(bool CloseStop)

Estas funciones son bastante sencillas y no requieren más explicaciones. Las dos primeras funciones cierran las posiciones con los números mágicos que indica el símbolo del gráfico en el cual se ejecuta el Asesor Experto. Las otras dos funcio0nes cierran todas las posiciones abiertas disponibles.

4. Funciones para eliminar órdenes pendientes

Este bloque incluye dos funciones básicas

bool CloseOrder1_(bool& CloseStop, int cmd, int MagicNumber)
bool CloseAllOrders1_(bool CloseStop, int cmd)

cuyas variables externas incluyen una nueva variable: cmd de tipo int. Sus valores pueden ser los siguientes:

• OP_BUYLIMIT 2 Orden pendiente BUY LIMIT
• OP_SELLLIMIT 3 Orden pendiente SELL LIMIT
• OP_BUYSTOP 4 Orden pendiente BUY STOP
• OP_SELLSTOP 5 Orden pendiente SELL STOP

5. Funciones de modificación de posición y de Trailing Stop

Este bloque incluye tres grupos de funciones:

1) modificadores de posiciones

bool dModifyOpenBuyOrder_
       (bool& Modify_Signal, int MagicNumber, 
                     datetime ModifyTimeLevel_, double dSTOPLOSS, double dTAKEPROFIT)
                         
bool dModifyOpenSellOrder_
       (bool& Modify_Signal, int MagicNumber, 
                     datetime ModifyTimeLevel_, double dSTOPLOSS, double dTAKEPROFIT)
                         
bool dModifyOpenBuyOrderS (bool& Modify_Signal, double dSTOPLOSS, double dTAKEPROFIT)
                         
bool dModifyOpenSellOrderS(bool& Modify_Signal, double dSTOPLOSS, double dTAKEPROFIT)

Las cuatro funciones de este grupo usan los valores absolutos de Stop Loss y Take Profit en la escala del gráfico de precios y se representan mediante variables de coma flotante. Todo lo mencionado en relación a las variables del primer y segundo grupo es válido y aplicable a las variables de este grupo.

Tenga en cuenta que el valor de la variable ModifyTimeLevel_ de tipo datetime se usa únicamente en las dos primeras funciones de este grupo. Esta variable no está presente en las dos últimas funciones. Para poder llamar a alguna de las dos últimas funciones en el código del Asesor Experto, primero hay que seleccionar una orden de tipo OP_BUY o OP_SELL mediante la función OrderSelect() para seguir trabajando con ella. Estas funciones están diseñadas para trabajar con posiciones abiertas que no disponen de números mágicos. Los códigos para el nombre de la cadena de la variable global destinada a almacenar el valor de la variable ModifyTimeLevel_ en el disco duro son los siguientes:

string G_Name_ = "ModifyTimeLevel_", "_", AccountNumber(), 
                                          "_", "_Test_", Symbol(), "_", MagicNumber;

string G_Name_ = "ModifyTimeLevel_", "_", AccountNumber(),
                                                    "_", Symbol(), "_", MagicNumber;  

2) Trailing Stops

bool Make_BuyTrailingStop_
             (bool& TreilSignal, int MagicNumber, datetime TrailTimeLevel, int TRAILINGSTOP)

bool Make_SellTrailingStop_
             (bool& TreilSignal, int MagicNumber, datetime TrailTimeLevel, int TRAILINGSTOP)
        
bool dMake_BuyTrailingStop_
        (bool& TreilSignal, int MagicNumber, datetime TrailTimeLevel_, double dTRAILINGSTOP)
        
bool dMake_SellTrailingStop_
        (bool& TreilSignal, int MagicNumber, datetime TrailTimeLevel_, double dTRAILINGSTOP)

Este grupo incluye cuatro Trailing Stops clásicos para mover el Stop Loss en función del precio. Los dos primeros tienen como parámetro externo un valor de Trailing Stop en puntos en relación al precio actual, mientras los otros dos usan el valor absoluto del Trailing Stop con la misma finalidad. Al igual que las funciones anteriores, estas cuatro funciones usan límites en el tiempo en forma de las variables TrailTimeLevel y TrailTimeLevel_ con el mismo valor. Si tiene la intención de cambiar los Trailing Stops en cada tick, hay que poner estas variables a cero.

3) y otro grupo de cuatro modificadores de posición

bool BuyStoplossCorrect
           (int MagicNumber, int ExtPointProfit, int StoplossProfit)
           
bool SellStoplossCorrect
           (int MagicNumber, int ExtPointProfit, int StoplossProfit)
           
bool AllBuyStoplossCorrects (int ExtPointProfit, int StoplossProfit)
           
bool AllSellStoplossCorrects(int ExtPointProfit, int StoplossProfit)

que llevan a cabo los cambios de los niveles Stop Loss una sola vez. Las dos primeras funciones comprueban el beneficio en puntos con respecto a una posición abierta con número mágico y si no es inferior al valor de la variable ExtPointProfit, se mueve el Stop Loss al precio actual a una distancia StoplossProfit desde la posición del precio de apertura.

Las dos últimas funciones de este grupo hacen el seguimiento de todas las posiciones abiertas del símbolo actual con cualquier número mágico y llevan a cabo el cambio correspondiente de sus niveles Stop Loss.

6. Funciones adicionales

Este es el último y probablemente el mayor grupo de funciones en el archivo Lite_EXPERT2.mqh. Muchas de las funciones de este grupo se usan como un código adicional dentro de las otras funciones que vimos antes y que en muchos casos no resultan especialmente interesantes. Así que me voy a limitar a repasar las más relevantes.

En primer lugar, me gustaría comentar la función TimeLevelGlobalVariableDel():

void TimeLevelGlobalVariableDel(string symbol, int MagicNumber)

Después de la prueba y la optimización, esta prueba elimina todas las variables globales almacenadas en el disco duro y que fueron generadas por las funciones de trading del archivo. Se llama a esta función desde el bloque de deinicialización del Asesor Experto, por ejemplo, así:

//+X================================================================X+
//| Custom Expert deinitialization function                          |
//+X================================================================X+  
int deinit()
  {
//----+
    TimeLevelGlobalVariableDel(Symbol(), 1);
    TimeLevelGlobalVariableDel(Symbol(), 2);
    TimeLevelGlobalVariableDel(Symbol(), 3);
    TimeLevelGlobalVariableDel(Symbol(), 4);
    //---- Completing deinitialization of the Expert Advisor
    return(0);
//----+ 
  }

¡Si esto no se hace, las variables globales con los últimos valores después de la prueba o la optimización bloquearán la prueba y la optimización del Asesor Experto!

Ocurre a menudo que los períodos de tiempo del gráfico que sólo se pueden seleccionar a partir de una serie de valores estándar sean utilizados como variables externas del Asesor Experto. Podemos equivocarnos y establecer un valor erróneo al hacerlo manualmente. En esto casos, puede comprobarlo mediante la función TimeframeCheck(),

void TimeframeCheck(string TimeframeName, int Timeframe)

que comprueba los valores del período de tiempo en las variables externas al inicializar el Asesor Experto.

Todos los cálculos que se llevan a cabo en el Asesor Experto para cualquier nivel de precio se basan inicialmente en los valores del gráfico de precios. Y los precios que se muestran en los gráficos no son siempre muy claros; ASK o BID (comprar o vender). Así que los valores obtenidos a partir de los gráficos de precios requieren ser ajustados a esta diferencia antes de ser utilizados en las funciones de trading. Esto se puede hacer mediante la función dGhartVelueCorrect():

double dGhartVelueCorrect(int cmd, double& GhartVelue)

El propósito de la variable cmd es exactamente igual a la descripción proporcionada en la Ayuda de MetaEditor. Al llamar a esta función, el parámetro externo GhartVelue sólo puede ser representado mediante una variable cuyo valor se cambia por referencia al valor ajustado. Por ejemplo:

//---- get the GhartVelue_ price level
   double GhartVelue_ = Low[0];
   //---- correct the GhartVelue_ price level
   dGhartVelueCorrect(OP_BUY, GhartVelue_);

Existen otras dos funciones para seleccionar órdenes y poder seguir utilizándolas:

bool OrderSelect_(string symbol, int cmd, int MagicNumber, int pool)
bool Order_Select(string symbol, int MagicNumber)

La variable pool sólo puede tomar dos valores: MODE_TRADES; se selecciona la orden a partir de las órdenes abiertas y pendientes, y MODE_HISTORY; se selecciona la orden a partir de las órdenes cerradas y eliminadas. Si todo va bien, las funciones devuelven true, de lo contrario, devuelven false.

En determinados casos, puede que tengamos que utilizar la función MarginCheck() que comprueba el tamaño del lote frente a los fondos disponibles en la cuenta y si es necesario reducir el tamaño del lote para ajustarlo a los fondos disponibles:

bool MarginCheck(string symbol, int Cmd, double& Lot)

El parámetro Cmd en esta función sólo puede tomar uno de estos dos valores: OP_BUY y OP_SELL. Si el cálculo es correcto, la función devuelve true. Si se produce algún error en la función, devuelve false.

A veces, puede que quiera calcular el tamaño del lote. Para ello, tenemos dos funciones más:

double BuyLotCount(double Money_Management, int Margin_Mode, int STOPLOSS)
double SellLotCount(double Money_Management, int Margin_Mode, int STOPLOSS)

Si no hay errores, las funciones devuelven el valor del lote, de lo contrario, devuelven -1.

También hay tres funciones más para aquellos que quieran colocar el código de un indicador en el código de un Asesor Experto:

int IndicatorCounted_(int Number, string symbol, int timeframe)

int ReSetAsIndexBuffer(string symbol, int timeframe, double& array[])

int ReSetAsIndexBuffer_(string symbol, int timeframe, double& Array[], int ArrSize)

La primera función es similar a la función IndicatorCounted() que se ejecuta en los Asesores Expertos. La variable externa Number representa el número de llamadas a la función en el código del Asesor Experto (un número por indicador).

La segunda función convierte una matriz de datos declarada a nivel global en un buffer de indicador análogo. Es decir que esta función sincroniza los elementos de la matriz cuyo nombre representa la variable array[] de tipo double con las respectivas matrices de series de tiempo. La llamada a este función se hace en la función start(), fuera del rango de los operadores del bucle de numeración de las barras del gráfico.

La tercera función es análoga a la segunda pero el número de elementos de la matriz Array[] se obtiene a partir del valor límite de la variable ArrSize. Es decir que en este caso la matriz contiene únicamente el número ArrSize de las barras más recientes. Esta función puede resultar más útil que la anterior en muchos casos donde se añaden los valores del código del indicador únicamente a esta matriz y sólo se utiliza el número ArrSize de los últimos valores en el código del Asesor Experto.

Y finalmente, las dos últimas funciones:

bool IsNewBar(int Number, string symbol, int timeframe)

bool MinBarCheck(string symbol, int timeframe, int MinBarTotal)

La función IsNewBar() devuelve True en el momento en el que cambia la barra en las respectivas matrices de series de tiempo. En todos los demás casos, esta función devuelve False. La variable Number representa el número de llamadas a la función en el código del Asesor Experto. La función MinBarCheck() compara el número de barras del gráfico con el valor de la variable MinBarTotal. Si el número de barras es inferior devuelve False. Se usa esta función para impedir al Asesor Experto operar si no hay suficientes barras para llevar a cabo el cálculo.

Conclusión

Básicamente, esta es la lista completa de las funciones más solicitadas de Lite_EXPERT2.mqh y que son suficientes para escribir estrategias de trading de manera cómoda y eficiente en MQL4. En los siguientes artículos de esta serie voy a proporcionar ejemplos concretos sobre el uso de las funciones anteriores en los Asesores Expertos.