Sumamos los valores obtenidos de las coincidencias y los valores de las inversiones. Encontramos su diferencia -37, y tras insertarla en la fórmula, obtenemos el siguiente valor del coeficiente de correlación de Kendall -0,82. De nuevo vemos una fuerte correlación negativa lineal, no obstante, el resultado indica que este método de cálculo es más selectivo que los dos anteriores, puesto que el propio valor absoluto ha resultado menor.

Como podemos ver, el método de cálculo del coeficiente de correlación de Fechner es bastante sencillo, y su valor es igual a -0,8. Lo que, al igual que en los métodos anteriores, indica una fuerte dependencia negativa lineal del Precio de cierre con respecto al número de vela, o temporal.

Implementación de indicadores

Bien, vamos a implementar con los recursos MQL5 todos los métodos de cálculo de las correlaciones. 

Coeficiente de correlación de Pearson

Ya que el cálculo de este método contiene una fórmula voluminosa, para visualizar y comprender las etapas de cálculo de forma más cómoda, vamos a dividirla en dos etapas: el cálculo del numerador y el cálculo del denominador.

//+------------------------------------------------------------------+
//| Cálculo del numerador de la fórmula                              |
//+------------------------------------------------------------------+
double Numerator(double &Ranks[],int N)
  {
//----
   double Y[],dx[],dy[],mx=0.0,my=0.0,sum=0.0,sm=0.0;
   ArrayResize(Y,N);
   ArrayResize(dx,N);
   ArrayResize(dy,N);

   int n=N;
   for(int i=0; i<N; i++)
     {
      Y[i]=n;
      n--;
     }

   mx=Average(Y);
   my=Average(Ranks);

   for(int j=0;j<N;j++)
     {
      dx[j]=Y[j]-mx;
      dy[j]=Ranks[j]-my;
      sm+=dx[j]*dy[j];
     }
   return sm;
  }
//+------------------------------------------------------------------+
//| Cálculo del denominador de la fórmula                            |
//+------------------------------------------------------------------+
double Denominator(double &Ranks[],int N)
  {
//----
   double Y[],dx2[],dy2[],mx=0.0,my=0.0,sum=0.0,smx2=0.0,smy2=0.0;
   ArrayResize(Y,N);
   ArrayResize(dx2,N);
   ArrayResize(dy2,N);

   int n=N;
   for(int i=0; i<N; i++)
     {
      Y[i]=n;
      n--;
     }

   mx=Average(Y);
   my=Average(Ranks);

   for(int j=0;j<N;j++)
     {
      dx2[j]=MathPow(Y[j]-mx,2);
      dy2[j]=MathPow(Ranks[j]-my,2);
      smx2+=dx2[j];
      smy2+=dy2[j];
     }
   return(MathSqrt(smx2*smy2));
  }

El método final de cálculo y la lógica de cálculo de la visualización del indicador tienen el aspecto que se muestra en la lista:

//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int OnCalculate(const int rates_total,    // number of bars in history at the current tick
                const int prev_calculated,// number of bars calculated at previous call
                const int begin,          // bars reliable counting beginning index
                const double &price[]
                )

  {
   if(rates_total<rangeN+begin)
      return(0);
   int limit;

   if(prev_calculated>rates_total || prev_calculated<=0)
     {
      limit=rates_total-2-rangeN-begin;
      if(begin>0)
         PlotIndexSetInteger(0,PLOT_DRAW_BEGIN,rangeN+begin);
     }
   else
      limit=rates_total-prev_calculated;

   ArraySetAsSeries(price,true);

   for(int i=0; i<=limit; i++)
     {
      for(int k=0; k<rangeN; k++)
         PriceInt[k]=price[k+i];
      ExtLineBuffer[i]=PearsonCalc(PriceInt,rangeN);
     }

   return(rates_total);
  }

//+------------------------------------------------------------------+
//| Cálculo del coeficiente de correlación de Pearson                |
//+------------------------------------------------------------------+
double PearsonCalc(double &Ranks[],int N)
  {
   double ch,zn;
   ch=Numerator(Ranks,N);
   zn=Denominator(Ranks,N);
   return (ch/zn);
  }

Coeficiente de correlación de puestos de Spearman

//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int OnCalculate(const int rates_total,    // number of bars in history at the current tick
                const int prev_calculated,// number of bars calculated at previous call
                const int begin,          // bars reliable counting beginning index
                const double &price[]
                )

  {
   if(rates_total<rangeN+begin)
      return(0);
   int limit;

   if(prev_calculated>rates_total || prev_calculated<=0)
     {
      limit=rates_total-2-rangeN-begin;
      if(begin>0)
         PlotIndexSetInteger(0,PLOT_DRAW_BEGIN,rangeN+begin);
     }
   else
      limit=rates_total-prev_calculated;

   ArraySetAsSeries(price,true);

   for(int i=limit; i>=0; i--)
     {
      for(int k=0; k<rangeN; k++)
         PriceInt[k]=int(price[i+k]*multiply);

      RankPrices(TrueRanks,PriceInt);
      ExtLineBuffer[i]=SpearmanCalc(R2,rangeN);
     }

   return(rates_total);
  }
//+------------------------------------------------------------------+
//| Cálculo del coeficiente de correlación de Spearman               |
//+------------------------------------------------------------------+
double SpearmanCalc(double &Ranks[],int N)
  {
//----
   double sumd2=0.0;

   for(int i=0; i<N; i++)
      sumd2+=MathPow(Ranks[i]-i-1,2);

   return(1-6*sumd2/(N*(MathPow(N,2)-1)));
  }

//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int OnCalculate(const int rates_total,    // number of bars in history at the current tick
                const int prev_calculated,// number of bars calculated at previous call
                const int begin,          // bars reliable counting beginning index
                const double &price[]
                )

  {
   if(rates_total<rangeN+begin)
      return(0);
   int limit;

   if(prev_calculated>rates_total || prev_calculated<=0)
     {
      limit=rates_total-2-rangeN-begin;

      if(begin>0)
         PlotIndexSetInteger(0,PLOT_DRAW_BEGIN,rangeN+begin);
     }
   else
      limit=rates_total-prev_calculated;

   ArraySetAsSeries(price,true);

   for(int i=0; i<=limit; i++)
     {
      for(int k=0; k<rangeN; k++)
         PriceInt[k]=price[k+i];
      ExtLineBuffer[i]=KendallCalc(PriceInt,rangeN);
     }

   return(rates_total);
  }
//+------------------------------------------------------------------+
//| Cálculo del coeficiente de correlación de Kendall                |
//+------------------------------------------------------------------+
double KendallCalc(double &Ranks[],int N)
  {
   double Y[],t;
   ArrayResize(Y,N);

   int n=N;
   for(int i=0; i<N; i++)
     {
      Y[i]=n;
      n--;
     }
   MathCorrelationKendall(Ranks,Y,t);
   return (t);
  }
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int OnCalculate(const int rates_total,    // number of bars in history at the current tick
                const int prev_calculated,// number of bars calculated at previous call
                const int begin,          // bars reliable counting beginning index
                const double &price[]
                )

  {
   if(rates_total<rangeN+begin)
      return(0);
   int limit;

   if(prev_calculated>rates_total || prev_calculated<=0)
     {
      limit=rates_total-2-rangeN-begin;
      if(begin>0)
         PlotIndexSetInteger(0,PLOT_DRAW_BEGIN,rangeN+begin);
     }
   else
      limit=rates_total-prev_calculated;

   ArraySetAsSeries(price,true);
   for(int i=0; i<=limit; i++)
     {
      for(int k=0; k<rangeN; k++)
         PriceInt[k]=price[k+i];
      ExtLineBuffer[i]=FechnerCalc(PriceInt,rangeN);
     }

   return(rates_total);
  }
//+------------------------------------------------------------------+
//| Cálculo del coeficiente de correlación de Fechner                |
//+------------------------------------------------------------------+
double FechnerCalc(double &Ranks[],int N)
  {
   double Y[],res,mx,my,sum=0.0,markx[],marky[];
   double Na=0.0,Nb=0.0;
   ArrayResize(Y,N);
   ArrayResize(markx,N);
   ArrayResize(marky,N);

   int n=N;
   for(int i=0; i<N; i++)
     {
      Y[i]=n;
      n--;
     }

   mx=Average(Y);
   my=Average(Ranks);

   for(int j=0; j<N; j++)
     {
      markx[j]=(Y[j]>mx)?1:-1;
      marky[j]=(Ranks[j]>my)?1:-1;
      if(markx[j]==marky[j])
         Na++;
      else
         Nb++;
     }

   res=(Na-Nb)/(Na+Nb);
   return (res);
  }

Fig.7 Comercio con la caída del coeficiente de correlación.

Como podemos ver por las capturas de pantalla, hay dos niveles simétricos establecidos del coeficiente de correlación, Sell Level 0,3 y Buy Level -0,3. Al darse la ruptura de Sell Level de arriba hacia abajo, abrimos una orden de venta, y al darse la ruptura de Buy Level de abajo hacia arriba, abrimos una orden de compra.

Fig.8 Comercio con el aumento del coeficiente de correlación.  

En el segundo método de comercio, mostrado en la fig. 8, los niveles clave para entrar en el mercado son opuestos. Ahora, al darse la ruptura de Buy Level de abajo hacia arriba, abrimos una orden de compra, y al darse la ruptura de Sell Level de arriba hacia abajo, abrimos una orden de venta. 

Bien, al implementar el experto comercial, conviene tener en cuenta el uso de una de las estrategias ofrecidas, así como la selección del método de cálculo de la correlación.

//+------------------------------------------------------------------+
//| Enumeración de los modos de trabajo                              |
//+------------------------------------------------------------------+
enum Strategy_type
  {
   DECREASE = 1,           //On Decrease       
   INCREASE                //On Increase
  };
//+------------------------------------------------------------------+
//| Enumeración de los métodos de medición de la correlación         |
//+------------------------------------------------------------------+
enum Corr_method
  {
   PEARSON = 1,            //Pearson       
   SPEARMAN,               //Spearman
   KENDALL,                //Kendall
   FECHNER                 //Fechner
  };

En los parámetros de entrada, aparte de los parámetros del asesor, añadiremos la selección del método de cálculo, el nivel clave y la selección ajustable del marco temporal.

//+------------------------------------------------------------------+
//| Parámetros de entrada del experto                                |
//+------------------------------------------------------------------+
input    string               Inp_EaComment="Correlation Strategy";        //EA Comment
input    double               Inp_Lot=0.01;                                //Lot
input    MarginMode           Inp_MMode=LOT;                               //MM

//--- Eligiendo el método de cálculo de la correlación y el tipo de estrategia
input    Corr_method          Inp_Corr_method=1;                           //Correlation Method
input    Strategy_type        Inp_Strategy_type=1;                         //Strategy type

//--- Parámetros del experto
input    string               Inp_Str_label="===EA parameters===";         //Label
input    int                  Inp_MagicNum=1111;                           //Magic number
input    int                  Inp_StopLoss=40;                             //Stop Loss(points)
input    int                  Inp_TakeProfit=60;                           //Take Profit(points)
//--- Parámetros del indicador 
input    int                  Inp_RangeN=10;                               //Rang Calculation
input    double               Inp_KeyLevel=0.2;                            //Key Level    
input    ENUM_TIMEFRAMES      Inp_Timeframe=PERIOD_CURRENT;                //Working Timeframe 

Al inicializar el experto comercial, añadiremos la comprobación de la corrección del nivel clave, en concreto, debemos asegurarnos de que se encuentre entre 0 y 1. Ya que usaremos como nivel clave un valor absoluto.

//--- Comprobando que el nivel clave sea correcto
   if(Inp_KeyLevel>1 || Inp_KeyLevel<0)
     {
      Print(Inp_EaComment,": Incorrect key level!");
      return(INIT_FAILED);
     }

A continuación, seleccionamos el método de cálculo de la correlación elegido en los ajustes:

//--- 
   switch(Inp_Corr_method)
     {
      case 1:
         ind_type="Correlation\\PearsonCorrelation";
         break;
      case 2:
         ind_type="Correlation\\SpearmanCorrelation";
         break;
      case 3:
         ind_type="Correlation\\KendallCorrelation";
         break;
      case 4:
         ind_type="Correlation\\FechnerCorrelation";
         break;
      default:
         break;
     }
//--- Obteniendo el manejador del indicador 
   InpInd_Handle=iCustom(Symbol(),Inp_Timeframe,ind_type,Inp_RangeN);
   if(InpInd_Handle==INVALID_HANDLE)
     {
      Print(Inp_EaComment,": Failed to get indicator handle");
      Print("Handle = ",InpInd_Handle,"  error = ",GetLastError());
      return(INIT_FAILED);
     }

Después de ello, ajustamos las condciones de entrada y la lógica de funcionamiento del experto comercial.

//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- Obteniendo los datos para el cálculo

   if(!GetIndValue())
      return;

   if(!Trade.IsOpenedByMagic(Inp_MagicNum))
     {
      //--- Abriendo orden al darse la señal de compra
      if(BuySignal())
         Trade.BuyPositionOpen(Symbol(),Inp_Lot,Inp_StopLoss,Inp_TakeProfit,Inp_MagicNum,Inp_EaComment);
      //--- Abriendo orden al darse la señal de venta
      if(SellSignal())
         Trade.SellPositionOpen(Symbol(),Inp_Lot,Inp_StopLoss,Inp_TakeProfit,Inp_MagicNum,Inp_EaComment);
     }
  }
//+------------------------------------------------------------------+
//| Condiciones de compra                                            |
//+------------------------------------------------------------------+
bool BuySignal()
  {
   bool res=false;
   if(Inp_Strategy_type==1)
      res=(corr[1]>Inp_KeyLevel && corr[0]<Inp_KeyLevel)?true:false;
   else if(Inp_Strategy_type==2)
      res=(corr[0]>Inp_KeyLevel && corr[1]<Inp_KeyLevel)?true:false;
   return res;
  }
//+------------------------------------------------------------------+
//| Condiciones de venta                                             |
//+------------------------------------------------------------------+
bool SellSignal()
  {
   bool res=false;
   if(Inp_Strategy_type==1)
      res=(corr[1]<-Inp_KeyLevel && corr[0]>-Inp_KeyLevel)?true:false;
   else if(Inp_Strategy_type==2)
      res=(corr[0]<-Inp_KeyLevel && corr[1]>-Inp_KeyLevel)?true:false;
   return res;
  }

Simulación

Para la simulación del experto comercial obtenido, seleccionaremos los parámetros iniciales:

• Intervalo: Para el modo Uptrend 01.01.2015 — 01.12.2018.
• Pareja de divisas: EURUSD.
• Modo de comercio: Sin retrasos. Las estaretegias no se relacionan con las de alta precisión, por eso la influencia de los retrasos sería muy pequeña.
  
• Simulación: OHLC en М1. La simulación preliminar con ticks reales ha resultado casi indistinguible de este modo. 
  
• Depósito inicial: 1000 USD.
• Apalancamiento: 1:500.
• Servidor: MetaQuotes-Demo.
• Cotizaciones: de 5 dígitos.

Asimismo, elegimos los parámetros que serán simulados y optimizados.

Fig.9 Conjunto de parámetros optimizados.

Según los resultados de la optimización, podemos dilucidar cuál de los métodos de cálculo y qué tipos de estrategia resultan preferibles. Bien, según los resultados de la simulación y optimización, obtenemos lo siguiente.

Fig.10 Resultados de simulación y optimización.

Asimismo, realizaremos la simulación de los mejores parámetros de optimización.

Fig.11 Resultados de la simulación de los mejores parámetros.

Resumiendo

Basándonos en los resultados obtenidos, podemos hacer las siguientes observaciones:

• Los mejores resultados de las simulaciones pertenecen a la estrategia de caída del coeficiente de correlación, con el modo On Decrease. Este resultado solo se puede explicar de una forma: en la caída de los coeficientes tiene lugar una reacción más temprana al movimiento del mercado. Como ya hemos comentado antes, los osciladores basados en los coeficientes de correlación, especialmente con grandes periodos, se retrasan notablemente.
• Salta a la vista que el cálculo más simple del coeficiente de correlación de Fechner no entra en los 20 primeros. El mejor con este método se encuentra en el puesto 99. 
• Los mejores resultados se han dado en los marcos temporales pequeños, con un take profit y un stop loss también pequeño.
• No se ha encontrado ninguna dependencia de la magnitud del beneficio con respecto al periodo elegido y el nivel clave preestablecido. No obstante, prevalecen los periodos pequeños, en concreto, el límite inferior del intervalo de optimización  con periodo 5 se encuentra constantemente entre los mejores resultados. Esto nos indica de nuevo que los indicadores basados en la correlación se retrasan mucho con la entrada en los periodos grandes, dando peores resultados.

Al final del artículo se adjunta un fichero con todos los archivos enumerados, clasificados por carpetas. Por eso, para que funcione correctamente, basta con colocar la carpeta MQL5 en la carpeta raíz del terminal.

Programas usados en el artículo: