Moving Mini-Max: ein neuer Indikator für die technische Analyse und seine Umsetzung in MQL5

Einleitung

Es gibt eine Wissenschaft namens quantitative Finanzwissenschaft, die das Studium der Preismodelle von Finanzderivaten mithilfe der Methoden theoretischer und mathematischer Physik ermöglicht.

Kürzlich stieß ich auf eine Arbeit, die einen neuen Indikator für die technische Analyse beschreibt und Ideen aus der Quantenphysik kombiniert und sie auf die Finanzwelt überträgt. Mein Interesse war geweckt und ich beschloss, zu beschreiben, wie Indikatoren auf Basis wissenschaftlicher Arbeiten in MQL5 umgesetzt werden können.

Die Originalarbeit über den Moving Mini-Max [2] wurde von Z.K. Silagadze verfasst, einem Quantenphysiker vom Budker-Institut für Kernphysik und der Staatlichen Universität Nowosibirsk. Den Link zu der Arbeit sowie den MQL5-Quellcode finden Sie am Ende des Beitrags.

Indikator

Ich hätte nie erwartet, diesen Satz zu schreiben, doch ich erkläre jetzt den Tunneleffekt. Da ich annehme, dass die meisten Leser keine Quantenphysiker sind, werde ich ihn in einfachen Begriffen beschreiben und hoffe, dass Sie sich dadurch nicht angegriffen fühlen. Als Erstes definieren wir in einem Satz die Grundidee hinter der technischen Analyse von finanziellen Zeitreihen. Insbesondere wollen wir Folgendes finden:

• Unterstützungs- und Widerstandspreisniveaus;
• Richtung kurz- und langfristiger Trends;
• Höchst- und Tiefstpunkte der Trends.

Die ursprüngliche Idee hinter dem Indikator Moving Mini-Max ist es, Höchst- und Tiefstpunkte des Diagramms mithilfe einer Entsprechung eines Alphateilchens zu finden, das versucht, einem Nukleus zu entkommen. Diese Aufgabe wurde der Theorie des Alphazerfalls von George Gamov [1] entnommen.

Doch ein Bild sagt mehr als tausend Worte, deshalb sehen Sie unten ein kleines Diagramm.

 

Abbildung 1. Imaginäre Quantenkugel im Forex-Preisdiagramm

Stellen Sie sich vor, ein Ball wird vom Gipfel eines Hügels oder, in unserem Fall, von einem Höchstpunkt im Diagramm einer Zeitreihe geworfen. Nach der klassischen Mechanik wird er von Hindernissen abprallen und wird keine Chance haben, vor dem vordersten Hindernis anzuhalten, da er möglicherweise auf seinem Weg steckenbleibt.

Doch laut Quantenmechanik und der Theorie des Alphazerfalls kann ein solcher Ball mit einer sehr geringen, aber nicht fehlenden Wahrscheinlichkeit einen Tunnel durch die Hindernisse graben und seinen Weg zum potenziellen Grund des Brunnens finden und dort oszillieren.

Dies ist analog zur Aufgabe, einen lokalen Tiefstpunkt im Preisdiagramm zu finden. Die Arbeit von Z.K. Silagadze [2] schlägt vor, dass es genügt, Quantenverhalten zu imitieren, anstatt die echte quantenmechanische Aufgabe zu lösen, um die Komplexität der Berechnungen zu verringern. Ich stelle den mathematischen Hintergrund vor, der in der Originalarbeit vorgestellt wird, und lege danach die Umsetzung in MQL5 dar.

Es sei eine Preisreihe für einen bestimmten Zeitraum. Der Moving Mini-Max ist eine nichtlineare Umwandlung der Preisreihe: 

wobei und definiert sind, wie folgt:

 

Wie Sie sehen können, handelt es sich um eine wiederkehrende Relation, das heißt, das i-te Element hängt vom Element i-1 ab. Die Moving-Mini-Max-Reihe erfüllt die Normalisierungsanforderung, das heißt, die Summe aller Elemente ist gleich eins:

 

Die Tunnelwahrscheinlichkeiten einer Quantenkugel werden als Übergangswahrscheinlichkeiten bezeichnet, da sie Wahrscheinlichkeiten der Durchquerung schmaler Barrieren von Preisreihen imitieren – imaginären kleinen Hindernissen auf dem Weg nach unten:

wobei

 

Der Parameter m ist die Breite eines Glättungsfensters, das die (umgekehrte) Masse der Quantenkugel und deren Möglichkeit, durch kleine Hindernisse hindurchzulaufen, imitiert. Der alternative Moving Mini-Max d(si), der lokale Höchstpunkte betont, kann konstruiert werden, indem dem an die Funktion exp() übergebenen Parameter ein Minuszeichen vorangestellt wird: 

 

Umsetzung

Nachdem wir uns die Mathematik hinter dem Indikator angelesen haben, können wir ihn in MQL5 umsetzen. Dafür sollte man am besten von der letzten Gleichung ausgehen. Wenn Sie die Variablen m und n betrachten, sehen Sie, dass dieser Indikator ein Array aus n+2m Elementen der Preisreihe für ein Mini-Max-Fenster mit einer Länge von m Balken benötigt.

Das liegt an den Indizes S i+k und S i-k in der Berechnung der Variablen Q. Die Variable i wird von 1 auf n und k von 1 auf m erhöht, deshalb brauchen wir zu Beginn n+2m Puffer. Dies wird durch den folgenden Aufruf erreicht:

double S[];
ArrayResize(S,n+2*m);
CopyClose(Symbol(),0,0,n+2*m,S);

Damit werden ein Array des Typen double deklariert, seine Größe zu n+2m verändert und die Schließungswerte der letzten n+2m Balken aus dem Diagramm des aktuellen Symbols ab dem letzten Balken kopiert.

Der nächste Schritt ist die Berechnung der Werte Q. Wenn Sie die Definition sorgfältig lesen, sehen Sie, dass wir für das i-te Element der analysierten Zeitreihe m Ergebnisse der Funktion exp() mit den Variablen der Preiswerte summieren müssen. Deshalb müssen wir eine Schleife von 1 bis n einrichten, die alle Werte Q zählt:

void calcQii()
  {
   int i,k;

   for(i=0; i<n; i++)
     {
      double sqiip1=0;
      double sqiim1=0;
      double dqiip1=0;
      double dqiim1=0;

      for(k=0; k<m; k++)
        {
         sqiip1 += MathExp(2*(S[m-1+i+k]-S[i])/(S[m-1+i+k]+S[i]));
         sqiim1 += MathExp(2*(S[m-1+i-k]-S[i])/(S[m-1+i-k]+S[i]));

         dqiip1 += MathExp(-2*(S[m-1+i+k]-S[i])/(S[m-1+i+k]+S[i]));
         dqiim1 += MathExp(-2*(S[m-1+i-k]-S[i])/(S[m-1+i-k]+S[i]));       
        }
      sQiip1[i] = sqiip1;
      sQiim1[i] = sqiim1;
      dQiip1[i] = dqiip1;
      dQiim1[i] = dqiim1;

     }
  }

Wie Sie sehen können, berechnet die Funktion calcQii die i-ten Q- und Q'-Werte für das beobachtete Preisfenster der Größe n. Das Array S speichert die Preiswerte und sQiip1, sQiim1, dQiip1, dQiim1 werden als Zwischenberechnungsvariablen von Q und Q' genutzt.

Wahrscheinlichkeiten werden auf Basis der Variablen Q und Q' berechnet, deshalb können wir eine weitere Funktion erstellen, die sich mithilfe der Arrays sQii und dQii von 1 bis n wiederholt:

void calcPii()
  {
   int i;

   for(i=0; i<n; i++)
     {
      sPiip1[i] = sQiip1[i] / (sQiip1[i] + sQiim1[i]);
      sPiim1[i] = sQiim1[i] / (sQiip1[i] + sQiim1[i]);
      dPiip1[i] = dQiip1[i] / (dQiip1[i] + dQiim1[i]);
      dPiim1[i] = dQiim1[i] / (dQiip1[i] + dQiim1[i]);
     }
  }

Es müssen noch die Elemente von uSi und später von dSi berechnet und die Ergebnisse in die Arrays uSi und dSi eingetragen werden: 

void calcui()
  {
   int i;

   sui[0] = 1;
   dui[0] = 1;

   for(i=1; i<n; i++) 
     {
      sui[i] = (sPiim1[i]/sPiip1[i])*sui[i-1];
      dui[i] = (dPiim1[i]/dPiip1[i])*dui[i-1];
     }

   double uSum = 0;
   double dSum = 0;

   ArrayInitialize(uSi, 0.0);
   ArrayInitialize(dSi, 0.0);
   
   for(i=0; i<n; i++) { uSum+=sui[i]; dSum+=dui[i]; }
   for(i=0; i<n; i++) { uSi[n-1-i] = sui[i] / uSum; dSi[n-1-i] = dui[i] / dSum; }
 
  }

Um zu prüfen, ob die Normalisierungsanforderung erfüllt ist, können die folgenden Zeilen hinzugefügt werden:

   double result=0;
   for(i=0; i<n; i++) { /* Print("i = "+i+" uSi = "+uSi[i]); */ result+=uSi[i]; }

   Print("Result = "+ DoubleToString(result));

Wenn alle Berechnungen abgeschlossen sind, müssen wir die Ergebnisse im Indikatorfenster abbilden. Dafür müssen mindestens zwei Indikatorpuffer deklariert werden, einer für das Array uSi, der andere für dSi, und der Indikatortyp muss als DRAW_LINE definiert werden. 

    #property indicator_separate_window

    #property indicator_buffers 2
    #property indicator_plots 2
    #property indicator_type1 DRAW_LINE
    #property indicator_type2 DRAW_LINE
    #property indicator_color1 SeaGreen
    #property indicator_color2 BlueViolet

Anschließend weisen wir durch Aufruf der Funktion SetIndexBuffer() den Arrays uSi und dSi die Anzeige als INDICATOR_DATA zu:

   SetIndexBuffer(0,uSi,INDICATOR_DATA);
   SetIndexBuffer(1,dSi,INDICATOR_DATA);

   PlotIndexSetDouble(0,PLOT_EMPTY_VALUE,0.0);
   PlotIndexSetDouble(1,PLOT_EMPTY_VALUE,0.0);

   PlotIndexSetInteger(0,PLOT_SHIFT,-(m-1));
   PlotIndexSetInteger(1,PLOT_SHIFT,-(m-1));

 Abbildung 2. Umgesetzter Indikator Moving Mini-Max 

Mögliche Anwendungen des in diesem Beitrag beschriebenen Indikators sind die Identifizierung von Unterstützungs- und Widerstandsniveaus und die Identifizierung von Diagrammmustern durch innere Glättung des Indikators. Die Unterstützungs- und Widerstandsniveaus werden durch das Überkreuzen des Moving Mini-Max von Preisreihen und des Moving Mini-Max des gleitenden Mittelwerts geformt.

Wenn ein Preis durch das lokale Maximum verläuft und einen gleitenden Mittelwert überkreuzt, haben wir einen Widerstand. Nach der Umsetzung stellte ich fest, dass diese Methode ein paar falsche Signale sendet, doch ich liefere Ihnen einen Quellcode für die Platzierung dieser Linien in MQL5 mithilfe der Bibliothek ChartObjectsLines.mqh: 

void SR()
{
   // if price goes through local maximum and crosses a moving average draw resistance
   int i, cnt=0;
   int rCnt=CopyClose(Symbol(),0,0,n+2*m,S);
      
   for (i=n-2; i>=0; i--)
      if (uSi[i]<uSi_MA[i] && uSi[i+1]>=uSi_MA[i+1]) 
      {
      Print("Resistance at " + i);
      CChartObjectHLine *line=new CChartObjectHLine();
      line.Create(0, "MiniMaxResistanceLine:"+IntegerToString(cnt), 0, S[i]);
      line.Color(LightSkyBlue);
      line.Width(1);
      line.Background(true);
      line.Selectable(false);
      cnt++;
      }
   // if price goes through local minimum and crosses a moving average draw support

   for (i=n-2; i>=0; i--)
      if (dSi[i]<dSi_MA[i] && dSi[i+1]>=dSi_MA[i+1]) 
      {
      Print("Support at " + i);
      CChartObjectHLine *line=new CChartObjectHLine();
      line.Create(0, "MiniMaxSupportLine:"+IntegerToString(cnt), 0, S[i]);
      line.Color(Tomato);
      line.Width(1);
      line.Background(true);
      line.Selectable(false);
      cnt++;
      }
}

Ein interessantes Detail des Indikators ist, dass er lokale Mindest- und Höchstwerte von kurzfristigen Trends für ein bestimmtes Zeitfenster ziemlich gut erkennt. Es reicht aus, um die Differenz zwischen den höchsten und niedrigsten Werten von Moving Mini-Maxes zu filtern und sie als Anfang eines kurzfristigen Bullen- oder Bärentrends zu kennzeichnen.

Wir können dieses Verhalten wie bei anderen Indikatoren und Geldverwaltungssystemen ausnutzen, um einen gewinnbringenden Expert Advisor daraus zu machen.

Zum Kennzeichnen der höchsten Werte des aktuellen Zeitfensters können wir zusätzliche Indikatorpuffer nutzen, um Pfeile nach oben und unten anzuzeigen, wenn die Differenz am größten ist. Um den Indikator ansprechender zu gestalten, habe ich außerdem beschlossen, ein neues Feature von MQL5 zu nutzen: ein Farbhistogramm. Der Abwärts- und Aufwärtstrend sind verschieden gefärbt und die Trendänderung wird durch einen gelben Balken signalisiert. 

Um das Farbhistogramm zwischen zwei Puffern nutzen zu können, müssen wir 2 Datenpuffer und einen Puffer für Farbenindizes verwenden. Bitte sehen Sie sich die Definition der Darstellung an. Es gibt insgesamt 5 Indikatorpuffer und es sind drei Farben für das Farbhistogramm definiert.

//+------------------------------------------------------------------+
//|                                                MovingMiniMax.mq5 |
//|                                      Copyright 2011, Investeo.pl |
//|                                               http://Investeo.pl |
//+------------------------------------------------------------------+
#property copyright   "Copyright 2011, Investeo.pl"
#property link        "http://Investeo.pl"

#property description "Moving Mini-Max indicator"
#property description "proposed by Z.K. Silagadze"
#property description "from Budker Institute of Nuclear Physics"
#property description "and Novosibirsk State University"
#property description "Original paper can be downloaded from:"
#property description "http://arxiv.org/abs/0802.0984"

#property version     "0.6"
#property indicator_separate_window

#property indicator_buffers 5
#property indicator_plots 3

#property indicator_type1 DRAW_COLOR_HISTOGRAM2
#property indicator_type2 DRAW_ARROW
#property indicator_type3 DRAW_ARROW

#property indicator_color1 Chartreuse, OrangeRed, Yellow
#property indicator_color2 RoyalBlue
#property indicator_color3 RoyalBlue

#property indicator_width1 5
#property indicator_width2 4
#property indicator_width3 4

Bitte beachten Sie, dass das Histogramm zwei Puffer des Typen INDICATOR_DATA und einen des Typen INDICATOR_COLOR_INDEX verwendet. Diese Puffer müssen genau in der folgenden Reihenfolge eingerichtet werden: Zuerst kommen Datenpuffer, danach wird ein Farbindexpuffer definiert.

   SetIndexBuffer(0,uSi,INDICATOR_DATA);
   SetIndexBuffer(1,dSi,INDICATOR_DATA);
   SetIndexBuffer(2,trend,INDICATOR_COLOR_INDEX);
   SetIndexBuffer(3,upArrows,INDICATOR_DATA);
   SetIndexBuffer(4,dnArrows,INDICATOR_DATA);
   
   PlotIndexSetDouble(0,PLOT_EMPTY_VALUE,0.0);
   PlotIndexSetDouble(1,PLOT_EMPTY_VALUE,0.0);
   PlotIndexSetDouble(2,PLOT_EMPTY_VALUE,0.0);
   
   PlotIndexSetInteger(1,PLOT_ARROW,234);
   PlotIndexSetInteger(2,PLOT_ARROW,233);

Puffer 0, 1, 2 sind für das Farbhistogramm, Puffer 3 und 4 für die Anzeige der Pfeile.

Der Algorithmus der Färbung ist folgender:

   if (upind<dnind) 
    { 
      for (i=0; i<upind; i++) trend[i]=0;
      for (i=upind; i<dnind; i++) trend[i]=1;
      for (i=dnind; i<n; i++) trend[i]=0 ;
    } else
    {
      for (i=0; i<dnind; i++) trend[i]=1;
      for (i=dnind; i<upind; i++) trend[i]=0;
      for (i=upind; i<n; i++) trend[i]=1;
   }
   
   trend[upind] = 2;
   trend[dnind] = 2;

 Ich zeige Ihnen einen Screenshot des Endergebnisses:

Abbildung 3. Endgültige Version des Indikators Moving Mini-Max

Man muss daran denken, dass die Werte für Abwärts- und Aufwärtstrends bei jedem Eingang eines neuen Balkens für ein bestimmtes Zeitfenster berechnet werden. Deshalb wird der Indikator Moving Mini-Max genannt.

Obwohl er um m Balken verzögert ist, liefert er einen überraschend guten Überblick über den Trend im aktuellen Zeitfenster und interpretiert, wie der Markt 'atmet'.

Ich bin der Meinung, dass dieser Indikator gewinnbringend sein kann.

 

Fazit

Ich habe die Mathematik hinter einem neuen Indikator für die technische Analyse und dessen Umsetzung in MQL5 vorgestellt.

Die Originalarbeit von Z.K. Silagadze steht unter http://arxiv.org/abs/0802.0984 zur Verfügung. Der angehängte Quellcode steht zum Download bereit.

Ich hoffe, Ihnen in Zukunft noch weitere interessante technische Indikatoren und deren Umsetzung in MQL5 vorstellen zu können.

 

Literatur:

1. G.Gamov, Theory of alpha decay.
2. Z.K. Silagadze, Moving Mini-Max - a new indicator for technical analysis.