Descargar MetaTrader 5

Creación de un Expert Advisor que opera con varios instrumentos

25 febrero 2014, 10:43
Nikolay Kositsin
0
837

Introducción

El aspecto técnico del código de programa de un Expert Advisor para una divisa, ejecutado en una ventana única, le permite hacer trading con distintos activos financieros al mismo tiempo. En general, esto no era un problema en MQL4. Pero con la aparición del terminal MetaTrader 5, los operadores han podido por fin llevar a cabo un análisis completo del funcionamiento de dichos sistemas automatizados, mediante los probadores de estrategias.

Por lo tanto, los sistemas automatizados multidivisa son ahora más populares que nunca, y podemos pronosticar un aumento de interés en la implementación de dichos sistemas de trading. Pero el principal problema para la implementación de dichos robots radica en la expansión del código del programa que se debe a las dimensiones, como mucho, en una progresión aritmética, y nos es fácil para un programador principiante.

Vamos a escribir en este artículo un Expert Advisor multidivisa sencillo, en el cual se minimizan los errores de estructura, si los hay.


1. Implementación de un sistema sencillo de seguimiento de tendencia

De hecho, vamos a empezar con un sistema de trading muy sencillo, siguiendo la tendencia mediante el indicador técnico integrado en el terminal Promedio móvil exponencial triple (Triple Exponential Moving Average). Es un algoritmo muy sencillo, no necesita comentarios especiales, y que vamos a incluir ahora en el código del programa.

Pero primero, me gustaría hacer las conclusiones más generales sobre el Expert Advisor. Esto tiene sentido para comenzar con el bloque de parámetros de entrada del Expert Advisor, declarados de manera general.

Por lo tanto, lo primero que tenemos que hacer es elegir los activos financieros que vamos a procesar. Esto se puede hacer mediante las variables de la línea de entrada, en la cual podemos almacenar los valores de los activos. Estaría bien ahora disponer de un interruptor para prohibir el trading para cada activo financiero, lo que permitirá desactivar las operaciones por activos.

Por supuesto, cada activo tiene que ir asociado a sus propios parámetros de trading como Stop Loss, Take Profit, el volumen de la posición abierta y el slippage. Y por razones obvias, los parámetros de entrada de cada indicador Promedio móvil exponencial triple para cada variedad de trading tienen que ser independientes.

A continuación, tenemos un bloque final de variables de entrada para una sola variedad, hecho de acuerdo con estos argumentos. Lo único que diferencia los bloques restantes es el número en los parámetros de entrada del Expert Advisor. Para este ejemplo me he limitado a doce activos financieros, aunque en el caso ideal no hay ningún límite de número de bloques en el programa.

¡Tan solo tenemos que hacer trading con algo! Y lo más importante, nuestro ordenador tiene que disponer de recursos suficientes para resolver este problema.

input string                Symb0 = "EURUSD";
input  bool                Trade0 = true; 
input int                    Per0 = 15; 
input ENUM_APPLIED_PRICE ApPrice0 = PRICE_CLOSE;
input int                 StLoss0 = 1000;
input int               TkProfit0 = 2000;
input double                Lots0 = 0.1;
input int               Slippage0 = 30;

Ahora que hemos averiguado las variables a nivel general, podemos proceder a la implementación del código dentro de la función OnTick(). La opción más lógica en este caso sería separar el algoritmo de recepción de señales de trading y la parte actual del trading del Expert Advisor en dos funciones personalizadas.

Y puesto que el Expert Advisor trabaja con doce activos financieros al mismo tiempo, tienen que haber también doce llamadas a estas funciones dentro del bloque OnTick(). 

Por supuesto, el primer parámetro de entrada de estas funciones debe ser un número único, que corresponde a estos activos de trading. Y por razones obvias, el segundo parámetro de entrada sería la línea del nombre del activo financiero del trading.

En cuanto al tercer parámetro, estableceremos una variable lógica para resolver la operación de trading. A continuación, para el algoritmo que determina las señales de trading, seguiremos las señales del indicador de entrada, y para la función de trading, la distancia hasta las órdenes pendientes, el volumen de la posición y el slippage (slippage admisible del precio de una posición abierta).

Para transferir las señales de trading de una función a otra, hay que establecer matrices estáticas como parámetros de la función, para conseguir sus valores de referencia. Esta es la versión final del código propuesto para la función OnTick().

void OnTick()
  {
//--- declare variables arrays for trade signals 
   static bool UpSignal[12], DnSignal[12], UpStop[12], DnStop[12];
  
//--- get trade signals
   TradeSignalCounter( 0, Symb0,  Trade0,  Per0,  ApPrice0,  UpSignal, DnSignal, UpStop, DnStop);
   TradeSignalCounter( 1, Symb1,  Trade1,  Per1,  ApPrice1,  UpSignal, DnSignal, UpStop, DnStop);
   TradeSignalCounter( 2, Symb2,  Trade2,  Per2,  ApPrice2,  UpSignal, DnSignal, UpStop, DnStop);
   TradeSignalCounter( 3, Symb3,  Trade3,  Per3,  ApPrice3,  UpSignal, DnSignal, UpStop, DnStop);
   TradeSignalCounter( 4, Symb4,  Trade4,  Per4,  ApPrice4,  UpSignal, DnSignal, UpStop, DnStop);
   TradeSignalCounter( 5, Symb5,  Trade5,  Per5,  ApPrice5,  UpSignal, DnSignal, UpStop, DnStop);
   TradeSignalCounter( 6, Symb6,  Trade6,  Per6,  ApPrice6,  UpSignal, DnSignal, UpStop, DnStop);
   TradeSignalCounter( 7, Symb7,  Trade7,  Per7,  ApPrice7,  UpSignal, DnSignal, UpStop, DnStop);
   TradeSignalCounter( 8, Symb8,  Trade8,  Per8,  ApPrice8,  UpSignal, DnSignal, UpStop, DnStop);
   TradeSignalCounter( 9, Symb9,  Trade9,  Per9,  ApPrice9,  UpSignal, DnSignal, UpStop, DnStop);
   TradeSignalCounter(10, Symb10, Trade10, Per10, ApPrice10, UpSignal, DnSignal, UpStop, DnStop);
   TradeSignalCounter(11, Symb11, Trade11, Per11, ApPrice11, UpSignal, DnSignal, UpStop, DnStop);
  
//--- perform trade operations
   TradePerformer( 0, Symb0,  Trade0,  StLoss0,  TkProfit0,  Lots0,  Slippage0,  UpSignal, DnSignal, UpStop, DnStop);
   TradePerformer( 1, Symb1,  Trade1,  StLoss1,  TkProfit1,  Lots1,  Slippage1,  UpSignal, DnSignal, UpStop, DnStop);
   TradePerformer( 2, Symb2,  Trade2,  StLoss2,  TkProfit2,  Lots2,  Slippage2,  UpSignal, DnSignal, UpStop, DnStop);
   TradePerformer( 3, Symb3,  Trade3,  StLoss3,  TkProfit3,  Lots3,  Slippage3,  UpSignal, DnSignal, UpStop, DnStop);
   TradePerformer( 4, Symb4,  Trade4,  StLoss4,  TkProfit4,  Lots4,  Slippage4,  UpSignal, DnSignal, UpStop, DnStop);
   TradePerformer( 5, Symb5,  Trade5,  StLoss5,  TkProfit5,  Lots5,  Slippage5,  UpSignal, DnSignal, UpStop, DnStop);
   TradePerformer( 6, Symb6,  Trade6,  StLoss6,  TkProfit6,  Lots6,  Slippage6,  UpSignal, DnSignal, UpStop, DnStop);
   TradePerformer( 7, Symb7,  Trade7,  StLoss7,  TkProfit7,  Lots7,  Slippage7,  UpSignal, DnSignal, UpStop, DnStop);
   TradePerformer( 8, Symb8,  Trade8,  StLoss8,  TkProfit8,  Lots8,  Slippage8,  UpSignal, DnSignal, UpStop, DnStop);
   TradePerformer( 9, Symb9,  Trade9,  StLoss9,  TkProfit9,  Lots9,  Slippage9,  UpSignal, DnSignal, UpStop, DnStop);
   TradePerformer(10, Symb10, Trade10, StLoss10, TkProfit10, Lots10, Slippage10, UpSignal, DnSignal, UpStop, DnStop);
   TradePerformer(11, Symb11, Trade11, StLoss11, TkProfit11, Lots11, Slippage11, UpSignal, DnSignal, UpStop, DnStop); 
//---
  }

En la función TradeSignalCounter(), hace falta obtener el identificador del indicador técnico Promedio móvil exponencial triple solo una vez al principio de cada variedad, y luego a cada cambio de barra para calcular las señales de trading.

Este esquema relativamente sencillo con la implementación en el código está empezando a rebosar a través de pequeños detalles.

bool TradeSignalCounter(int Number,
                        string Symbol_,
                        bool Trade,
                        int period,
                        ENUM_APPLIED_PRICE ApPrice,
                        bool &UpSignal[],
                        bool &DnSignal[],
                        bool &UpStop[],
                        bool &DnStop[])
  {
//--- check if trade is prohibited
   if(!Trade)return(true);

//--- declare variable to store final size of variables arrays
   static int Size_=0;

//--- declare array to store handles of indicators as static variable
   static int Handle[];

   static int Recount[],MinBars[];
   double TEMA[4],dtema1,dtema2;

//--- initialization
   if(Number+1>Size_) // Entering the initialization block only on first start
     {
      Size_=Number+1; // For this number entering the block is prohibited

      //--- change size of variables arrays
      ArrayResize(Handle,Size_);
      ArrayResize(Recount,Size_);
      ArrayResize(MinBars,Size_);

      //--- determine minimum number of bars, sufficient for calculation 
      MinBars[Number]=3*period;

      //--- setting array elements to 0
      DnSignal[Number] = false;
      UpSignal[Number] = false;
      DnStop  [Number] = false;
      UpStop  [Number] = false;

      //--- use array as timeseries
      ArraySetAsSeries(TEMA,true);

      //--- get indicator's handle
      Handle[Number]=iTEMA(Symbol_,0,period,0,ApPrice);
     }

//--- check if number of bars is sufficient for calculation 
   if(Bars(Symbol_,0)<MinBars[Number])return(true);
//--- get trade signals 
   if(IsNewBar(Number,Symbol_,0) || Recount[Number]) // Entering the block on bar change or on failed copying of data
     {
      DnSignal[Number] = false;
      UpSignal[Number] = false;
      DnStop  [Number] = false;
      UpStop  [Number] = false;

      //--- using indicator's handles, copy values of indicator's
      //--- buffers into static array, specially prepared for this purpose
      if(CopyBuffer(Handle[Number],0,0,4,TEMA)<0)
        {
         Recount[Number]=true; // As data were not received, we should return 
                               // into this block (where trade signals are received) on next tick!
         return(false);        // Exiting the TradeSignalCounter() function without receiving trade signals
        }

      //--- all copy operations from indicator buffer are successfully completed
      Recount[Number]=false; // We may not return to this block until next change of bar

      int Digits_ = int(SymbolInfoInteger(Symbol_,SYMBOL_DIGITS)+4);
      dtema2 = NormalizeDouble(TEMA[2] - TEMA[3], Digits_);
      dtema1 = NormalizeDouble(TEMA[1] - TEMA[2], Digits_);

      //---- determining the input signals
      if(dtema2 > 0 && dtema1 < 0) DnSignal[Number] = true;
      if(dtema2 < 0 && dtema1 > 0) UpSignal[Number] = true;

      //---- determining the output signals
      if(dtema1 > 0) DnStop[Number] = true;
      if(dtema1 < 0) UpStop[Number] = true;
     }
//----+
   return(true);
  }

En este sentido, el código de la función TradePerformer() es muy sencillo:

bool TradePerformer(int    Number,
                    string Symbol_,
                    bool   Trade,
                    int    StLoss,
                    int    TkProfit,
                    double Lots,
                    int    Slippage,
                    bool  &UpSignal[],
                    bool  &DnSignal[],
                    bool  &UpStop[],
                    bool  &DnStop[])
  {
//--- check if trade is prohibited
   if(!Trade)return(true);

//--- close opened positions 
   if(UpStop[Number])BuyPositionClose(Symbol_,Slippage);
   if(DnStop[Number])SellPositionClose(Symbol_,Slippage);

//--- open new positions
   if(UpSignal[Number])
      if(BuyPositionOpen(Symbol_,Slippage,Lots,StLoss,TkProfit))
         UpSignal[Number]=false; //This trade signal will be no more on this bar!
//---
   if(DnSignal[Number])
      if(SellPositionOpen(Symbol_,Slippage,Lots,StLoss,TkProfit))
         DnSignal[Number]=false; //This trade signal will be no more on this bar!
//---
   return(true);
  }

Pero esto se debe solo al empaquetado de los comandos reales para el rendimiento de la operaciones de trading en cuatro funciones adicionales:
BuyPositionClose();
SellPositionClose();
BuyPositionOpen();
SellPositionOpen();

Las cuatro funciones trabajan de forma similar, por lo que podemos limitarnos a examinar una de ellas solo:

bool BuyPositionClose(const string symbol,ulong deviation)
  {
//--- declare structures of trade request and result of trade request
   MqlTradeRequest request;
   MqlTradeResult result;
   ZeroMemory(request);
   ZeroMemory(result);

//--- check if there is BUY position
   if(PositionSelect(symbol))
     {
      if(PositionGetInteger(POSITION_TYPE)!=POSITION_TYPE_BUY) return(false);
     }
   else  return(false);

//--- initializing structure of the MqlTradeRequest to close BUY position
   request.type   = ORDER_TYPE_SELL;
   request.price  = SymbolInfoDouble(symbol, SYMBOL_BID);
   request.action = TRADE_ACTION_DEAL;
   request.symbol = symbol;
   request.volume = PositionGetDouble(POSITION_VOLUME);
   request.sl = 0.0;
   request.tp = 0.0;
   request.deviation=(deviation==ULONG_MAX) ? deviation : deviation;
   request.type_filling=ORDER_FILLING_FOK;
//---
   string word="";
   StringConcatenate(word,
                     "<<< ============ BuyPositionClose():   Close Buy position at ",
                     symbol," ============ >>>");
   Print(word);

//--- send order to close position to trade server
   if(!OrderSend(request,result))
     {
      Print(ResultRetcodeDescription(result.retcode));
      return(false);
     }
//----+
   return(true);
  }

Básicamente, este es más o menos todo el Expert Advisor multidivisa (Exp_TEMA.mq5)!

Además de las funciones vistas antes, contiene dos funciones adicionales de usuario:

bool IsNewBar(int Number, string symbol, ENUM_TIMEFRAMES timeframe);
string ResultRetcodeDescription(int retcode);

La primera de estas funciones devuelve el valor true en el momento de cambio de barra, basándose en el símbolo y período de tiempo seleccionados, y la segunda, devuelve la línea del código resultante de la transacción, resultante del campo retcode de la estructura de petición de trading MqlTradeResult

El Expert Advisor está listo, es el momento de comenzar las pruebas! No hay una diferencia significativa entre las pruebas del Expert Advisor multidivisa y el Expert Advisor de una sola divisa.

Definir las configuraciones en la pestaña "Configuración" en el Probador de estrategias:

<img src="http://p.mql5.com/data/2/105/fig1_en.png" title="Figura 1. Pestaña "Configuración" (Settings) del Probador de estrategias" alt="Figura 1. Pestaña "Configuración" (Settings) del Probador de estrategias" height="319" width="743">

Figura 1. Pestaña "Configuración" (Settings) del Probador de estrategias

Si es necesario, ajustar los valores de los parámetros de entrada en la pestaña "Parámetros de entrada":

<img src="http://p.mql5.com/data/2/105/fig2_en.png" title="Figura 2. Pestaña "Parámetros de entrada" (Inputs) del Probador de estrategias" alt="Figura 2. Pestaña "Parámetros de entrada" (Inputs) del Probador de estrategias" height="262" width="652">

Figura 2. Pestaña "Parámetros de entrada" (Inputs) del Probador de estrategias

y hacer clic en el botón "Empezar" (Start) de la pestaña "Configuración" del Probador de estrategias:

Figura 3. Ejecución de la prueba de un Expert Advisor

Figura 3. Ejecución de la prueba de un Expert Advisor

El tiempo de ejecución de la primera prueba del Expert Advisor puede ser muy largo, debido a la carga de los historiales de los doce símbolos. Después de finalizar la prueba en el probador de estrategias, abrimos la pestaña "Resultados" (Results):

Figura 4. Resultados de la prueba

Figura 4. Resultados de la prueba

y hacemos un análisis de los datos, usando los contenidos de la pestaña "Gráfico" (Chart):

Figura 5. Gráfico de la dinámica del balance y del patrimonio

Figura 5. Gráfico de la dinámica del balance y del patrimonio

y el "Diario" (Journal):

Figura 6. Diario del Probador de estrategias

Figura 6. Diario del Probador de estrategias

Naturalmente, la esencia misma de las entradas y salidas del algoritmo al mercado para este Expert Advisor es muy sencilla, y sería muy ingenuo esperar resultados muy relevantes al utilizar por primera vez unos parámetros aleatorios. Pero nuestro objetivo aquí es demostrar la idea de base para la implementación de un Expert Advisor de la manera más sencilla posible.

Con la optimización pueden surgir algunos inconvenientes con el Expert Advisor, debido a la gran cantidad de parámetros de entrada. El algoritmo genético de optimización requiere una cantidad mucho menor de estos parámetros, para que el Expert Advisor pueda optimizar en cada variedad individualmente, desactivando las variedades restantes de los parámetros de entrada TradeN.

Ahora, que ya se ha descrito la esencia del enfoque, puede empezar a trabajar en un algoritmo de toma de decisión más interesante para el robot multidivisa.


2. Resonancias en los mercados financieros y sus aplicaciones en los sistemas de trading

La idea de tener en cuenta las correlaciones entre los distintos activos financieros, en general, no es nueva, y sería interesante implementar el algoritmo, que se basará justamente en el análisis de dichas tendencias. Voy a implementar en este artículo un sistema automatizado multidivisa, basado en el artículo de Vasily Yakimin "Resonances - a New Class of Technical Indicators" (Resonancias -una nueva clase de indicadores técnicos) publicado en el diario ruso "Currency Speculator" (Especuladores de divisas) del 04/05/2001.

La esencia de este método se resume de la siguiente manera. Por ejemplo, para investigar el par EUR/USD, no usamos únicamente los resultados de algunos indicadores del activo financiero, sino también los resultados del mismo indicador relacionado con el par EUR/USD, EUR/JPY y USD/JPY. Es lo mejor para utilizar el indicador, y sus valores están normalizados en el mismo rango para simplificar y facilitar las mediciones y los cálculos.

Teniendo en cuento estos requisitos, que son muy adecuados para este clásico indicador estocástico. Aunque, en realidad, no hay ninguna diferencia en la utilización de otros indicadores. Para la dirección de la tendencia, vamos a tomar el signo de la diferencia entre el valor del estocástico Stoh y su línea de señal Sign .

Figura 7. Determinación de la dirección de la tendencia

Figura 7. Determinación de la dirección de la tendencia

Para el símbolo de la variable dStoh hay una tabla entera de combinaciones y sus interpretaciones para la dirección de la tendencia actual:

Figura 8. Combinaciones del símbolo de la variable dStoh y la dirección de la tendencia

Figura 8. Combinaciones del símbolo de la variable dStoh y la dirección de la tendencia

En el caso de que dos señales de los activos EUR/JPY y USD/JPY tengan valores opuestos, deberíamos de sumarlos, y si el resultado es positivo, se consideran ambas señales positivas, de los contrario, negativas.

Así pues, para la apertura de posiciones Largas, se usa el caso de la tendencia alcista, y para salir la tendencia bajista, o durante la tendencia con las señales del indicador del activo principal EUR/USD negativas. Además, hay que salir de la posición Larga si el activo principal no tiene señales, o cuando la suma de la variable dStoh de los activos restantes es negativa. Para las cortas, es exactamente igual, salvo que al revés.

La mejor solución sería poner toda la parte analítica del Expert Advisor en el indicador multidivisa, y de los buffers del indicador para el Expert Advisor, coger solamente las señales de control del trading. La versión de este tipo de indicador está en el indicador MultiStochastic.mq5, proporcionando un análisis visual de las condiciones del mercado.

Figura 9. El indicador MultiStochastic

Figura 9. El indicador MultiStochastic

Las barras verdes señalan la apertura y la retención de las posiciones largas, y las barras rojas la cortas, respectivamente. Los puntos de color rosa y verde claro en la parte superior del gráfico representan las señales de salida de las posiciones largas y cortas.

Se puede utilizar este indicador directamente para recibir señales en el Expert Advisor, pero sería mejor facilitar su trabajo y quitar todos los buffers innecesarios y los elementos de visualización, dejando solamente lo que está directamente implicado en suministrar señales de trading. Esto es precisamente lo que se hizo en el indicador MultiStochastic_Exp.mq5.

En este Expert Advisor, he llevado a cabo operaciones de trading con tres variedades solo, así que el código es extremadamente sencillo:

void OnTick()
  {
//--- declare variables arrays for trade signals
  static bool UpSignal[], DnSignal[], UpStop[], DnStop[];
  
//--- get trade signals
  TradeSignalCounter(0, Trade0, Kperiod0, Dperiod0, slowing0, ma_method0, price_0, SymbolA0, SymbolB0, SymbolC0, UpSignal, DnSignal, UpStop, DnStop);
  TradeSignalCounter(1, Trade1, Kperiod1, Dperiod1, slowing1, ma_method1, price_1, SymbolA1, SymbolB1, SymbolC1, UpSignal, DnSignal, UpStop, DnStop);
  TradeSignalCounter(2, Trade2, Kperiod2, Dperiod2, slowing2, ma_method2, price_2, SymbolA2, SymbolB2, SymbolC2, UpSignal, DnSignal, UpStop, DnStop);
                             
//--- perform trade operations
   TradePerformer( 0, SymbolA0,  Trade0,  StopLoss0,  0,  Lots0,  Slippage0,  UpSignal, DnSignal, UpStop, DnStop);
   TradePerformer( 1, SymbolA1,  Trade1,  StopLoss1,  0,  Lots1,  Slippage1,  UpSignal, DnSignal, UpStop, DnStop);
   TradePerformer( 2, SymbolA2,  Trade2,  StopLoss2,  0,  Lots2,  Slippage2,  UpSignal, DnSignal, UpStop, DnStop);
//---
  }

Sin embargo, el código de la función TradeSignalCounter() es un poco más complejo: El hecho de que el indicador multidivisa trabaja directamente con tres series de tiempo de activos distintos, y por lo tanto, implementamos una comprobación más sutil de las barras para adecuar el número mínimo de las mismas en una de las tres series de tiempo, mediante la función Rates_Total().

Además, se hace una comprobación adicional de la sincronización de las series de tiempo, mediante la función Synchro_Check(), para garantizar una precisión al determinar el momento de un cambio simultaneo de la barra en todas las series de tiempo.

bool TradeSignalCounter(int Number,
                        bool Trade,
                        int Kperiod,
                        int Dperiod,
                        int slowing,
                        ENUM_MA_METHOD ma_method,
                        ENUM_STO_PRICE price_,
                        string SymbolA,
                        string SymbolB,
                        string SymbolC,
                        bool &UpSignal[],
                        bool &DnSignal[],
                        bool &UpStop[],
                        bool &DnStop[])
  {
//--- check if trade is prohibited
   if(!Trade)return(true);
//--- declare variable to store sizes of variables arrays
   static int Size_=0;
//--- declare arrays to store handles of indicators as static variables
   static int Handle[];
   static int Recount[],MinBars[];
//---
   double dUpSignal_[1],dDnSignal_[1],dUpStop_[1],dDnStop_[1];
//--- change size of variables arrays
   if(Number+1>Size_)
     {
      uint size=Number+1;
      //----
      if(ArrayResize(Handle,size)==-1
         || ArrayResize(Recount,size)==-1
         || ArrayResize(UpSignal, size) == -1
         || ArrayResize(DnSignal, size) == -1
         || ArrayResize(UpStop, size) == -1
         || ArrayResize(DnStop, size) == -1
         || ArrayResize(MinBars,size) == -1)
        {
         string word="";
         StringConcatenate(word,"TradeSignalCounter( ",Number,
                           " ): Error!!! Unable to change sizes of variables arrays!!!");
         int error=GetLastError();
         ResetLastError();
         //---
         if(error>4000)
           {
            StringConcatenate(word,"TradeSignalCounter( ",Number," ): Error code ",error);
            Print(word);
           }
         Size_=-2;
         return(false);
        }

      Size_=int(size);
      Recount[Number] = false;
      MinBars[Number] = Kperiod + Dperiod + slowing;

      //--- get indicator's handle
      Handle[Number]=iCustom(SymbolA,0,"MultiStochastic_Exp",
                             Kperiod,Dperiod,slowing,ma_method,price_,
                             SymbolA,SymbolB,SymbolC);
     }
//--- check if number of bars is sufficient for calculation 
   if(Rates_Total(SymbolA,SymbolB,SymbolC)<MinBars[Number])return(true);
//--- check timeseries synchronization
   if(!SynchroCheck(SymbolA,SymbolB,SymbolC))return(true);
//--- get trade signals 
   if(IsNewBar(Number,SymbolA,0) || Recount[Number])
     {
      DnSignal[Number] = false;
      UpSignal[Number] = false;
      DnStop  [Number] = false;
      UpStop  [Number] = false;

      //--- using indicators' handles, copy values of indicator's 
      //--- buffers into static arrays, specially prepared for this purpose
      if(CopyBuffer(Handle[Number], 1, 1, 1, dDnSignal_) < 0){Recount[Number] = true; return(false);}
      if(CopyBuffer(Handle[Number], 2, 1, 1, dUpSignal_) < 0){Recount[Number] = true; return(false);}
      if(CopyBuffer(Handle[Number], 3, 1, 1, dDnStop_  ) < 0){Recount[Number] = true; return(false);}
      if(CopyBuffer(Handle[Number], 4, 1, 1, dUpStop_  ) < 0){Recount[Number] = true; return(false);}

      //--- convert obtained values into values of logic variables of trade commands
      if(dDnSignal_[0] == 300)DnSignal[Number] = true;
      if(dUpSignal_[0] == 300)UpSignal[Number] = true;
      if(dDnStop_  [0] == 300)DnStop  [Number] = true;
      if(dUpStop_  [0] == 300)UpStop  [Number] = true;

      //--- all copy operations from indicator's buffers completed successfully
      //--- unnecessary to return into this block until next bar change
      Recount[Number]=false;
     }
//----+
   return(true);
  }

No hay ninguna otra diferencia de concepto significativa en el código de este Expert Advisor (Exp_ResonanceHunter.mq5) puesto que se compila en base a algunos componentes funcionales. Así que, no creo que sea necesario dedicar más tiempo a su estructura interna.


Conclusión

En mi opinión, el código del Expert Advisor multidivisa en MQL5 es exactamente parecido al código de un Expert Advisor ordinario.


Traducción del ruso hecha por MetaQuotes Software Corp.
Artículo original: https://www.mql5.com/ru/articles/105

Archivos adjuntos |
multistochastic.mq5 (17.47 KB)
exp_tema.mq5 (25.17 KB)
Análisis de los patrones de velas Análisis de los patrones de velas

La construcción de un gráfico de velas japonesas y el análisis de los patrones de velas constituye un área fascinante del análisis técnico. La ventaja de las velas es que representan los datos de una forma que le permite hacer un seguimiento de las dinámicas en los datos. En este artículo vamos a analizar los tipos de velas, la clasificación de los patrones de velas y presentar un indicador que puede determinar patrones de velas.

Guía para escribir un DLL para MQL en Delphi Guía para escribir un DLL para MQL en Delphi

En este artículo examinaremos el mecanismo para crear un módulo DLL usando el popular lenguaje de programación de ObjectPascal dentr del entorno de programación de Delphi. Los materiales que se facilitan en este artículo están diseñados para dirigirse a programadores principiantes que trabajan con problemas que superan las barreras del lenguaje de programación incrustado de MQL5 conectando los módulos DLL externos.

Pruebas de rendimiento computacional de los promedios móviles en MQL5 Pruebas de rendimiento computacional de los promedios móviles en MQL5

Desde la creación del primer indicador de Promedio móvil, surgieron muchos indicadores. Muchos de ellos utilizan los mismos métodos de suavizado, pero no se han estudiado los rendimientos de los distintos algoritmos de los promedios móviles. En este artículo, vamos a examinar distintas maneras de utilizar los Promedios móviles en MQL5 y comparar su rendimiento.

Los principios del cálculo económico de los indicadores Los principios del cálculo económico de los indicadores

Las llamadas a los usuarios y a los indicadores técnicos requieren muy poco espacio en el código del programa de los sistemas de trading automatizados. Se trata a menudo de pocas líneas de código. Pero con frecuencia, son estas pocas líneas de código las que requieren la mayor parte del tiempo, destinada a probar el Expert Advisor. Por lo tanto, hay que tener en cuenta mucho más de lo parecía al principio todo lo que está relacionado con los cálculos de datos en un indicador. Este artículo trata justamente esta cuestión.