MetaTrader 5 herunterladen

Muster, die beim Handeln mit Währungskörben verfügbar sind. Teil II.

3 April 2017, 15:37
Andrei Novichkov
0
283

Einleitung

Der vorherige Artikel über Muster beim Handeln mit Währungskörben beschäftigte sich hauptsächlich mit vereinigten Indikatoren, die basierend auf Oszillatoren erstellt werden. Als Beispiel wurde der vereinigte Indikator Williams’Percent Range angeführt, und als Ergebnis haben wir mehrere Muster erhalten, ihre Vor- und Nachteile betrachtet und Schlussfolgerungen über die Anwendungmöglichkeit jedes Musters im realen Handel gezogen.

Es ist offensichtlich, dass die geleistete Arbeit nicht ausreicht. Vereinigte Indikatoren auf Basis von Oszillatoren können den Bedarf der Trader an der technischen Analyse des Zustands der Währungkörbe nie decken. Der Set solcher Indikatoren muss durch vereinigte Trendindikatoren ergänzt werden. Dies würde den Set der technischen Werkzeuge vervollständigen. Vereinigte Trendindikatoren haben ihre eigenen Muster. Die Erforschung dieser Tatsache flößt uns Sicherheit ein, dass wir alle grundlegenden Arten von Mustern festgestellt haben, und dass nichts außer Acht gelassen wurde.

Erstellen wir einen Testindikator, um diese Aufgabe zu lösen. Verwenden wir den Code aus dem vorherigen Artikel und modifizieren wir ihn ein bisschen. Aber zuerst sollte man auf einige spezifischen Besonderheiten vereinigter Trendindikatoren hinweisen. Hier und weiter werden wir die Terminologie verwenden, die wir in den vorherigen Artikeln eingeführt haben.


Besonderheiten vereinigter Trendindikatoren

Die vereinigten Trendindikatoren können auf Basis jeder Trend-Basisklasse erstellt werden. Es gibt aber einige Begrenzungen, die erste von denen lautet:

- vereinigte Indikatoren müssen sich in einem separaten Fenster befinden. Sonst welchen Sinn hat die Anzeige eines solchen Indikators im Preischartfenster? Gar keinen, das bestätigt das grundlegende Prinzip des Zeichnens vereinigter Indikatoren - das Mittelungprinzip. Es ist absolut unklar, was ein solcher Indikator anzeigen wird. Darüber hinaus ist es offensichtlich, dass es Probleme mit Messeinheiten geben wird, die sich von denen auf dem Chart unterscheiden werden. Daraus folgt, dass weder gleitende Durchschnitte noch Bollinger Bands noch weitere Indikatoren, die sich auf Preischarts befinden als Basisindikatoren verwendet werden können.

Es gibt eine weitere wichtige Begrenzung:

- Jedes Währungspaar besteht aus zwei Währungskörben, wie das in den vorherigen Artikel gezeigt wurde. Ein vereinigter Indikator zeigt den Status nur einer Währung an. Deswegen stellen zwei vereinigte Indikatoren den Zustand eines Währungspaares am besten dar, wie dies im ersten Teil des Artikels über Muster beschrieben wurde. Im Vergleich zu vereinigten Indikatoren auf Basis von Oszillatoren, können vereinigte Trendindikatoren nur in separaten Fenstern platziert werden, deswegen werden für zwei vereinigte Trendindikatoren zwei zusätzliche Fenster benötigt. Das liegt am Untеrschied im Maßstab. Wenn sich die vereinigte Indikatoren auf Basis von Oszillatoren immer innerhalb der im Voraus bekannten Bereichen ändern, ist das bei Trendindikatoren anders. Weder Höchstwert noch Mindestwert sind im Voraus bekannt. Daraus folgt, dass der beschriebene Ansatz mit der Berechnung der Differenz zwischen den Werten von zwei vereinigten Indikatoren sowie die Anwendung des gleitenden Durchschnitts sinnlos sind. Die vereinigten Trendindikatoren können ihre Werte für solche gemeinsamen Berechnungen nicht bereitstellen.

Die Begrenzungen engen den Bereich für die Erstellung vereinigter Trendindikatoren ein, indem sie die Liste der Basisklassen einschränken. Aus der ganzen Liste der Trendindikatoren aus dem MetaTrader 5 Menü "Trendindikatoren" passen vorläufig ADX und StdDev. Das ist aber kein Anlass, sich auf die Lösung der Aufgabe zu verzichten. Wir werden mit vorhandenen Werkzeugen arebeiten und fangen mit dem vereinigten Trendindikator an, den wir bereits verwendet haben, und zwar mit dem Index der Korbwährung:


Index der Korbwährung mit gleitendem Durchschnitt

Schreiben wir den Testindikator testIndexMA.mq5, analog dem in diesem Artikel angewandten Indikator. Fügen wir diesem Indikator einen gleitenden Durchschnitt hinzu:

//+------------------------------------------------------------------+
//|                                                 testDistance.mq5 |
//|                                   2016 MetaQuotes Software Corp. |
//|                                              http://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2016, MetaQuotes Software Corp."
#property link      "http://www.mql5.com"
#property version   "1.00"
#property indicator_separate_window

#property indicator_buffers 2
#property indicator_plots   2


input color   clr= clrGreen;
input color   clrMA = clrMagenta;
input int maperiod  = 10; //Period MA

double ind[],ma[];
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
//int h,h1;
int OnInit()
  {
//--- indicator buffers mapping
   ArraySetAsSeries(ind,true);
   SetIndexBuffer(0,ind);        
  
   IndicatorSetString(INDICATOR_SHORTNAME,"testdistance");
   IndicatorSetInteger(INDICATOR_DIGITS,2);
   PlotIndexSetInteger(0,PLOT_DRAW_TYPE,DRAW_LINE);
   PlotIndexSetInteger(0,PLOT_LINE_STYLE,STYLE_SOLID);
   PlotIndexSetInteger(0,PLOT_LINE_WIDTH,2);
   PlotIndexSetInteger(0,PLOT_LINE_COLOR,clr);
   PlotIndexSetString(0,PLOT_LABEL,"_tstdistance_");    

   ArraySetAsSeries(ma,true);  
   SetIndexBuffer(1,ma);
   PlotIndexSetInteger(1, PLOT_DRAW_TYPE, DRAW_LINE           );
   PlotIndexSetInteger(1, PLOT_LINE_STYLE, STYLE_SOLID            );
   PlotIndexSetInteger(1, PLOT_LINE_WIDTH, 1            );
   PlotIndexSetInteger(1, PLOT_LINE_COLOR, clrMA            );
   PlotIndexSetString (1, PLOT_LABEL, "_tstdistance_MA" );        
//---
   return(INIT_SUCCEEDED);
  }
  
string pair[]={"EURUSD","GBPUSD","AUDUSD","NZDUSD","USDCAD","USDCHF","USDJPY"};
bool bDirect[]={false,false,false,false,true,true,true};
int iCount=7;
  
double GetValue(int shift)
  {
   double res=1.0,t;
   double dBuf[1];
   for(int i=0; i<iCount; i++)
     {
      t=CopyClose(pair[i],PERIOD_CURRENT,shift,1,dBuf);
      if(!bDirect[i]) dBuf[0]=1/dBuf[0];
      res*=dBuf[0];
     }//end for (int i = 0; i < iCount; i++)
   return (NormalizeDouble(MathPow (res, 1/(double)iCount), _Digits) );  
  }  
//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int OnCalculate(const int rates_total,
                const int prev_calculated,
                const datetime &time[],
                const double &open[],
                const double &high[],
                const double &low[],
                const double &close[],
                const long &tick_volume[],
                const long &volume[],
                const int &spread[])
  {
   if(prev_calculated==0 || rates_total>prev_calculated+1)
     {
      int rt=rates_total;
      for(int i=1; i<rt; i++)
        {
         ind[i]= GetValue(i);
        }
         rt -= maperiod;  
         for (int i = 1; i< rt; i++)
           {
            ma[i] = GetMA(ind, i, maperiod, _Digits);
           }        
     }
   else
     {
         ind[0]= GetValue(0);
          ma[0] = GetMA(ind, 0, maperiod, _Digits);
     }
//--- return value of prev_calculated for next call
   return(rates_total);
  }
void OnDeinit(const int reason)
  {
   string text;
   switch(reason)
     {
      case REASON_PROGRAM:
         text="Indicator terminated its operation by calling the ExpertRemove() function";break;
      case REASON_INITFAILED:
         text="This value means that OnInit() handler "+__FILE__+" has returned a nonzero value";break;
      case REASON_CLOSE:
         text="Terminal has been closed"; break;
      case REASON_ACCOUNT:
         text="Account was changed";break;
      case REASON_CHARTCHANGE:
         text="Symbol or timeframe was changed";break;
      case REASON_CHARTCLOSE:
         text="Chart was closed";break;
      case REASON_PARAMETERS:
         text="Input-parameter was changed";break;
      case REASON_RECOMPILE:
         text="Program "+__FILE__+" was recompiled";break;
      case REASON_REMOVE:
         text="Program "+__FILE__+" was removed from chart";break;
      case REASON_TEMPLATE:
         text="New template was applied to chart";break;
      default:text="Another reason";
     }
   PrintFormat("%s",text);
  }
//+------------------------------------------------------------------+

double GetMA(const double& arr[], int index , int period, int digit) {
   double m = 0;
   for (int j = 0; j < period; j++)  m += arr[index + j];
   m /= period;
   return (NormalizeDouble(m,digit));
}
Mit diesem Set der Ausgabedaten wird der Indikator den Dollarindex mit dem schnellen gleitenden Durchschnitt zeichnen. Ändern wir die Zeilen 49 und 50 wie folgt:

string pair[]={"EURUSD", "EURJPY", "EURCHF", "EURGBP", "EURNZD", "EURCAD", "EURAUD"};
bool bDirect[]={true,true,true,true,true,true,true};
Wiederholen wir die Kompilation mit dem Namen testIndexMA2.mq5. Wir erhalten den gleichen Indikator, der aber den Euroindex anzeigt. Platzieren wir den Indikator auf dem Stundenchart EURUSD:




Die absoluten Werte des Indikators interessieren uns noch nicht. Schauen wir uns die Schnittpunkte des Indikators mit dem gleitenden Durchschnitt als potentielle Einstiegspunkte an. Erinnern wir uns daran, worum es in den vorherigen Artikeln ging: diese Punkte müssen beim Schließen einer Kerze fixiert werden, was wir auch getan haben. Heben wir die ermittelten Einstiegspunkte mit vertikalen Linien hervor - blau für Kaufen, rot für Verkaufen. Bei aller Strittigkeit der Auswahl des Parameters für die Berechnung des gleitenden Durchschnitts, wird das positive Ergebnis ganz deutlich. Der Profit ist nicht groß und nicht besonders stabil, deswegen muss man an die Erhöhung der Profitabilität denken. Zunächst einmal denken wir daran, dass es im EURUSD Währungspaar auch der Dollar mit seinem Index vorhanden ist. Fügen wir den Indikator des Dollarindex auf den Chart hinzu:

Fügen wir vertikale Linien hinzu und markieren wir die Stellen, an welchen sich der gleitende Durchschnitts und die Grafik des Dollarindex kreuzen. Analysieren wir das Bild:

  • Zunächst einmal fällt uns auf, dass der Schnittpunkt des Index und des gleitenden Durchschnitts auf einen möglichen Trendwechsel deutlicher hinweist, wenn die andere Währung den gleichen Schnittpunkt kurz davor hatte. Dabei müssen die Schnittpunkte "gegenläufig" sein, und zwar: wenn die Grafik des Index einer Währung den gleitenden Durchschnitt von unten nach oben durchkreuzt, muss die Grafik der zweiten Währung den gleitenden Durchschnitt von oben nach unten durchkreuzen. Dieser Fall wurde auch früher betrachtet, die Situation signalisiert die Stärkung einer Währung und eine gleichzeitige Schwächung der anderen.
  • Zweitens wenn es Schnittpunkte auf beiden Grafiken des Index gibt, aber in einer Richtung, zum Beispiel von oben nach unten, sollte man auf Einstieg verzichten. Diese Situation spricht von einer hohen Wahrscheinlichkeit eines Seitwärtsmarkts.
  • Drittens müssen die Schnittpunkte offensichtlich, sichtbar sein. Dieser Punkt wurde ausführlich im vorherigen Artikel erläutert.

Aus dem bereits Dargelegten kann man die erste Schlussfolgerung ziehen:

- beim Einstieg muss man den Index der beiden Währungen berücksichtigen. Besonders bevorzugt ist der Einstieg bei der Stärkung einer Währung und einer gleichzeitigen Schwächung der anderen. Um eine solche Situation zu erwischen, wartet der Trader auf den Moment, wenn die Grafik des Index einer der Währungen den gleitenden Durchschnitt durchkreuzt. Das ist nur ein Teil der benötigten Situation, die die Stärkung/Schwächung einer der Währungen signalisiert. Für die Bestätigung des Signals muss man auf die Stärkung/Schwächung der zweiten Währung warten und erst dann vielleicht in den Markt einsteigen.

Offen bleibt die Frage: wie weit können die Schnittpunkte der Grafiken und der gleitenden Durchschnitte auf verschiedenen Währungen voneinander liegen? Offensichtlich ist der minimale Abstand gleich Null. Für den maximalen Abstand gibt es keine eindeutige Antwort, wie es häufig auf dem Devisenmarkt der Fall ist. Zugleich muss dieser Abstand vorhanden sein. Es ist gefährlich einzusteigen, wenn der Moment der Schwächung einer Währung und der Stärkung der anderen zeitlich zu weit voneinander liegen. Der Trader kann mit Divergenz und einer Trendabschwächung als Folge konfrontiert werden.

Wir sind also in der Erhöhung der Qualität des Einstiegs deutlich vorangekommen. Schauen wir nun, was wir zusätzlich tun kann. Am Anfang des Artikels sagten wir, dass absolute Werte, die der Inikator annimmt, uns erstmal nicht interessieren. Es ist höchste Zeit darauf genauer einzugehen.


Express-Analyse mithilfe des ZigZag Indikators

Für die weitere Arbeit verwenden wir einen Indikator auf Basis von ZigZag, welchen unser Kollege für öffentlichen Gebrauch freundlicherweise hier bereitgestellt hat. Platzieren wir den iUniZigZagPriceSW.mq5 unmittelbar auf dem Chart des Dollarindex. Wir werden das folgende Bild sehen:



Hier ist die ZigZag Grafik mit dicker blauer Linie abgebildet. Unser Ziel ist, die Länge der ZigZag Strecken zu analysieren und diese Werte zu systematisieren. Kann man sagen, dass wir auf diese Weise "Amplitude von Swings" des Dollarindex erhalten? Ich werde das nicht behaupten, das ist aber durchaus möglich. Nehmen wir einige Änderungen für die weitere Arbeit im Code des Indikators vor:


//+------------------------------------------------------------------+
//|                                                 iUniZigZagSW.mq5 |
//|                        Copyright 2016, MetaQuotes Software Corp. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2016, MetaQuotes Software Corp."
#property link      "https://www.mql5.com"
#property version   "1.00"
#property indicator_separate_window
#property indicator_buffers 6
#property indicator_plots   3
//--- plot High
#property indicator_label1  "High"
#property indicator_type1   DRAW_LINE
#property indicator_color1  clrGreen
#property indicator_style1  STYLE_SOLID
#property indicator_width1  1
//--- plot Low
#property indicator_label2  "Low"
#property indicator_type2   DRAW_LINE
#property indicator_color2  clrGreen
#property indicator_style2  STYLE_SOLID
#property indicator_width2  1
//--- plot ZigZag
#property indicator_label3  "ZigZag"
#property indicator_type3   DRAW_SECTION
#property indicator_color3  clrRed
#property indicator_style3  STYLE_SOLID
#property indicator_width3  1
//--- plot Direction
#property indicator_label4  "Direction"
#property indicator_type4   DRAW_LINE
#property indicator_style4  STYLE_SOLID
#property indicator_width4  1
//--- plot LastHighBar
#property indicator_label5  "LastHighBar"
#property indicator_type5   DRAW_LINE
#property indicator_style5  STYLE_SOLID
#property indicator_width5  1
//--- plot LastLowBar
#property indicator_label6  "LastLowBar"
#property indicator_type6   DRAW_LINE
#property indicator_style6  STYLE_SOLID
#property indicator_width6  1

#include <ZigZag\CSorceData.mqh>
#include <ZigZag\CZZDirection.mqh>
#include <ZigZag\CZZDraw.mqh>
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
enum EDirection
  {
   Dir_NBars=0,
   Dir_CCI=1
  };
//--- input parameters
input EDirection  DirSelect=Dir_NBars;
input int                  CCIPeriod   =  14;
input ENUM_APPLIED_PRICE   CCIPrice    =  PRICE_TYPICAL;
input int                  ZZPeriod=14;
input string               name="index-usd-zz.txt";

CZZDirection*dir;
CZZDraw*zz;

//--- indicator buffers
double         HighBuffer[];
double         LowBuffer[];
double         ZigZagBuffer[];
double         DirectionBuffer[];
double         LastHighBarBuffer[];
double         LastLowBarBuffer[];
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int h;
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int OnInit()
  {
   switch(DirSelect)
     {
      case Dir_NBars:
         dir=new CNBars(ZZPeriod);
         break;
      case Dir_CCI:
         dir=new CCCIDir(CCIPeriod,CCIPrice);
         break;
     }
   if(!dir.CheckHandle())
     {
      Alert("Fehler beim Laden des Indikators 2");
      return(INIT_FAILED);
     }
   zz=new CSimpleDraw();
//--- indicator buffers mapping
   SetIndexBuffer(0,HighBuffer,INDICATOR_DATA);
   SetIndexBuffer(1,LowBuffer,INDICATOR_DATA);
   SetIndexBuffer(2,ZigZagBuffer,INDICATOR_DATA);
   SetIndexBuffer(3,DirectionBuffer,INDICATOR_CALCULATIONS);
   SetIndexBuffer(4,LastHighBarBuffer,INDICATOR_CALCULATIONS);
   SetIndexBuffer(5,LastLowBarBuffer,INDICATOR_CALCULATIONS);
   h=FileOpen(name,FILE_CSV|FILE_WRITE|FILE_ANSI,',');
//---
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {

   if(CheckPointer(dir)==POINTER_DYNAMIC)
     {
      delete(dir);
     }
   if(CheckPointer(zz)==POINTER_DYNAMIC)
     {
      delete(zz);
     }
  }
//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int ind=0;
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int OnCalculate(const int rates_total,
                const int prev_calculated,
                const int begin,
                const double &price[]
                )
  {
   int start;

   if(prev_calculated==0)
     {
      start=0;
     }
   else
     {
      start=prev_calculated-1;
     }

   for(int i=start;i<rates_total;i++)
     {
      HighBuffer[i]=price[i];
      LowBuffer[i]=price[i];
     }

   int rv;
   rv=dir.Calculate(rates_total,
                    prev_calculated,
                    HighBuffer,
                    LowBuffer,
                    DirectionBuffer);
   if(rv==0)return(0);
   zz.Calculate(rates_total,
                prev_calculated,
                HighBuffer,
                LowBuffer,
                DirectionBuffer,
                LastHighBarBuffer,
                LastLowBarBuffer,
                ZigZagBuffer);

   if(ind<= 10) ind++;
   if(ind == 10)
     {
      double mx=0,mn=1000000;
      double lg;
      for(int i=0;i<rates_total;i++)
        {
         if(ZigZagBuffer[i]==0 || ZigZagBuffer[i]==EMPTY_VALUE) continue;
         if(ZigZagBuffer[i] > mx) mx = ZigZagBuffer[i];
         if(ZigZagBuffer[i] < mn) mn = ZigZagBuffer[i];
        }
      lg=mx-mn;
      PrintFormat("Min index: %.05f Max index: %.05f Length: %.05f",mn,mx,lg);
      lg/=100;
      double levels[100];
      int    count[100];
      ArrayInitialize(count,0);
      for(int i=1; i<101; i++) levels[i-1]=NormalizeDouble(lg*i,_Digits);
      mn=0;
      for(int i=0;i<rates_total;i++)
        {
         if(ZigZagBuffer[i]==0 || ZigZagBuffer[i]==EMPTY_VALUE) continue;
         if(mn==0) mn=ZigZagBuffer[i];
         else
           {
            lg=MathAbs(mn-ZigZagBuffer[i]);
            for(int j=0; j<100; j++)
              {
               if(lg<levels[j])
                 {
                  count[j]++;
                  break;
                 }
              }
            mn=ZigZagBuffer[i];
           }
        }
      for(int i=0; i<100; i++)
        {
         PrintFormat("%d level: %.05f count: %d",i,levels[i],count[i]);
         FileWrite(h,i,levels[i],count[i]);
        }
      FileClose(h);
     }

   return(rates_total);
  }
//+------------------------------------------------------------------+
Der Indikator beginnt zu arbeiten, und auf dem 10. Tick bestimmt er die maximal mögliche Länge der ZigZag Strecke. Nehmen wir diese Länge als 100 Prozent und berechnen wir ein Prozent, danach werden alle anderen ZigZag Strecken angepasst. Im Endeffekt haben wir ein Array mit der Anzahl der ZigZag Strecken, einem Wert von 1% bis 100% von der maximalen. Die Ergebnisse werden in eine Datei und ein Diagramm für Libre Office Calc ausgegeben. Sie befinden sich in der Zip-Datei ZZdata.zip. Geben wir hier den Anfang der Datei und den entsprechenden Teil des Diagramms wieder:


Nummer Länge der Strecken
Anzahl der Strecken
0
0.01193 2975
1
0.02387
850
2
0.0358
197
3
0.04773
54
4
0.05967
17
Andere Abschnitte des Diagramms sind nicht so interessant, denn sie sind hauptsächlich mit 0 ausgefüllt. Man kann diese Forschung fortsetzen, wenn die Schrittweite reduziert wird, wir bleiben aber bei den erhaltenen Ergebnissen. Man kann schon praktische Schlussfolgerungen ziehen:
  • Man muss vorsichtig nach Trend einsteigen, wenn die Größe der ZigZag Strecke, die an den vereinigten Indikator des Index der Währung angewandt wurde, einen bestimmten Wert übersteigt.

Hier stellt sich natürlich die Frage über die Länge einer solchen "kritischen" Strecke. Uns helfen die statistischen Methoden, die für die oben angeführten Daten angewandt werden. Der Trader kann eine solche Analyse auch selbständig vornehmen und sich von seinen Ansichten über das Risiko leiten lassen. Ich bin der Ansicht, dieser Wert sollte nicht größer als 0.04, und vielleicht sogar als 0.03 sein. Hier muss man einiges präzisieren. Wenn wir von der "Länge" der ZigZag Strecke sprechen, ist damit die Länge der Projektion dieser Strecke auf die Preis-Achse gemeint. Vielleicht ist das auch ohne weitere Erklärungen klar, man darf aber keine Missinterpretationen zulassen.

In diesem Fall wurde die ganze Periode der vorhandenen Historie analysiert. Vielleicht wäre es richtiger mit kleineren Perioden zu arbeiten - Jahr, Quartal, Monat. Das würde erlauben, die letzten aktuellsten Bewegungen zu erfassen.

Eine ähnliche Analyse kann man für alle Währungskörbe und für viele Zeitrahmen durchführen. Es wird interessant sein, den Unterschied (oder die Ähnlichkeit) anhand Diagramme für verschiedene Währungen zu analysieren. Genauso interessant ist es die Unterschiede zu betrachten, die beim Wechsel der Timeframe auftreten.

Den Entwicklern wird auffallen, dass man den Algorithmus im Code ganz einfach wiederholen kann wenn nötig. Natürlich muss man beachten, dass man sich nicht auf nur ein Signal orientieren muss, sondern immer nach einer Bestätigung suchen. Diese Binsenwahrheit wird leider häufig vergessen.

Zum Schluss kann man sagen, dass diese Methode auch für gewöhnliche Trendindikatoren (natürlich, nicht für alle) angewandt werden kann. Die Anwendung für Oszillatoren wäre aber sinnlos und würde keine Ergebnisse liefern.

Es wurde ein weiterer aber nicht der letzte Schritt auf dem Weg zur Erhöhung der Qualität des Einstiegs in den Markt unter Verwendung vereinigter Indikatoren gemacht. Da die Notwendigkeit der Bestätigung der Signale eines Indikators hervorgehoben wurde, schauen wir, was man dafür tun kann:

Gemeinsame Verwendung verschiedener vereinigter Indikatoren


Wir haben bereits einen früher erstellten vereinigten Indiaktor basierend auf WPR. Im letzten Artikel wurde er von allen Seiten studiert: sowohl sein Code als auch verfügbare Muster. Dieses Mal versuchen wir, ihn zusammen mit dem vereinigten Index-Indikator zu verwenden. Diese Struktur muss funktionsfähig sein, denn viele Handelssysteme werden auf solche Weise erstellt: Trendindikator + Oszillator. Nehmen wir den Indikator des vereinigten WPR aus dem vorherigen Artikel und platzieren wir ihn auf dem Chart gemeinsam mit dem vereinigten Indikator des Euro-Index. Der Indikator des vereinigten WPR wird uns die Differenz zwischen den vereinigten WPR Währungen zeichnen, die zu unserem Währungspaar gehören (dies wurde ausführlich im vorherigen Artikel beschrieben). Unser Ziel ist die vorher beschriebenen Muster auf einem Indikator unter Verwendung eines anderen Indikators als Filter festzustellen:





Auf dem Bild sind mögliche Einstiegspunkte (nicht alle) markiert. Besonders zuverlässig sind die Einstiegspunkte, wo der Indikator im oberen Fenster (das ist der vereinigte WPR) und im unteren Fenster (das ist der vereinigte Euro-Index) uns die Muster demonstrieren, die auf eine Richtung hinweisen. Diese Einstiegspunkte wurden hier als Nr.1 und Nr.6 bezeichnet. Das sind die Punkte, in welchen sich der Indikator und der gleitende Durchschnitt schneiden. Interessant ist der Einstiegspunkt Nr.2, denn an dieser Stelle schenkt uns der vereinigte WPR ein vorbildliches Muster mit der Kreuzung der überverkauften Linie. Die anderen Einstiegspunkte demonstrieren keine ausreichende Bestätigung. Und obwohl der reale Einstieg an diesen Punkten nicht zu Verlusten geführt hätte, ist ein solches Risiko für einen Trader akzeptabel?

Inwiefern ist es richtig, einen vereinigten Indikator zu verwenden, der die Differenz zwischen den vereinigten WPRs zeichnet, die zu einem Währungskorb gehören? Wäre es nicht richtiger ihn zusammen mit dem vereinigten Euro-Index den vereinigten Euro WPR zu verwenden? Tun wir das:

Auf dem Bild sieht man, dass wir ganz unten den Indikator des vereinigten WPR für den Euro hinzugefügt haben. Was gibt uns dieser dritte Indikator, brauchen wir ihn wirklich? In diesem Fall offensichtlich ja. Dieser Indikator hat den Einstieg in den Punkten Nr.2 und Nr.6 um eine Kerze korrigiert (die Richtung ist mit Pfeilen angezeigt). Nicht besonders deutlich ist der Einstieg im Schnittpunkt Nr.1 bestätigt. Der Einstieg im Punkt Nr.5 ist nicht empfehlenswert, genauso wie im Punkt Nr.3 (diesen Einstieg würden wir auslassen). Und den Punkt Nr.4 hat der Indikator in den Punkt Nr.7 verschoben. Anhand der Ergebnisse kann man die Schlussfolgerung ziehen: die Anwendung des vereinigten WPR Indiaktors der Korbwährung ist gegenüber dem gleichen Indikator für die Differenz zwischen dem vereinigten WPR für zwei Währungen eines Währungspaars vorteilhafter. Das trifft aber für diesen konkreten Fall zu. Für die "alltägliche" Anwendung würde ich die Anwendung beider Formen des vereinigten Oszillators nicht ausschließen, bis es Statistik akkumuliert wird.

Es kann sein, dass jemand mir widerspricht: "Was ist daran besonders? Die gemeinsame Verwendung mehrerer Indikatoren ist doch nichts neu, warum muss man darüber einen Artikel schreiben? Und Muster haben damit nichts zu tun". Das Ziel dieses Artikels war:
  • Versuchen festzustellen, in welcher Form Oszillatoren in diesem Fall am besten verwendet werden müssen?
  • Ob es einen expliziten Verbot für die Verwendung einer der Formen gibt?
  • Wie korrekt werden die Muster unter Verwendung verschiedener Formen der Oszillatoren identifiziert und bestätigt.

Im Rahmen unserer Möglichkeiten haben wir diese Fragen beantwortet, darüber hinaus ist es klar, wie man die Schlussfolgerungen überprüfen kann.


Fazit

Damit endet die Beschreibung der einfachsten Muster, die beim Handel mit Währungskörben auftreten können. Bedeutet dass, dass man damit das ganze Thema abschließen kann? Auf keinem Fall. Es gibt noch viele interessante Möglichkeiten.

Zusammenfassend möchte ich noch einmal wiederholen: Die Indikatoren im Anhang sind nicht für reales Trading vorgesehen! Sie veranschaulichen nur diese oder jene Situation. Sie brauchen noch lange, bis sie stabil arbeiten werden. Halten Sie sie von echten Finanzen fern )


Übersetzt aus dem Russischen von MetaQuotes Software Corp.
Originalartikel: https://www.mql5.com/ru/articles/2960

Beigefügte Dateien |
testIndexMA.mq5 (4.82 KB)
testIndexMA2.mq5 (4.96 KB)
ZZdata.zip (37.28 KB)
wpr.zip (45.32 KB)
Grafische Interfaces X: Neue Möglichkeiten der Tabellendarstellung (build 9) Grafische Interfaces X: Neue Möglichkeiten der Tabellendarstellung (build 9)

Bis heute war CTable die fortschrittlichste Tabellenart überhaupt in der Bibliothek. Diese Tabelle ist zusammengestellt aus editierbaren Boxen des Typs OBJ_EDIT Typ, aber eine weitere Entwicklung ist problematisch. Mit dem Ziel einer maximale Leistungsfähigkeit, wäre es besser, eine andere Tabellendarstellung vom Typ CCanvasTable zu entwickeln, auch beim augenblicklichen Entwicklungsstand der Bibliothek. Die aktuelle Version ist völlig starr, aber ab diesem Artikel werden wir versuchen, die Situation zu beheben.

Universeller Kanal mit grafischem Interface Universeller Kanal mit grafischem Interface

Alle Channel Indikatoren stellen drei Linien dar: zentrale, obere und untere Linie. Die zentrale Linie ist nach dem Prinzip des Zeichnens dem gleitenden Durchschnitt identisch, und in den meisten Fällen wird für das Zeichnen eines Kanals gerade der gleitende Durchschnitt verwendet. Die obere und untere Linien sind von der zentralen Linie gleich weit entfernt. Dieser Abstand kann in Punkten oder in Prozent vom Preis (Envelopes Indikator) definiert werden, es können der Wert der Standardabweichung (Bolliger Bands) oder der Wert des ATR Indikators (Keltner Kanal) verwendet werden.

Visualisierung! Eine grafische MQL5 Bibliothek ähnlich 'plot' der Sprache R Visualisierung! Eine grafische MQL5 Bibliothek ähnlich 'plot' der Sprache R

Beim Studium der Handelslogik hat die visuelle Darstellung durch Grafiken eine großer Bedeutung. Eine Reihe von Programmiersprachen, die in der wissenschaftlichen Gemeinschaft weit verbreitet sind (wie R und Python), verfügen über eine spezielle "plot"-Funktion für die Visualisierung von Daten. Sie ermöglicht das Zeichnen von Linien, Gruppen von Punkten und Histogramme, um Muster darzustellen. In MQL5 können wir das Gleiche mit der Klasse CGraphics erreichen.

Die Berechnung des Hurst-Exponenten Die Berechnung des Hurst-Exponenten

Der Artikel erklärt detailliert die Idee hinter dem Hurst-Exponenten, sowie die Bedeutung der Werte und den Algorithmus der Berechnung. Eine Reihe von Teilen des Finanzmarktes werden analysiert, und die Methode zur Umsetzung der Fraktalanalyse mit dem MetaTrader 5 wird beschrieben.