Then we sum up the resulting matching values and inversion values. Their difference is equal to -37. By inserting this value into the formula, we get the Kendall coefficient equal to -0,82. It is again a strong negative correlation. However the result suggests that this method is more selective, than the previous two ones, because the absolute value is smaller.

As you can see, the Fechner correlation coefficient calculation method is quite simple. The resulting value is -0,8. Again, this is an indication of a strong negative relationship between the Close price and the candlestick number.

Implementation of indicators

Now, let us implement all the correlation calculation methods using the MQL5 language. 

Pearson correlation coefficient

Since the Pearson coefficient is calculated using a large formula, the calculation is divided into two stages, calculation of the numerator and the denominator.

//+------------------------------------------------------------------+
//| Calculation of the numerator                                     |
//+------------------------------------------------------------------+
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;
  }
//+------------------------------------------------------------------+
//| Calculation of the denominator                                   |
//+------------------------------------------------------------------+
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));
  }

The final calculation method and calculation logic for indicator visualization look as follows:

//+------------------------------------------------------------------+
//| 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);
  }

//+------------------------------------------------------------------+
//| Calculation of Pearson correlation coefficient                   |
//+------------------------------------------------------------------+
double PearsonCalc(double &Ranks[],int N)
  {
   double ch,zn;
   ch=Numerator(Ranks,N);
   zn=Denominator(Ranks,N);
   return (ch/zn);
  }

Spearman's rank correlation coefficient

//+------------------------------------------------------------------+
//| 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);
  }
//+------------------------------------------------------------------+
//| Calculation of Spearman correlation coefficient                  |
//+------------------------------------------------------------------+
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);
  }
//+------------------------------------------------------------------+
//| Calculation of Kendall correlation coefficient                   |
//+------------------------------------------------------------------+
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);
  }
//+------------------------------------------------------------------+
//| Calculation of Fechner correlation coefficient                   |
//+------------------------------------------------------------------+
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 Trading the fall of the correlation coefficient.

As can be seen from the screenshots, there are two symmetrical correlation coefficient levels Sell Level 0.3 and Buy Level -0.3. When the Sell Level is broken downwards, open a Sell order. A Buy order is placed when the Buy Level is broken upwards.

Fig.8 Trading the growth of the correlation coefficient.  

In the second trading mode shown in Fig. 8, the key market entry levels are the opposite. This time, when the Buy Level is broken upwards, a buy order is opened. A sell order is opened when the Sell Level is broken downwards. 

To implement and Expert Advisor, we need provide the above strategies and choose an appropriate correlation calculation method.

//+------------------------------------------------------------------+
//| Enumeration of operating modes                                   |
//+------------------------------------------------------------------+
enum Strategy_type
  {
   DECREASE = 1,           //On Decrease       
   INCREASE                //On Increase
  };
//+------------------------------------------------------------------+
//| Enumeration of correlation calculation methods                   |
//+------------------------------------------------------------------+
enum Corr_method
  {
   PEARSON = 1,            //Pearson       
   SPEARMAN,               //Spearman
   KENDALL,                //Kendall
   FECHNER                 //Fechner
  };

In addition to the EA parameters, let us add the following inputs: selection of calculation method, the strategy the key level and the adjustable operating timeframe.

//+------------------------------------------------------------------+
//| Expert Advisor input parameters                                  |
//+------------------------------------------------------------------+
input    string               Inp_EaComment="Correlation Strategy";        //EA Comment
input    double               Inp_Lot=0.01;                                //Lot
input    MarginMode           Inp_MMode=LOT;                               //MM

//--- Выбор метода расчета корреляции и тип стратегии
input    Corr_method          Inp_Corr_method=1;                           //Correlation Method
input    Strategy_type        Inp_Strategy_type=1;                         //Strategy type

//--- EA parameters
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)
//--- Indicator parameters 
input    int                  Inp_RangeN=10;                               //Rang Calculation
input    double               Inp_KeyLevel=0.2;                            //Key Level    
input    ENUM_TIMEFRAMES      Inp_Timeframe=PERIOD_CURRENT;                //Working Timeframe 

The correctness of the key level will be checked at the EA initialization step: the level must be located between 0 and 1, because an absolute value will be used for the level.

//--- Checking the correctness of the key level
   if(Inp_KeyLevel>1 || Inp_KeyLevel<0)
     {
      Print(Inp_EaComment,": Incorrect key level!");
      return(INIT_FAILED);
     }

Then set the correlation calculation method selected in inputs:

//--- 
   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;
     }
//--- Getting the indicator handle 
   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);
     }

After that, we can set up entry conditions and EA operating logic.

//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- Getting data for calculations

   if(!GetIndValue())
      return;

   if(!Trade.IsOpenedByMagic(Inp_MagicNum))
     {
      //--- Opening an order if there is a buy signal
      if(BuySignal())
         Trade.BuyPositionOpen(Symbol(),Inp_Lot,Inp_StopLoss,Inp_TakeProfit,Inp_MagicNum,Inp_EaComment);
      //--- Opening an order if there is a sell signal
      if(SellSignal())
         Trade.SellPositionOpen(Symbol(),Inp_Lot,Inp_StopLoss,Inp_TakeProfit,Inp_MagicNum,Inp_EaComment);
     }
  }
//+------------------------------------------------------------------+
//| Buy conditions                                                   |
//+------------------------------------------------------------------+
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;
  }
//+------------------------------------------------------------------+
//| Sell conditions                                                  |
//+------------------------------------------------------------------+
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;
  }

Testing

The Expert Advisor will be tested with the following parameters:

• Interval: for the Uptrend mode01.01.2015 — 01.12.2018.
• Currency pair: EURUSD.
• Trading mode: No delay. These are not high-frequency trading strategies, so the effect of delays would be very small.
  
• Testing: M1 OHLC. Pre-testing on real ticks shows nearly the same results. 
  
• Initial deposit: 1000 USD.
• Leverage: 1:500.
• Server: MetaQuotes-Demo.
• Quotes: 5-digit.

Testing and optimization parameters.

Fig.9 The set of parameters to be optimized.

The optimization will help determine which of the calculation methods and strategy types is more preferable. Testing and optimization produced the following results.

Fog.10 Testing and optimization results.

Now let us test the EA using the best optimization parameters.

Fig.11 Testing results with the best optimization parameters.

Findings

Based on the results obtained, the following observations can be made:

• The best results are obtained with the correlation coefficient fall strategy, in the On Decrease mode. This result can only be explained by the fact that when coefficients fall, the oscillator faster responds to market movements. As mentioned above, oscillators based on correlation coefficients (especially those having large periods) have significant lagging.
• The simplest calculation method (Fechner coefficient) is not found among the top 20 results. The best result with this method is only located in the 99th place. 
• The best results were obtained on small timeframes with tight take profit and stop loss.
• No dependencies of profit amount on the selected period and the key level have been found. However smaller periods prevail and the lower limit of the optimization range with the period of 5 is constantly encountered among the best results. This is another confirmation that correlation based indicators have a large delay on large period and show worse results.

The attached archive contains all the listed files, which are located in the appropriate folders. For their proper operation, you only need to save the MQL5 folder into the terminal folder.

Programs used in the article