Dann fassen wir die resultierenden übereinstimmende Werte und Invertierungswerte zusammen. Ihre Differenz ist gleich -37. Durch Einfügen dieses Wertes in die Formel erhalten wir den Wert des Kendall-Koeffizienten: -0,82. Es ist wieder eine starke negative Korrelation. Das Ergebnis deutet jedoch darauf hin, dass diese Methode selektiver ist als die beiden vorherigen, da der Absolutwert kleiner ist.

Wie Sie sehen können, ist die Methode für den Korrelationskoeffizienten nach Fechner recht einfach. Das Ergebnis ist -0,8. Auch dies ist ein Hinweis auf eine stark negative Beziehung zwischen dem Schlusskurs und der Kerzenanzahl.

Implementierung von Indikatoren

Lassen Sie uns nun alle Methoden zur Korrelationsberechnung in der Sprache MQL5 implementieren. 

Korrelationskoeffizient nach Pearson

Da der Pearson-Koeffizient nach einer großen Formel berechnet wird, ist die Berechnung in zwei Stufen unterteilt, die Berechnung des Zählers und des Nenners.

//+------------------------------------------------------------------+
//| Berechnung des Zählers                                           |
//+------------------------------------------------------------------+
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;
  }
//+------------------------------------------------------------------+
//| Berechnung des Nenners                                           |
//+------------------------------------------------------------------+
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));
  }

Die endgültige Logik und Methode der Berechnung für eine Darstellung als Indikator sieht wie folgt aus:

//+------------------------------------------------------------------+
//| Funktion des nutzerdefinierten Indikators                        |
//+------------------------------------------------------------------+
int OnCalculate(const int rates_total,    // Anzahl der Bars in der Historie ab der aktuellen Bar
                const int prev_calculated,// Anzahl der bereits berechneten Bars
                const int begin,          // Index für den Array price[] für den Beginn
                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);
  }

//+------------------------------------------------------------------+
//| Berechnung des Korrelationskoeffizient nach Pearson              |
//+------------------------------------------------------------------+
double PearsonCalc(double &Ranks[],int N)
  {
   double ch,zn;
   ch=Numerator(Ranks,N);
   zn=Denominator(Ranks,N);
   return (ch/zn);
  }

Der Rang-Korrelationskoeffizient nach Spearman

//+------------------------------------------------------------------+
//| Funktion des nutzerdefinierten Indikators                        |
//+------------------------------------------------------------------+
int OnCalculate(const int rates_total,    // Anzahl der Bars in der Historie ab der aktuellen Bar
                const int prev_calculated,// Anzahl der bereits berechneten Bars
                const int begin,          // Index für den Array price[] für den Beginn
                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);
  }
//+------------------------------------------------------------------+
//| Berechnung des Korrelationskoeffizient nach 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)));
  }

//+------------------------------------------------------------------+
//| Funktion des nutzerdefinierten Indikators                        |
//+------------------------------------------------------------------+
int OnCalculate(const int rates_total,    // Anzahl der Bars in der Historie ab der aktuellen Bar
                const int prev_calculated,// Anzahl der bereits berechneten Bars
                const int begin,          // Index für den Array price[] für den Beginn
                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);
  }
//+------------------------------------------------------------------+
//| Berechnung des Korrelationskoeffizient nach 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);
  }
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
//| Funktion des nutzerdefinierten Indikators                        |
//+------------------------------------------------------------------+
int OnCalculate(const int rates_total,    // Anzahl der Bars in der Historie ab der aktuellen Bar
                const int prev_calculated,// Anzahl der bereits berechneten Bars
                const int begin,          // Index für den Array price[] für den Beginn
                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);
  }
//+------------------------------------------------------------------+
//| Berechnung des Korrelationskoeffizient nach 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);
  }

Abb.7 Den fallenden Korrelationskoeffizienten handeln.

Wie aus der Abbildung ersichtlich ist, gibt es zwei symmetrische Schwellenwerte für den Korrelationskoeffizienten: Sell Level 0.3 und Buy Level -0.3. Wenn der Verkaufswert nach unten gebrochen ist, verkaufen wir. Wir kaufen, wenn der Kaufwert nach oben durchbrochen wird.

Abb.8 Den steigenden Korrelationskoeffizienten handeln.  

Im zweiten Handelsmodus in Abb. 8 sind die Schwellenwerte für die Positionseröffnungen umgekehrt. Diesmal, wenn das Kaufniveau nach oben durchbrochen ist, wird eine Kaufposition eröffnet. Eine Verkaufsorder wird eröffnet, wenn das Verkaufsniveau nach unten gebrochen ist. 

Für die Implementierung in einem Expert Advisor benötigen wir die oben genannten Strategien und die Wahl einer geeigneten Korrelationsberechnungsmethode.

//+------------------------------------------------------------------+
//| Enumeration der Berechnungsmodi                                  |
//+------------------------------------------------------------------+
enum Strategy_type
  {
   DECREASE = 1,           // Fallend       
   INCREASE                // Steigend
  };
//+------------------------------------------------------------------+
//| Enumeration der Berechnungsmethoden der Korrelationen            |
//+------------------------------------------------------------------+
enum Corr_method
  {
   PEARSON = 1,            //Pearson       
   SPEARMAN,               //Spearman
   KENDALL,                //Kendall
   FECHNER                 //Fechner
  };

Zusätzlich zu den EA-Parametern fügen wir folgende Eingaben hinzu: Auswahl der Berechnungsmethode, der Strategie, der Schlüsselebene und des einstellbaren Arbeitszeitraums.

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

//--- Auswahl der Korrelationsberechnungsmethode und des Strategietyps
input    Corr_method          Inp_Corr_method=1;                           //Korrelationsmethode
input    Strategy_type        Inp_Strategy_type=1;                         //Strategietype

//--- EA Parameter
input    string               Inp_Str_label="===EA parameters===";         //Kennzeichnung
input    int                  Inp_MagicNum=1111;                           //Magicnummer
input    int                  Inp_StopLoss=40;                             //Stop-Loss(points)
input    int                  Inp_TakeProfit=60;                           //Take-Profit(points)
//--- Indicator parameters 
input    int                  Inp_RangeN=10;                               //Rangberechnung
input    double               Inp_KeyLevel=0.2;                            //Schwellenwert    
input    ENUM_TIMEFRAMES      Inp_Timeframe=PERIOD_CURRENT;                //Arbeitszeitrahmen

Die Korrektheit der Schwellenwerte wird bei der Initialisierung des EAs überprüft: Die Ebene muss zwischen 0 und 1 liegen, da für die Schwellenwerte ein Absolutwert verwendet werden.

//--- Überprüfung des Schwellenwertes
   if(Inp_KeyLevel>1 || Inp_KeyLevel<0)
     {
      Print(Inp_EaComment,": Incorrect key level!");
      return(INIT_FAILED);
     }

Definition der Berechnungsmethode gemäß dem Eingabeparameter:

//--- 
   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;
     }
//--- Erstzellen des Indikatorhandles 
   InpInd_Handle=iCustom(Symbol(),Inp_Timeframe,ind_type,Inp_RangeN);
   if(InpInd_Handle==INVALID_HANDLE)
     {
      Print(Inp_EaComment,": Fehler beim Erhalt des Indikatorhandles");
      Print("Handle = ",InpInd_Handle,"  error = ",GetLastError());
      return(INIT_FAILED);
     }

Danach können wir die Eröffnungsbedingungen festlegen:

//+------------------------------------------------------------------+
//| Experten Funktion OnTick                                         |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- Datenabfrage für die Berechnung

   if(!GetIndValue())
      return;

   if(!Trade.IsOpenedByMagic(Inp_MagicNum))
     {
      //--- Eröffnen einer Position wegen eines Kaufsignals
      if(BuySignal())
         Trade.BuyPositionOpen(Symbol(),Inp_Lot,Inp_StopLoss,Inp_TakeProfit,Inp_MagicNum,Inp_EaComment);
      //--- Eröffnen einer Position wegen eines Verkaufssignals
      if(SellSignal())
         Trade.SellPositionOpen(Symbol(),Inp_Lot,Inp_StopLoss,Inp_TakeProfit,Inp_MagicNum,Inp_EaComment);
     }
  }
//+------------------------------------------------------------------+
//| Kaufbedingungen                                                  |
//+------------------------------------------------------------------+
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;
  }
//+------------------------------------------------------------------+
//| Verkaufsbedingungen                                              |
//+------------------------------------------------------------------+
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;
  }

Tests

Der Expert Advisor wir mit folgenden Parametern getestet:

• Zeitraum: für den Modus des Aufwärtstrends 01.01.2015 — 01.12.2018.
• Währungspaar EURUSD.
• Ausführung: Ohne Verzögerung. Dies sind keine hochfrequenten Handelsstrategien, so dass der Effekt von Verzögerungen sehr gering wäre.
  
• Test: 1 Minute OHLC. Vortests an realen Ticks zeigen fast die gleichen Ergebnisse. 
  
• Einlage: 1000 USD.
• Test: 1 Minute OHLC. Vortests mit realen Ticks zeigen fast die gleichen Ergebnisse.
• Server: MetaQuotes-Demo.
• Kurse: 5 Dezimalstellen.

Parameter für die Tests und Optimierung.

Abb.9 Die Optimierungsparameter.

Die Optimierung wird helfen, festzustellen, welche der Berechnungsmethoden und Strategiearten besser geeignet ist. Die Tests und die Optimierungen führten zu folgenden Ergebnissen.

Abb.10 Test- und Optimierungsergebnisse.

Lassen Sie uns nun den EA mit den besten Optimierungsparametern testen.

Abb.11 Testergebnis mit den besten Optimierungsparametern.

Ergebnisse

Basierend auf den erzielten Ergebnissen können wir folgende Schlüsse ziehen:

• Die besten Ergebnisse werden bei fallendem Korrelationskoeffizienten im Modus On Decrease erzielt. Dieses Ergebnis lässt sich nur dadurch erklären, dass der Oszillator bei fallendem Koeffizienten schneller auf Marktbewegungen reagiert. Wie bereits erwähnt, weisen Oszillatoren, die auf Korrelationskoeffizienten basieren (insbesondere solche mit großen Perioden), eine signifikante Verzögerung auf.
• Die einfachste Berechnungsmethode (Fechner-Koeffizient) findet sich nicht unter den Top 20 Ergebnissen. Das beste Ergebnis mit dieser Methode liegt nur auf Platz 99. 
• Die besten Ergebnisse wurden bei kleinen Zeitfenstern mit engem Take Profit und Stop Loss erzielt.
• Es wurden keine Abhängigkeiten der Gewinnsumme von der ausgewählten Periode und der Schlüsselstufe gefunden. Es herrschen jedoch kleinere Perioden vor und die untere Grenze des Optimierungsbereichs mit der Periode 5 wird ständig unter den besten Ergebnissen gefunden. Dies ist eine weitere Bestätigung dafür, dass korrelationsbasierte Indikatoren eine große Verzögerung und über einen längeren Zeitraum ein schlechteres Ergebnis erzielen.

Das angehängte Archiv enthält alle besprochenen Dateien, die sich in den entsprechenden Ordnern befinden. Für den ordnungsgemäßen Betrieb müssen Sie lediglich den Ordner MQL5 in den Terminalverzeichnis speichern.

Programme, die im diesem Artikel verwendet werden