MetaTrader 5 herunterladen

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

3 Juli 2017, 12:19
Andrei Novichkov
0
166

Einleitung

Das ist der dritte und wahrscheinlich der letzte Artikel, der sich mit diesem Thema befasst. Wir analysieren primäre und sekundäre Muster und deren Anwendungstaktik. Unsere Aufgabe besteht nicht in der Beschreibung komplizierter Methoden, nach Art von Wellenanalyse oder VSA, ich glaube aber, dass das dargelegte Material völlig ausreicht, um den Handel mit Körben von Währungspaaren kennenzulernen. Versuchen wir in diesem Artikel unter der Untersuchung von Mustern, die bei der Verwendung vereinigter Oszillatoren und Trendindikatoren auftreten, einen dicken Strich zu ziehen. Gerade um vereinigte Trendindikatoren geht es im Artikel.


Index der Korbwährung als Quelldaten

In den Kommentaren zu einem der vorherigen Artikel wurde eine sehr aussichtsreiche Idee geäußert: statt Indikatorwerte für jedes Währungspaar separat zu erhalten und den Mittelwert zu berechnen, sollte man die Formel des technischen Indikators auf die Daten eines vereinigten Indikators, des Index der Korbwährung, anwenden. Ich möchte diesen Gedanken erläutern. Für die Berechnung der Daten eines vereinigten WPR haben wir zum Beispiel Werte des Standardindiaktors WPR für jedes Währungspaar des Korbes erhalten. Dann haben wir anhand der erhaltenen Werte den arithmetischen Mittelwert berechnet (im allgemeinen Fall kann auch der geometrische Mittelwert verwendet werden). Als Ergebnis haben wir den vereinigten WPR erhalten, der das Verhalten nicht einzelner Paare des Korbes anzeigt, sondern einer Währung - "der Währung des Korbes der Währungspaare".

Hier wird eine alternative Methode für das Erhalten der gleichen Daten dargestellt. Wir haben bereits erklärt, was der Index einer Korbwährung bedeutet, und wie er zu berechnen ist. Rufen wir es uns noch einmal ins Gedächtnis: als Index eines Korbwährung wird der geometrische Mittelwert aller Paare im Korb, der "bereinigte Preis" der Korbwährung bezeichnet. Es wird vorgeschlagen, den Wert eines vereinigten WPR durch die Anwendung der Berechnungsformel für den Standard-WPR auf die Grafik des Index der Korbwährung zu erhalten. Daraus folgt, dass um die Werte eines vereinigten RSI oder eines vereinigten STOCH zu erhalten, muss man ihre Berechnungsformel verwenden. Die Idee ist sehr interessant, überprüfen wir sie. Wenn diese Annahme richtig ist, erhalten wir die Werte vereinigter Indikatoren. Diese Indikatoren sind ähnlich den Indikatoren, die nach der in den vorherigen Artikeln beschriebenen Methode erhalten wurden.

Für den Anfang brauchen wir zwei Indikatoren, deren Codes in der beigefügten Zip-Datei wpr.zip zu finden sind:

  • testWPR, der in einem der vorherigen Artikel beschrieben wurde. Verwenden wir einen Set von Währungspaaren für den USD-Korb: EURUSD, GBPUSD, AUDUSD, NZDUSD, USDCAD, USDCHF und USDJPY. Wir werden ihn als "Richtwert" für den Vergleich verwenden.
  • Code des technischen Indikators WPR. Er wurde der Bibliothek öffentlich zugänglicher Codes der Community entnommen. Die Fragmente des Codes verwenden wir im neuen Indikator für die Veranschaulichung der Methode. 

Als Ergebnis erhalten wir den folgenden Testindikator:

//+------------------------------------------------------------------+
//|                                                testIndex+WPR.mq5 |
//|                                   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 2
#property indicator_plots   1


input color   clrWPR = clrGreen;
input int wprperiod  = 14; 

double ind[],ma[];
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+

int OnInit()
  {
//--- indicator buffers mapping
     
  IndicatorSetDouble(INDICATOR_MINIMUM,-100);
  IndicatorSetDouble(INDICATOR_MAXIMUM, 0);   
      
   ArraySetAsSeries(ma,true);   
   SetIndexBuffer(0,ma);
   PlotIndexSetInteger(0, PLOT_DRAW_TYPE, DRAW_LINE           ); 
   PlotIndexSetInteger(0, PLOT_LINE_STYLE, STYLE_SOLID            ); 
   PlotIndexSetInteger(0, PLOT_LINE_WIDTH, 1            ); 
   PlotIndexSetInteger(0, PLOT_LINE_COLOR, clrWPR            ); 
   PlotIndexSetString (0, PLOT_LABEL, "_tstdistance_MA" );       
   
   ArraySetAsSeries(ind,true);
   SetIndexBuffer(1,ind , INDICATOR_CALCULATIONS);       
//---
   return(INIT_SUCCEEDED);
  }
  
string pair[]={"EURUSD","GBPUSD","AUDUSD","NZDUSD","USDCAD","USDCHF","USDJPY"};
bool bDirect[]={false,false,false,false,true,true,true};
int iCount=7;

//Calc. index  
double GetIndex(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                              |
//+------------------------------------------------------------------+
double HH,LL;

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]= GetIndex(i);
        }
      rt -= wprperiod;  
      for (int i = 1; i< rt; i++) 
        {
         ma[i] = GetMA(ind, i, wprperiod, _Digits);
        }        
     }
   else 
     {
         ind[0] = GetIndex(0);
         ma[0]  = GetMA(ind, 0, wprperiod, _Digits);
     }
   return(rates_total);
  }

//Calc. WPR
double GetMA(const double& arr[], int index , int period, int digit) {
   double m = 0;
   HH = arr[ArrayMaximum(arr, index, period)];
   LL = arr[ArrayMinimum(arr, index, period)];   
   m = -100 * (HH - arr[index]) / (HH - LL);
   return (NormalizeDouble((m + 50) * 2, _Digits));
}


Wenden wir ihn auf das Währungspaar EURUSD gemeinsam mit dem Referenz-Indikator testWPRusd an. Hier ist das Ergebnis:


Im ersten Unterfenster sehen wir die Kurve unseres Testindikators und im zweiten — die Kurve des Referenz-Indikators. Das Ergebnis ist unerwartet enttäuschend. Zwar haben wir mehr erwartet, müssen aber das analysieren, was wir erhalten haben. Man kann direkt sagen, dass der Testindikator unbrauchbar ist. Es fällt auf, dass der Testindikator ständig maximal mögliche Werte erreicht. Dabei passiert auf dem Markt nicht besonders viel, und der Preis verhält sich relativ ruhig. Als Folge ist der Grad der Veränderungen der Indikatorwerte unangemessen hoch. Es ist auch zu betonen, dass die Stellen der Extremwerte im Testindikator und im Referenz-Indikator zusammenfallen. Warum erhalten wir gute Übereinstimmungen hinsichtlich der Stellen, aber dabei so komische Werte der Extrema? Die Antwort ist ganz einfach und steckt in der Berechnungsformel des WPR Indikators:

R% = - ((H – C)/(H – L)) x 100;

wobei:

  • C: Schlusskurs;
  • L: minimaler Preis für eine bestimmte Periode;
  • H: maximaler Preis für eine bestimmte Periode.

Wir haben aber keine Arrays minimaler und maximaler Preise. Der Testindikator verwendet für die Berechnung die Werte des Index der Korbwährung, und der Index selbst wird nach Schlusskursen berechnet. Aus diesem rein technischen Grund erhalten wir so häufige Extrema des Testindikators. Das heißt, wir können nicht mit Sicherheit behaupten, dass die Methode selbst falsch oder ungenau ist. Das Zusammenfallen der Stellen zeugt vom Gegenteil. Ist es möglich, die unerwarteten Hindernisse aus dem Wege zu räumen?


Zeichnen des vereinigten Indikators des Index der Korbwährung als Kerzen

Natürlich, ja. Dafür müssen wir die Quelldaten, d.h. den Index der Korbwährung, nicht als eine Kurve nach Schlusskursen, sondern als japanische Kerzen erhalten. In diesem Fall erhalten wir alle notwendigen Arrays und können dann nicht nur WPR, sondern auch andere Indikatoren berechnen. Wenn der Trader bereits die Grafik des Index der Korbwährung realisiert als Kerzen hat, erhält er einen gewohnten Preischart, das wird aber nicht die Grafik eines Währungpaares, sondern die einer Währung sein. Wir können vorsichtig vermuten, dass dies die Grafik des Preises der Korbwährung hinsichtlich aller Währungen des Korbes sein wird.

Rein technisch ist es einfach, eine solche Grafik zu erhalten. Es sei daran erinnert, dass der klassische Dollar-Index häufig nicht als eine Linie, sondern gerade als Kerzen dargestellt wird. Auf welche Weise kann der Entwickler ein ähnliches Ergebnis erhalten? Der bereits vorhandene Testindikator führt Berechnungen durch und verwendet dabei den Schlusskurs der Kerze im aktuellen Zeitrahmen. Wenn man dem Indikator die gleiche Berechnung unter Verwendung des Eröffnungskurses der Kerzen der aktuellen Timeframe hinzufügt, erhält der Entwickler zwei Werte, die den Körper der benötigten Kerze bestimmen. Hier enden aber die guten Nachrichten. Man kann nicht Low und High der Kerze des Index der Korbwährung auf die gleiche Weise ermitteln. Wenn der Entwickler einfach den arithmetischen oder geometrischen Mittelwert von Low und High berechnet, wird der erhaltene Wert auf keinem Fall Low und High richtig bestimmen. Der Grund ist offensichtlich: Low und High einzelner Währungspaare des Korbes treten nicht unbedingt zur selben Zeit auf. Das ist zwar gut möglich, aber nicht garantiert. Der Entwickler kann diesen Ansatz auf eigene Gefahr anwenden. In diesem Fall erreicht er sein Ziel und erhält alle Werte, die für das Zeichnen von Kerzen benötigt werden, aber mit einer Ungenauigkeit, die sich im Voraus nicht einschätzen lässt. Um den garantiert richtigen Wert zu erhalten, muss man zur Berechnung nach Ticks oder im schlimmsten Fall nach Minuten greifen. Solche Berechnungen werden das Terminal belasten, deswegen sollten sie am besten in einer separaten Anwendung durchgeführt werden.

Wir werden dies aber nicht tun, und unten erkläre ich warum. Wir ziehen die Schlussfolgerung, dass die zu betrachtende Methode für vereinigte Indikatoren basierend auf WPR und für weitere vereinigte Indikatoren, die für Berechnungen nicht nur Open und Close Arrays, sondern auch Low und High Arrays verwendet, nicht geeignet ist. Für andere ist sie immer noch von Interesse, und darum geht es weiter.


Werkzeuge basierend auf dem Index der Korbwährung

Beispiele für solche Anwendung des Index der Korbwährung haben wir bereits in den vorherigen Artikeln betrachtet. Ich meine die Anwendung eines gleitenden Durchschnitts auf die Grafik des Index der Korbwährung. Der Gleitende Durchschnitt ist ein verlässliches Werkzeug, dank seiner Anwendung haben wir ein Muster erhalten — den Schnittpunkt des gleitenden Durchschnitts und der Grafik des Index der Korbwährung. Das Beispiel haben wir bereits früher betrachtet. Schauen wir, welche Werkzeuge wir noch verwenden können, wenn wir den Index der Korbwährung als Quelldaten nehmen. Natürlich kann man ein kurzer Artikel nicht alle Tools umfassen, wir können aber die Perspektiven schildern.

Rufen wir uns ins Gedächtnis, dass der Index-Chart der Korbwährung der Preis-Chart ist. Versuchen wir zu bestimmen, ob die wichtigsten Werkzeuge des Traders damit arbeiten können. Dazu gehören Unterstützungs- und Widerstandslevels, Kanäle und Fibonacci-Levels. Von Zeit zu Zeit werden Artikel über die Anwendungsmöglichkeiten solcher Werkzeuge auf Charts von Indikatoren veröffentlicht. Versuchen auch wir, diese anzuwenden. Platzieren wir dafür auf dem Chart EURUSD zwei vereinigte Indikatoren des Index der Korbwährung für USD und EUR (diese sind in der angefügten Zip-Datei index.zip zu finden) und führen wir einige Standard-Zeichnungen durch:


Auf beiden Charts haben wir klassische grafische Werkzeuge platziert. Natürlich ist diese Variante nicht einzig möglich, aber durchaus möglich:

  • Fibonacci, ein Aufwärtskanal und der horizontale Level auf EUR
  • Zwei Linien, die einen Keil und einen horizontalen Level auf USD bilden

Markieren wir die für uns interessanten Punkte mit Rechtecken und vertikalen Linien und schauen wir, wie sich der Preis des Paares EURUSD um diesen Punkten verhält.

  1. Ein Rückschlag von der oberen Kanalgrenze und dem Fibo-Level auf dem EUR-Index. Mit dem USD-Index passiert nichts besonderes — eine leichte Senkung. Man kann eine Bewegung in den Sell-Bereich auf dem Hauptchart erwarten, was sich auch in der Wirklichkeit beobachten lässt.
  2. Ein weiterer Rückschlag von der oberen Kanalgrenze nach EUR. Man könnte eine weitere Bewegung in den Sell-Bereich erwarten, dies passiert aber nicht, denn der USD-Index bewegt sich neben der oberen Keilgrenze. In der Wirklichkeit lässt sich eine Seitenbewegung mit einem Trend in Buy beobachten.
  3. Als Fortsetzung des Punktes 2 wird der Kanal des EUR-Index nach unten durchbrochen, was mit dem Punkt 5 des Rückschlags von der unteren Grenze des Keils zusammenfällt. Wir betrachten eine logische Bewegung in Sell auf dem Hauptchart.
  4. Ein Rückschlag vom horizontalen Level nach EUR, der mit dem Ausbruch des Keils des USD-Index im Punkt 7 übereinstimmt. Am Anfang ist der Rückschlag auf EUR intensiver und der Preis bewegt sich in den Sell-Bereich, dann "überwiegt" der Ausbruch des Keils und Preis bewegt sich in den Buy-Bereich. 

Man kann schon die ersten Schlussfolgerungen ziehen. Natürlich, wurde hier eine einzelne Episode eines komplexes Währungspaars betrachtet, deswegen gelten unsere Vermutungen nicht als die letzte Wahrheit. Dafür werden längere Beobachtungen auf verschiedenen Zeitrahmen und Währungspaaren benötigt. Das Bild gibt aber Hoffnung. Auf dem Chart des vereinigten Indikators des Index des Währungspaares kann man gewöhnliche grafische Konstruktionen zeichnen. Die Muster, die bei diesen Zeichnungen erhalten wurden, unterordnen sich einer bekannten Regel:

  • Jedes Signal muss durch andere (mehrere) Signale bestätigt werden.
  • Im Vergleich zur Standardanwendung ist die Verarbeitung der erhaltenen Muster durch den Preis viel träger.
  • Zusammenfassende Schlussfolgerung. Die Muster, die auf solche Weise erhalten wurden, haben einen sekundären, bestätigenden Charakter. Sie können auch für die Ermittlung von Einstiegspunkten und wahrscheinlich auch beim Setzen von Stoploss Levels berücksichtigt werden. Mit anderen Worten sind diese Muster hilfreich, spielen aber eine sekundäre Rolle.

Analysieren wir das Bild von einer anderen Seite. Erinnern wir uns daran, dass der Index der Korbwährung den Zustand aller Währungspaare in Bezug auf die Korbwährung zeigt. Die von uns vorgemerkten Punkte auf dem Chart des EUR-Index gehören nicht nur zu EURUSD, sondern auch zu den anderen Währungspaaren, die im EUR-Korb beinhaltet sind. Unsere Schlussfolgerungen haben wir hinsichtlich nur einer Währung gezogen. Wahrscheinlich ist der Grund dieser Zweitrangigkeit der erhaltenen Muster gerade das, was der Trader loswerden will, indem er Körbe von Währungspaaren verwendet, und zwar - der Einfluss der zweiten Währung (in diesem Fall USD)? Es ist ganz einfach, unsere Vermutung zu überprüfen, indem man die Situation bei den anderen Währungspaaren des Korbes kontrolliert. Als Beispiel nehmen wir einen beliebigen Punkt. Sagen wir den Punkt 2, 2015.09.18 00:00. Wir vermuten einen allgemeinen Trend in Sell in diesem Punkt, denn es gab einen Rückschlag von der oberen Kanalgrenze, und später wurde der Kanal nach unten durchbrochen. Unser Punkt wird auf der Grafik des EUR-Index gefunden, deswegen nehmen wir alle Währungspaare, die zum EUR-Korb gehören, und schauen wir, was während dieser Zeit mit dem Preis passiert ist:


Ein sehr interessantes und vielversprechendes Ergebnis! Auf dem Bild wird mit der blauen vertikalen Linie das Zeit-LAbel dargestellt. Unsere Prognose bestätigt sich für die meisten Paare. Wenn der Trader anhand des zu betrachtenden (relativ schwachen) Musters in den Markt eingestiegen wäre, hätte er Profite erzielt. Aber Stoploss ist auch auf einigen Paaren wahrscheinlich. Ich spreche von EURAUD und EURGBP und in geringerem Maße von EURUSD. Auf anderen Paaren hätte der Trader Gewinne erzielt. In diesem Fall hat sich der Grundprinzip der Arbeit mit Körben von Währungspaaren bewährt: der Trader erhält ein Signal zum Einstieg mit einer Korbwährung und steigt auf allen Paaren ein, die den Korb bilden. Auf einigen Paaren kann es auch Verluste geben, aber auf den meisten erzielt der Trader Gewinne. Darüber haben wir bereits ausführlich in den ersten Artikeln dieser Reihe gesprochen. Ich möchte Sie aber noch einmal daran erinnern, dass alle Schlussfolgerungen und Überlegungen nur wahrscheinlichen Charakter haben.

Man kann natürlich keine Schlussfolgerungen basierend auf einem einzelnen Punkt ziehen. Das erhaltene Ergebnis kann aber Forscher zu einer erweiterten Durchsuchung dieser Frage bewegen, mit der Planung des Experiments, Erhebung der Statistik und Veröffentlichung des Ergebnisses.

Wenn wir auf den Anfang des Artikels zurückkommen, können wir die Gründe darlegen, aus welchen man momentan keinen vereinigten Indikator des Index der Korbwährung mit einem Kerzen-Chart schreiben sollte.

  • Für ein einzelnes Währungspaar sind das nur Hilfsmuster.
  • Für alle Währungspaare des Korbes sieht die Situation anders aus und erfordert eine Analyse anhand Historie.


Einfacher Trendindikator

Um unsere Schlussfolgerungen nachzuweisen, erstellen wir einen primitiven vereinigten Indikator, der nach dem folgenden Prinzip arbeitet:

  • Für das Array der Quelldaten (in diesem Fall wird das das Array des Index der EUR-Korbwährung sein) wird die Differenz zwischen zwei gleitenden Durchschnitten - dem schnellen und dem langsamen - berechnet und angezeigt. Es fällt auf, dass das Arbeitsprinzip ähnlich dem des MACD Indikators ist. Hoffen wir, dass der Indikator uns die Divergenz zeigen kann.

Der Code des Indikators (er ist in der angefügten Zip-Datei testIndexMACD.zip zu finden):

//+------------------------------------------------------------------+
//|                                                testIndexMACD.mq5 |
//|                                   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 2
#property indicator_plots   1


input color   clr = clrBlue;
input int InpFastEMA = 12;   // Fast EMA Period
input int InpSlowEMA = 26;   // Slow EMA Period

double ind[],ma[];
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
//int h,h1;
int OnInit()
  {
//--- indicator buffers mapping
   ArraySetAsSeries(ind,true);
   SetIndexBuffer(0,ind);        
   
   IndicatorSetString(INDICATOR_SHORTNAME,"testIndexMACD");
   IndicatorSetInteger(INDICATOR_DIGITS,2);
   PlotIndexSetInteger(0,PLOT_DRAW_TYPE,DRAW_HISTOGRAM/*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,"_tstMACD_");    


   ArraySetAsSeries(ma,true);
   SetIndexBuffer(1,ma , INDICATOR_CALCULATIONS);   

//---
   return(INIT_SUCCEEDED);
  }
  
string pair[]={"EURUSD","EURJPY","EURCHF","EURGBP","EURNZD","EURCAD","EURAUD"};
bool bDirect[]={true,true,true,true,true,true,true};
int iCount=7;
  
double GetValue(int shift) 
  {
   double res=1.0,d;
   double dBuf[1];
   for(int i=0; i<iCount; i++) 
     {
      d=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                              |
//+------------------------------------------------------------------+
double t;
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++) 
        {
         ma[i]= GetValue(i);
        }
      rt=rates_total - InpSlowEMA;  
      for(int i=1; i<rt; i++) 
        {
         ind[i] = GetMA(ma, i, InpFastEMA, _Digits) - GetMA(ma, i, InpSlowEMA, _Digits);
        }        
     }
   else 
     {
         ma[0]= GetValue(0);
         ind[0] = GetMA(ma, 0, InpFastEMA, _Digits) - GetMA(ma, 0, InpSlowEMA, _Digits);
     }
//--- return value of prev_calculated for next call
   return(rates_total);
  }

//+------------------------------------------------------------------+

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

Platzieren wir den Indikator auf dem Chart, und wir erhalten das folgende Bild, wenn wir den vereinigten EUR-Index als Quelldaten nutzen:


... und auf einem der Abschnitte sehen wir die Divergenz. Die Widerstandslinie weist auf einen Trend nach Süden hin, aber die Dynamik der Wertveränderungen des Indikators warnt den Trader vor einer Schwächung oder vor einem eventuellen Ende des Trends. Tatsächlich sehen wir weiter einen eindeutigen Trendwechsel. Die Untersuchung des Verhaltens anderer Währungspaare bestätigt die gezogenen Schlussfolgerungen:

In diesem Fall bestätigt diese einzelne Situation die Schlussfolgerungen, dass die in diesem Artikel betrachteten Muster mit Vorsicht auf ein einzelnes Währungspaar, aber mit Sicherheit auf ein ganzes Währungskorb angewandt werden soll.


Fazit

Wir haben die Muster betrachtet, die beim Handel mit Körben von Währungspaaren auftreten. Fassen wir kurz allgemeine Regeln für die Anwendung aller beschriebenen Muster zusammen.

  • Die hohe Genauigkeit des Musters, das beim Kreuzen der überkauften/überverkauften Levels mit der Grafik des vereinigten Indikators der Differenz zwischen den Werten des vereinigten Indikators-Oszillators (WPR, STOCH) für die Basiswährung und für die Kurswährung auftritt, wurde bestätigt. Man kann auch nach dem Schließen der Kerze einsteigen. Dies wird den Ausbruch der überkauften/überverkauften Linie und vielleicht auch den Anfang eines neuen Trends bestätigen. Der Einstieg erfolgt auf einem Währungspaar, auf welchem sich unser Indikator befindet. Der Ausstieg erfolgt, nachdem der Indikator den Bereich bei Null erreicht, oder wenn er sich der entgegengesetzten Bereichsgrenze des Indikators nähert:

    Im letzten Fall, bei der Annäherung dem Nullbereich, sollten offene Orders zur Gewinnschwelle übertragen werden. Bitte achten Sie auf das falsche Signal in Buy, darüber haben wir hier gesprochen. Ein Stoploss Level kann auch nach diesem Indikator gesetzt werden. Er kann ausgelöst werden, wenn der Indikator nach dem Ausbruch der überkauften/überverkauften Linie nicht in die Nullrichtung geht, sondern sich umkehrt, die überkaufte/überverkaufte Linie noch einmal durchbricht und beginnt, sich neben einer Bereichsgrenze zu bewegen.
  • Das gleiche Muster existiert auch für vereinigte Indikatoren-Oszillatoren (WPR, STOCH), die den Status der Korbwährung anzeigen. Auf dem Bild ist die Grafik des vereinigten WPR für EUR dargestellt:

    Die Regeln für Einstieg und Ausstieg bleiben gleich, der Einstieg erfolgt aber nicht auf einem sondern auf allen Paaren des Korbes. Achten Sie auf den Punkt, in welchem Stoploss möglich ist. Hier ist er als Beispiel angeführt, der Trader kann den Level auch woanders setzen. Die hier und im vorherigen Abschnitt verwendeten Indikatoren kann man in der angefügten Zip-Datei wpr2.zip finden.
  • In Ergänzung zu den zwei oben genannten Mustern kann das Kreuzen der MA-Grafiken als Hilfsmuster dienen. Wenn sich die MA-Grafiken im Bereich des Ausbruchs der überkauften/überverkauften Linien schneiden, stärkt dies die beiden Muster.
  • Die Muster, die sich bei der Anwendung vereinigter Trendindikatoren bilden, sind auch Hilfsmuster. Es gibt noch keinen Grund, den Einstieg in den Markt basierend auf ihrer Erkennung zu empfehlen, sie können aber als zusätzliche Signale zu den ersten zwei Mustern verwendet werden.

In dieser Phase ist es unmöglich, genaue Handelsempfehlungen mit Zahlen und Statistik zu geben. Der größte Mangel aller beschriebenen Muster ist die fehlende Untersuchung anhand historischer Daten. Mit der Beseitigung dieses Mangels werden wir uns in den nächsten Artikeln befassen.

Die im Artikel verwendeten Programme:

 # Name
Typ
 Beschreibung
1 wpr.zip Zip-Datei
Beinhaltet den Referenz-Indikator testWPRusd (den Code und das ausführbare Modul) und den Code des technischen Indikators WPR - wpr.mq5
2
testIndex+WPR.mq5 Indikator Ein vereinigter Testindikator; zeichnet die WPR Werte, die nach der Anwendung der Berechnungsformel von WPR auf die Werte des Index der Korbwährung erhalten wurden.
3
 index.zip    Zip-Datei  Zwei vereinigte Indexindikatoren des USD/EUR-Währugskorbes
 4  testIndexMACD.zip   Zip-Datei  Einfacher Trendindikator basierend auf MACD
5
 wpr2.zip Zip-Datei Indikatoren für die Veranschaulichung des Einstiegs und Ausstiegs


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

Beigefügte Dateien |
testIndex8WPR.mq5 (6.93 KB)
index.zip (3.25 KB)
testIndexMACD.ZIP (1.65 KB)
wpr.zip (3.22 KB)
wpr2.zip (4.83 KB)
Die benutzerdefinierten Indikatoren und die Informationsgrafik in CCanvas Die benutzerdefinierten Indikatoren und die Informationsgrafik in CCanvas

Im Artikel werden die neuen Arten der Indikatoren mit einer komplizierteren strukturellen Realisierung betrachtet. Es werden der Aufbau der pseudoräumlichen Typen der Indikatoren und die Erstellung einer dynamisch ändernden Informationsgrafik beschrieben.

Erstellung der Dokumentation basierend auf Quellcodes von MQL5 Erstellung der Dokumentation basierend auf Quellcodes von MQL5

Der Artikel beschäftigt sich mit der Erstellung der Dokumentation zu einem Code in MQL5 und beginnt mit der Automatisierung der Platzierung von Tags. Weiter wird die Arbeit mit dem Programm Doxygen beschrieben, ihre Konfiguration und das Erhalten von Ergebnissen in verschiedenen Formaten: in HTML, HtmlHelp und in PDF.

Graphisches Interface X: Textauswahl im mehrzeiligen Textfeld (build 13) Graphisches Interface X: Textauswahl im mehrzeiligen Textfeld (build 13)

In diesem Artikel erreichen wir, Text mittels verschiedener Tasten auszuwählen, und markierten Text zu löschen, genau so, wie man das von einem Texteditor kennt. Zusätzlich wird der Code weiter optimiert, und es werden die Klassen für die zweite Stufe in Richtung der endgültigen Version der Bibliothek vorbereitet, die alle Elemente als Einzelbilder vor einem Hintergrund darstellt.

Sortierverfahren und deren Visualisierung mit MQL5 Sortierverfahren und deren Visualisierung mit MQL5

Für die Arbeit mit der Grafik wurde in MQL5 eine spezielle Bibliothek Graphic.mqh erstellt. Der Artikel gibt ein Beispiel deren praktischer Anwendung und erklärt den Sinn von Sortierverfahren. Zu jedem Sortierverfahren gibt es mindestens einen Artikel, zu einigen wurden bereits ganze Untersuchungen veröffentlicht, deswegen wird in diesem Artikel nur die Grundidee beschrieben.