MetaTrader 5 herunterladen

Ein neuer Ansatz der Interpretation der klassischen und der versteckten Divergenz

16 November 2017, 12:55
Alexander Lasygin
0
243

Einführung

Händler verwenden häufig klassische, technische Analysemethoden. Es gibt jedoch viele verschiedene Wege und Ansätze, die auch nützlich sein können. In diesem Artikel schlage ich eine nicht standardisierte Methode zum Suchen und Interpretieren von Divergenzen vor. Auf dieser Grundlage werden wir eine Handelsstrategie entwickeln.

Definition von Divergenz/Konvergenz

Die Bewegung im Markt hält an, solange die Marktteilnehmer Geld und den Willen zum Handel haben. So kommt früher oder später ein Moment, in dem alle Teilnehmer bereits am Markt sind und niemand mehr da ist, um den Preis zu bewegen. Solche Situationen können auf dem Markt recht häufig vorkommen. Je nach Trendrichtung werden sie als überkaufte oder überverkaufte Marktlage bezeichnet.

Der überkaufte Situation kann an Finanz-, Aktien- oder Terminmärkten auftreten. Sie zeigt, dass diejenigen, die Vermögenswerte kaufen wollten, sie bereits gekauft haben, so dass es niemanden gibt, der den Preis weiter nach oben treibt.

Die überverkaufte Situation ist der umgekehrte Fall. Sie zeigt, dass diejenigen, die Vermögenswerte verkaufen wollten, diese bereits verkauft haben, so dass niemand mehr da ist, der den Preis weiter nach unten bewegen kann.

Die überkauften/überverkauften Situationen erscheinen nicht von heute auf morgen. Es ist bekannt, dass die Preise sich in Wellen bewegen. Händler verfolgen Kursveränderungen, indem sie das Kurschart mit Indikatoren- oder Oszillator-Charts vergleichen. Wenn sich das Verhalten des Indikators von der Richtung Kursbewegung unterscheidet, bildet sich in einem fallenden Markt eine Konvergenz, und wenn er steigt eine Divergenz.

Arten von Divergenzen

Verschiedene Forscher bieten unterschiedliche Klassifizierungen von Divergenz/Konvergenz. Wir werden diejenige verwenden, die Divergenz/Konvergenz in klassische und verborgene unterteilt.

    Klassische Divergenz

    Die klassische Divergenz kann durch den Vergleich der aktuellen Hochs/Tiefs mit den Identifikatorwerten im gleichen Momenten identifiziert werden. Wenn die Preise im Chart ein neues Hoch oder Tief gebildet haben und der Indikator das nicht geschafft hat, ist dies ein Zeichen für eine Divergenz. Der Markt ist überkauft (überverkauft), so dass es nicht ratsam ist, weitere Positionen in der aktuellen Trendrichtung zu eröffnen.

    Die klassische Divergenz ist in verschiedenen Quellen weit verbreitet. Je nach der Charakteristik der Divergenz kann sie in drei Unterklassen unterteilt werden

    • Klasse A. Sie tritt häufiger auf, als die anderen Klassen. Wenn die Preise neue Hochs und Tief bilden, der Indikator aber seine Richtung umzukehren beginnt, ist das ein Anzeichen für eine bevorstehenden Trendumkehr.
    • Klasse B. Sie ähnelt der Klasse A, mit der Ausnahme, dass der Kurs des Vermögenswertes das Extremum nicht durchbrechen kann, und so das Muster eines einer Trendumkehr in Form von Double Top oder Double Bottom bildet, während der Indikator sein Extremum auch nicht erreicht.
    • Class C. Das Hoch oder Tief wird aktualisiert, und der Indikator bildet das Muster eines Double Tops (Double Bottoms).

    Eine Divergenz (Konvergenz) kann sich mehrmals hintereinander wiederholen, indem verschiedene Klassen kombiniert werden und so ein stärkeres Umkehrmuster geschaffen wird. Jede Klasse sollte unbedingt separat analysiert werden. Wir können nicht eindeutig sagen, welche stärker oder schwächer ist. Die Gründe dafür werden wir später analysieren.

    Verdeckte Divergenz

    Auch dieser Typ kann in verschiedene Unterklassen unterteilt werden:

    • Sinkende Hochs bei gleichzeitig steigenden Hochs der Oszillatorwerte bestätigen den Abwärtstrend.
    • Steigende Tiefs bei gleichzeitig sinkenden Tiefs der Oszillatorwerte bestätigen den Aufwärtstrend.


    In der obigen Abbildung sehen wir deutlich den Aufwärtsmarkt, aber MACD hat einen neues Tief erreicht, das nicht durch das Kurschart bestätigt wird. Diese Diskrepanz deutet auf eine versteckte Divergenz eines steigenden Trends hin und deutet dessen Verstärkung an. Indikatoren und Oszillatoren zum Auffinden von Divergenzen/Konvergenzen. So funktioniert es

    Indikatoren und Oszillatoren für die Suche nach Divergenzen/Konvergenzen. Arbeitsprinzip

    Welche Indikatoren können Divergenzen und Konvergenzen aufweisen? Ein technischer Indikator sollte in der Lage sein, das Ausmaß von Nachfrage und Angebot und deren Dynamik zu bestimmen. Die folgenden Indikatoren können für die oben genannten Zwecke verwendet werden: Oszillatoren, Stochastik, RSI, CCI usw. und der Trendindikator MACD. MACD kann als Divergenz und Konvergenz von gleitenden Durchschnitten interpretiert werden. Der Indikator erkennt effizient die Diskrepanzen in der Kursentwicklung und deren Dynamik. Viele Händler entscheiden auf Basis einer Konvergenz/Divergenz des MACD.

    Es wäre jedoch falsch, einfach so einen der oben genannten Indikatoren für die Arbeit mit Divergenzen zu empfehlen. Jeder Händler sollte einen Indikator wählen, der zu seinen spezifischen Handelsstrategien passt und effizient arbeitet, ohne das Kurschart zu überlasten. Also, die allgemeine Empfehlung ist die folgende: Überprüfen Sie die aufgelisteten Indikatoren, testen Sie sie, wählen Sie einen von ihnen und folgen Sie dessen Signalen ohne anderer Faktoren zu berücksichtigen.

    Divergenzen lassen sich auch ohne Indikatoren leicht feststellen. Zunächst sollten Sie die Grundlagen für das Erkennen von Divergenzen verstehen.

    Das Momentum spielt eine wichtige Rolle bei der Bildung der Divergenz. Wir verstehen, dass die Abnahme der Bewegungsdynamik nach einem starken Impuls ein Signal zur Divergenzbildung ist.


    Die obige Abbildung zeigt dieses Beispiel. Hat sich ein neues Tief gebildet, ist die Größe der neuen Welle kleiner als die der vorherigen. In diesem Fall ist mit einer sich abzeichnenden Divergenz zu rechnen.

    Das folgende Beispiel über dieselbe Zeitspanne des Marktes mit dem RSI-Indikator zeigt, bestätigt die oben genannte Annahme.


    Auch wenn eine Divergenz leicht festgestellt werden kann, ist diese Methode ohne den Einsatz von Indikatoren nicht vollständig. Die Konvergenz-/Divergenzlinien sehen wir nicht. Daher betrachten Sie einige, der häufigsten Indikatoren, um dieses Muster zu identifizieren.

    Der Oszillator RSI

    Der RSI-Oszillator verfügt über Zonen >-100 und <+100, die überverkaufte bzw. überkaufte Zonen repräsentieren. Alle Signale, die in diesen Zonen entstehen, werden als stark angesehen, und die Signale der Divergenz werden als noch stärker angesehen.

    Zu den Nachteilen dieser Methode gehört, dass der Indikator sehr empfindlich auf Preisschwankungen reagiert. Dadurch ist es schwierig, die Hochs und Tiefs anhand dieses Indikators zu erkennen. Das Kurschart muss analysiert werden. Dies verzögert das Erkennen der Signale.

    Der Oszillator Stochastik

    Die folgenden Standardparameter des Oszillators werden verwendet:

    • Periodenlänge %K: 5
    • Periodenlänge %D: 3
    • Verlangsamung: 3

    Ähnlich wie der RSI hat die Stochastik überkaufte und überverkaufte Zonen. Divergenz oder Konvergenz in diesen Zonen erhöht die Chancen auf positive Geschäftsergebnisse erheblich.

    Der Nachteil der Stochastik ist das zu häufige Auftreten von Divergenzen, d. h. viele falsche Signale. Alle Signale sind als Warnung vor möglichen Veränderungen zu interpretieren, daher ist es notwendig, zusätzliche Techniken zur Bestimmung des Eröffnungszeitpunktes einer Position zu verwenden.

    Der MACD

    MACD ist ein interessanter Oszillator, der auch zur Bestimmung von Divergenzen beitragen kann. Der Indikator wird mit Standardparametern verwendet:

    • Schneller EMA: 12
    • Langsamer EMA: 26
    • MACD SMA: 9


    Eine der Regeln für die Bestimmung der Divergenz mittels MACD ist folgende: Die Bars des Oszillators dürfen die Nulllinie nicht kreuzen. Der folgende Screenshot zeigt, dass in diesem Fall Divergenz nicht eindeutig ist, so dass die Chancen für einen profitablen Handel gering sind.

    Im Gegensatz zu den vorherigen Indikatoren erzeugt dieser weniger Signale. Er ist aber ein Trendindikator und informiert daher über die globalen Veränderungen des Marktes. Trotz aller Vorteile muss eine Positionseröffnung muss durch die Analyse der "Price Action" oder von Kerzenmuster bestätigt werden.

    Die Volumen-Indikator

    Ein weiteres wichtiges Merkmal ist das Volumen. Eines der stärksten Umkehrsignale ist die Divergenz (oder Konvergenz) von Preis und Volumen. Die Idee ist die folgende:

    Solange neue Volumina in den Markt fließen, setzt sich ein Aufwärtsbewegung fort. Bei einem der hohen Ausbrüche sehen wir einen Volumenrückgang, was bedeutet, dass die Käufer aufhören, dem Markt frisches Geld zur Verfügung zu stellen. Wir können daraus schließen, dass der Preis überkauft ist und wird wahrscheinlich nach unten tendieren. Die beschriebene Situation ist in der folgenden Abbildung dargestellt.

    In diesem Zusammenhang sehe ich den OBV als den interessantesten Indikator. Es bietet basierend auf dieser versteckten Divergenz gute Signale zur Positionseröffnung.

    Eine klassische Divergenz mit dem OBV zeigt oft nur die Verlangsamung und den Übergang in eine Konsolidierung.


    Regeln für die Bestimmung der Divergenz/Konvergenz. Wie handelt man eine Divergenz

    Lassen Sie uns über Fehler sprechen, die Händler häufig machen, wenn sie versuchen, eine Konvergenz/Divergenz zu finden und diese zu handeln.

    • Das Vorhandensein eines Trends ist obligatorisch; eine Divergenz funktioniert nicht in einem Seitwärtsmarkt.
    • Zusätzlich zur Divergenz sollten die Positionseröffnung durch "Price Action" oder japanische Kerzenmuster bestätigt werden.
    • Erwarten Sie nicht, dass Sie ein 100%-Signal gefunden haben. Es besteht immer die Möglichkeit eines Fehlers. Daher sollten Sie bei der Ausführung von Handelsgeschäften die allgemeinen Handelsregeln beachten.
    • Ermitteln Sie die Divergenz nicht anhand von Kerzen, die während Pressemitteilung entstanden sind. Aufgrund der durch sie hohen Volatilität erzeugen solche Kerzen oft falsche Signale.
    • Die Divergenz muss eindeutig sein. Sie müssen sicher sein, dass das Signal nicht nur für Sie, sondern auch für die anderen Marktteilnehmer sichtbar ist. Nur in diesem Fall kann sich die Chance auf eine richtige Entscheidung erhöhen.
    • Analysieren Sie nur die nächstgelegenen Hochs und Tiefs. Dadurch entsteht ein besseres Bild von der Situation. Bei Verwendung von Trendindikatoren wie MACD kann der Schnittpunkt der Nulllinie das Signal schwächen oder sogar aufheben.

    Ein neuer Ansatz

    Wir haben gemeinsame Regeln für die Verwendung und Erkennen von Divergenzen betrachtet. Nun werden wir uns mit der nicht standardisierten Verwendung von Divergenzen im Handel befassen. Wir werden in unserer Arbeit keine Standardregeln anwenden, sondern einen weiteren, absolut untypischen Indikator verwenden.

    Wir werden unser Experiment auf der Basis des klassischen Accelerator Oszillators von Bill Williams durchführen. Die Wahl ist kein Zufall. Die Richtung des Indikators ändert sich, bevor sich die Antriebskraft des Trends sich ändert, während sich ihrerseits die Richtung der Antriebskraft vor der Preisänderung dreht. Der AO ist ein frühzeitiges Bestätigungssignal, das klare Vorteile bietet. Wir können Divergenzsignale früher und häufiger empfangen. Normalerweise würde diese Lösung zu einem erhöhten Rauschen führen, aber in unserem Fall haben wir mehr Signale für eine Positionseröffnung und die Position wieder zu schließen.

    Wir haben bereits gemeinsame Regeln besprochen, um Divergenzen zu erkennen und zu verwenden. Diese Variante der Divergenzanwendung ist nicht standardisiert. Wir halten uns an diese gemeinsamen Regeln, während wir eine ungewöhnliche Art und Weise anwenden, um Einstiegspunkte zu bestimmen.

    Der Hauptzweck ist es, Divergenzen zu finden mit nur einen Parameter - die Anzahl der Bars für die Bestimmung der Divergenz.

    #property indicator_separate_window
    //---- Ein Puffer wird zum Berechnen und zeichnen des Indikators verwendet
    #property indicator_buffers 2
    //---- Es werden nur eine grafische Konstruktion verwendet
    #property indicator_plots 1
    //---- Der Indikator wird als Linie gezeichnet
    #property indicator_type1 DRAW_COLOR_HISTOGRAM
    //---- Die Indikatorlinie ist Blau
    #property indicator_color1 Green,Red
    //----
    #property indicator_width1 2
    //---- Die Indikatorlinie als kontinuierliche Linie
    #property indicator_style1 STYLE_SOLID
    //---- Anzeige der Kennzeichnung des Indikators
    #property indicator_label1 "AC_Div"
    //+------------------------------------------------------------------+
    input int Bars_Calculated=1000;
    //+------------------------------------------------------------------+
    string shortname="";
    double AC_buff[];
    double Color_buff[];
    int wid;
    int Handle_AC;
    //---
    #define DATA_LIMIT 37
    
    

    Der Indikator wird den vorgegebenen Parametern auuf dem mehrfarbigen Histogramm initialisiert.

    //+------------------------------------------------------------------+
    //| Initialisieren des Indikators                                    |
    //+------------------------------------------------------------------+
    int OnInit()
     {
    //---- Anlegen der dynamischen Arrays als Indikatorpuffer
     SetIndexBuffer(0,AC_buff,INDICATOR_DATA);
     SetIndexBuffer(1,Color_buff,INDICATOR_COLOR_INDEX);
    //---- Festlegen der Position, ab wann der Indikator gezeichnet wird
     PlotIndexSetInteger(1,PLOT_DRAW_BEGIN,DATA_LIMIT);
    //---- Initialisieren des "short name" des Indikators
     shortname="Accelerator_Divergence";
    //---- Erstellendes Namens für die Anzeige im eigenen Unterfenster und im Tooltip
     IndicatorSetString(INDICATOR_SHORTNAME,shortname);
    //---- Festlegen der Genauigkeit für die Anzeige der Indikatorwerte
     IndicatorSetInteger(INDICATOR_DIGITS,_Digits);
    //---- Keine Darstellung 'leerer' Indikatorwerte
     PlotIndexSetDouble(0, PLOT_EMPTY_VALUE, 0.0);
     PlotIndexSetDouble(1, PLOT_EMPTY_VALUE, 0.0);
    //--- das "handle" zum Indikator Accelerator
     Handle_AC=iAC(NULL,0);
    //--- Ermitteln des Index des Unterfensters
     wid=ChartWindowFind(0,shortname);
    //---
     return(INIT_SUCCEEDED);
     }
    
    

    Die grundlegende Berechnung besteht aus zwei Teilen.

    Der erste Teile betrifft den eigentlichen Indikator.

    //---- Deklarieren der lokalen Variablen 
     int limit,bar,pos;
    //---- Prüfen, ob die Anzahl der Bars zur Berechnung ausreicht
     if(rates_total<DATA_LIMIT)
     return(0);
     int barsCalculated=MathMin(Bars_Calculated,rates_total);
    //+------- Festlegen der Richtung der Indices der Arrays ------------+
     ArraySetAsSeries(close,true);
     ArraySetAsSeries(AC_buff,true);
     ArraySetAsSeries(low,true);
     ArraySetAsSeries(high,true);
     ArraySetAsSeries(Color_buff,true);
     ArraySetAsSeries(time,true);
    //+--- Ermitteln der der benötigten Zahl der Bars zur Berechnung ----+
     limit=rates_total-DATA_LIMIT-1;
     if(prev_calculated>0) limit=rates_total-prev_calculated;
     pos=limit;
     if(pos>barsCalculated)pos=limit;
     int to_copy;
     if(prev_calculated>rates_total || prev_calculated<0) to_copy=rates_total;
     else
     {
     to_copy=rates_total-prev_calculated;
     if(prev_calculated>0) to_copy++;
     }
    //---
     if(IsStopped()) return(0); //Checking for stop flag
    //+----- Bilden des Hauptarrays -------------------------------------+
     if(CopyBuffer(Handle_AC,0,0,to_copy,AC_buff)<=0)
     {
     Print("getting Accelerator Handle is failed! Error",GetLastError());
     return(0);
     }
    //+---------- Färben des Histogramms --------------------------------+
     for(bar=limit; bar>=0 && !IsStopped(); bar--)
     {
     Color_buff[bar]=0.0;
     if(AC_buff[bar]<AC_buff[bar+1])Color_buff[bar] =1.0;
     if(AC_buff[bar]>AC_buff[bar+1])Color_buff[bar] =0.0;
     }
    
    

    Der zweite Teil betrifft die Suche nach den Diskrepanzen.

    //+----------- Ermitteln von Aufwärts-Divergenzen --------------------+
     int bars=barsCalculated;
     for(bar=pos; bar>=0 && !IsStopped(); bar--)
     {
     int l=bar+2;
     if(Extremum(AC_buff[l+1],AC_buff[l],AC_buff[l-1])<0)
     {
     int i=l;
     int counted=LastPeak(l,bars,AC_buff);
     if(counted!=-1)
     {
     if(AC_buff[i]<AC_buff[counted] && high[i]>high[counted])
     {
     DrawPriceTrendLine(time[i],time[counted],high[i],high[counted],Red,STYLE_SOLID);
     DrawIndicatorTrendLine(time[i],time[counted],AC_buff[i],AC_buff[counted],Red,STYLE_SOLID);
     }
    
     if(AC_buff[i]>AC_buff[counted] && high[i]<high[counted])
     {
     DrawPriceTrendLine(time[i],time[counted],high[i],high[counted],Red,STYLE_DOT);
     DrawIndicatorTrendLine(time[i],time[counted],AC_buff[i],AC_buff[counted],Red,STYLE_DOT);
     }
     }
     }
    //+----------- Ermitteln von Abwärts-Divergenzen ---------------------+
     if(Extremum(AC_buff[l+1],AC_buff[l],AC_buff[l-1])>0)
     {
     int i=l;
     int counted=LastTrough(l,bars,AC_buff);
     if(counted!=-1)
     {
     if(AC_buff[i]>AC_buff[counted] && low[i]<low[counted])
     {
     DrawPriceTrendLine(time[i],time[counted],low[i],low[counted],Green,STYLE_SOLID);
     DrawIndicatorTrendLine(time[i],time[counted],AC_buff[i],AC_buff[counted],Green,STYLE_SOLID);
     }
     if(AC_buff[i]<AC_buff[counted] && low[i]>low[counted])
     {
     DrawPriceTrendLine(time[i],time[counted],low[i],low[counted],Green,STYLE_DOT);
     DrawIndicatorTrendLine(time[i],time[counted],AC_buff[i],AC_buff[counted],Green,STYLE_DOT);
     }
     }
     }
     }
    
    

    Um den Umfang des Code geringe zu halten, werden die grafische Konstruktion und die Suche nach den Hochs/Tiefs gesondert angegeben.

    //+----- Suchen des zweiten Aufwärts-Extremums ----------------------+
    int LastPeak(int l,int bar,double &buf[]) 
     {
     for(int i=l+5; i<bar-2; i++)
     if(Extremum(buf[i+1],buf[i],buf[i-1])<0)return (i);
     return (-1);
     }
    //+----- Suchen des zweiten Abwärts-Extremums -----------------------+
    int LastTrough(int l,int bar,double &buf[])
     {
     for(int i=l+5; i<bar-2; i++)
     if(Extremum(buf[i+1],buf[i],buf[i-1])> 0)return (i);
     return (-1);
     }
    //+-- Suchen eines Extremums ---------------------------------------+
    int Extremum(double a,double b,double c)
     {
     if((a-b)*(b-c)<0)
     {
     if(c>b && b<0) return(1); //DN extremum
     if(c<b && b>0) return(-1);//UP extremum
     }
     return(0);
     }
    //+------ Erstellen von Objekten auf dem Chart ----------------------+
    void DrawPriceTrendLine(datetime T_0,
     datetime T_1,
     double P_0,
     double P_1,
     color color_0,
     int style)
     {
     string name_2=shortname+DoubleToString(T_0,0);
     string name_0;
     name_0=shortname+"Line_Sn"+ColorToString(color_0);
    //--- 
     if(ObjectFind(0,name_2)<0)
     drawLineS(name_2,T_0,T_1,P_0,P_1,color_0,style,0,true,false,0);
    //+-----------+
     if(style==STYLE_DOT)
     drawLineS(name_0,T_1,T_0,P_1,P_0,clrAqua,0,3,true,true,0);
     }
    //+------ Erstellen von Objekten im Fenster des Indikators ----------+
    void DrawIndicatorTrendLine(datetime T_0,
     datetime T_1,
     double P_0,
     double P_1,
     color color_0,
     int style)
     {
     string name_1,name_0;
     int window= wid;
     name_1 = shortname+DoubleToString(T_0+wid,0);
     if(ObjectFind(0,name_1)<0)
     drawLineS(name_1,T_0,T_1,P_0,P_1,color_0,style,0,false,false,window);
    //---
     if(style==STYLE_SOLID)
     {
     name_0=shortname+"Line_Pn"+ColorToString(color_0);
     drawLineS(name_0,T_1,T_0,P_1,P_0,clrMagenta,style,2,true,true,window);
     }
     }
    //+------------------------------------------------------------------+
    void drawLineS(string name,
     datetime t0,
     datetime t1,
     double p0,
     double p1,
     color clr,
     int style,
     int width,
     bool back,
     bool ray,
     int window)
     {
     ObjectDelete(0,name);
     ObjectCreate(0,name,OBJ_TREND,window,t0,p0,t1,p1,0,0);
     ObjectSetInteger(0,name,OBJPROP_RAY_RIGHT,ray);
     ObjectSetInteger(0,name,OBJPROP_COLOR,clr);
     ObjectSetInteger(0,name,OBJPROP_STYLE,style);
     ObjectSetInteger(0,name,OBJPROP_WIDTH,width);
     ObjectSetInteger(0,name,OBJPROP_SELECTABLE,false);
     ObjectSetInteger(0,name,OBJPROP_BACK,back);
     }
    //+------------------------------------------------------------------+
    
    
    

    Für die visuelle Analyse verwenden wir eine durchgezogene Linie für die klassische Divergenz und eine gestrichelte Linie für die versteckte Divergenz. Rot wird für absteigende Divergenzen verwendet und Grün wird für aufsteigende. Dicke Strahlen zeigen die letzte verborgene auf- und absteigende Divergenz auf dem Kurschart und der klassische Divergenzen im Indikator-Fenster. Im Folgenden werde ich diese Visualisierungsregeln erläutern. Der Indikator wird so aussehen:


    Grundlegende Prinzipien der Strategie

    Eine Analyse der Kurscharts und des Indikators hat gezeigt, dass die erweiterte Linie der umgekehrten Divergenz auf dem Kurschart und die der klassischen Divergenz auf dem Indikator-Chart zu schrägen Unterstützungs- und Widerstandsniveaus werden. Ein souveräner Ausbruch dieser Linien prägt das weitere kurz- und langfristige Marktverhalten.

    Beispiel eines Ausbruchs durch die Unterstützungslinien, die durch die versteckte Divergenz gebildet werden und sich auf dem Kurschart befinden:


    Im nächsten Beispiel durchbrechen die Bars des Histogramms die klassischen Divergenz-Linien in der Indikatorfenster:


    Nach dem Ausbruch ändern sich oft die Bedeutung Linien. So wird z.B. aus einer Unterstützungslinie ein Widerstand:

    Wir stützen unsere Handelsstrategie auf diese Merkmale.


    Prinzipien des Handelns

    Sie können sowohl schwebende (pernding orders) als auch als auch Marktorder handeln. Der Zeitrahmen und die Börsenzeit haben keine Bedeutung. Die Hauptregel ist der deutliche Ausbruch durch die Linien. Beim Handel mit schwebenden Aufträgen platzieren wir sie am Hoch (Tief) der ausbrechenden Kerze, auf dem die Bar des Histogramms gebildet wird. Die Kerze sollte in Richtung des Ausbruchs sein. Mit anderen Worten, wenn die Linie nach oben durchbrochen wurde, sollte der Schlusskurs der Kerze über der Eröffnung liegen und umgekehrt. 

    Die folgende Abbildung zeigt ein Kurschart, bei dem die versteckte Divergenz deutlich durchbrochen wird: Es gibt ein Signal für eine Kaufposition, die danach bestätigt wird. Im Indikatorfenster wurde die klassische Divergenzlinie durchbrochen, so dass ein Signal zur Eröffnung einer Verkaufsposition gegeben ist, das später nicht bestätigt wird.


    Das nächste Bild zeigt eine andere Situation: Ein Kaufsignal bildet sich, wenn die klassische Divergenzlinie im Indikatorfenster durchbrochen wird. Das Signal wird später bestätigt.

    Unten ist ein weiteres interessantes Beispiel. Zwei Signale erscheinen gleichzeitig auf einer Kerze: ein Kaufsignal und ein Verkaufssignal. In diesem Fall können wir die Werte des Oszillators überprüfen. Aber selbst wenn wir den Oszillator ignorieren, werden wir sehen, dass nur die gewünschte Order ausgelöst wurde, so dass das Verkaufsgeschäft bestätigt wird. Darüber hinaus gibt es ein weiteres Verkaufssignal, das das vorherige verstärkt. Es erlaubt, das Volumen der Position zu vergrößern und damit die Gewinne zu erhöhen.


    Ein klassisches Verkaufssignal:

    Die Abbildung unten zeigt ein Verkaufssignal (das später durch den Oszillator annulliert wird) und zwei Kaufsignale.


    Die Stop-Loss werden unter dem nächstgelegenen lokalen Extremum gesetzt. Take-Profit wird auf Unterstützung/Widerstandsniveau gesetzt. Die Support/Widerstandsebenen können bei einem "Counter-Trend-Handel" auf unseren Linien eingestellt werden. Aber in diesem Fall seien Sie vorsichtig, denn die Marktsituation kann sich dramatisch ändern und Sie müssen möglicherweise Take-Profit anpassen.

    Bei niedrigeren Zeitrahmen (M1-M15) kehrt der Preis nach dem Ausbruch oft wieder zur Linie zurück und bildet das 1-2-3-Muster, das das Signal verstärkt. Daher, wenn der Markt nicht aktiv genug ist, sollten Sie besser warten, bis der Preis das Hoch bzw, das Tief passiert, nach dem Sie dann Ihre Position eröffnen können. Natürlich gilt auch die klassische Auslegung der Divergenz. Obwohl der Oszillator nicht so wichtig ist wie in anderen Strategien und hauptsächlich für grafische Konstruktionen verwendet wird, empfiehlt es sich dennoch, das Verhalten des Oszillators zu berücksichtigen. Der AO-Indikator wird in einer Vielzahl von Strategien eingesetzt. Eine Kombination aus AO und dem beschriebenen Ansatz kann die Effektivität solcher Strategien deutlich steigern.

    Um die Realisierbarkeit unserer Strategie zu testen, lassen Sie uns einen Expert Advisor Handel mit schwebenden Aufträgen erstellen. Das Hauptproblem besteht darin, dass wir keinen einfachen Indikatoraufruf innerhalb des Expert Advisors verwenden können. In diesem Fall wird der Indikator nichts im Indikatorfenster zeichnen. Da wir die grafischen Konstruktionen benötigen, fügen wir den Code des Indikators in den des EAs ein.

    input double InpLots =0.1;           // Lots
    input int InpTakeProfit =150;        // Take Profit (in pips)
    input int InpStopLoss =60;           // StopLoss (in pips)
    input int InpTrailingStop =25;       // Trailing Stop Level (in pips)
    input int InpOffset =5;              // Distance from the price (in pips)
    input int InpDellOorder =30;         // Order removal distance (in pips)
    //---
    int ExtTimeOut=10;                   // Zeitspanne in Sekunden zwischen Positionseröffnungen
    int barsCalculated=1000;
    datetime t=0;
    datetime time[];
    
    
    

    Zusätzlich zu den traditionellen Variablen wie Lots, TakeProfit, StopLoss und TrailingStop haben wir Offset und DellOrder hinzugefügt. Der erste legt den Abstand (in Pip) zwischen der Order und dem Hoch oder Tief der Kerzen des Ausbruchs fest. Wenn die Order noch nicht ausgelöst wurde und sich der Preis in der entgegengesetzten Richtung DellOrder (Pip) überschreitet, sollte die Order gelöscht werden.

    Dieser Expert Advisor selbst ist nichts Besonderes, so dass wir nur die wichtigsten Punkte besprechen. Wir werden keine Handelsfilter verwenden, aber wir werden den ursprünglichen Code leicht modifizieren.

    //+------------------------------------------------------------------+
    //| Grundlegende Berechnung                                          |
    //+------------------------------------------------------------------+
     for(int bar=1; bar>0 && !IsStopped() && t!=time[0]; bar--)
     {
     int l=bar+1;
     int p1=0,p2=0;
     //+----------- Ermitteln von Aufwärts-Divergenzen --------------------+
     if(Extremum(m_buff_ind[l+1],m_buff_ind[l],m_buff_ind[l-1])<0)
     {
     int i=l;
     int counted=LastPeak(l,bars,m_buff_ind);
     if(counted!=-1)
     {
     if(m_buff_ind[i]<m_buff_ind[counted] && high[i]>high[counted] && !d1)
     { drawLine("Buy_1",time[i],time[counted],m_buff_ind[i],m_buff_ind[counted],Red,1); d1=true;}
     //---
     if(m_buff_ind[i]>m_buff_ind[counted] && high[i]<high[counted] && !d2)
     {
     p1=ArrayMaximum(high,i-1,5);p2=ArrayMaximum(high,counted-2,5);
     drawLine("Buy_2",time[p1],time[p2],high[p1],high[p2],Red,0);d2=true;
     }
     }
     }
     //+----------- Ermitteln von Abwärts-Divergenzen ---------------------+
     if(Extremum(m_buff_ind[l+1],m_buff_ind[l],m_buff_ind[l-1])>0)
     {
     int i=l;
     int counted=LastTrough(l,bars,m_buff_ind);
     if(counted!=-1)
     {
     if(m_buff_ind[i]>m_buff_ind[counted] && low[i]<low[counted] && !d3)
     { drawLine("Sell_1",time[i],time[counted],m_buff_ind[i],m_buff_ind[counted],Green,1);d3=true;}
     //---
     if(m_buff_ind[i]<m_buff_ind[counted] && low[i]>low[counted] && !d4)
     {
     p1=ArrayMinimum(low,i-1,5);p2=ArrayMinimum(low,counted-2,5);
     drawLine("Sell_2",time[p1],time[p2],low[p1],low[p2],Green,0);d4=true;
     }
     }
     }
     if(d1 && d2 && d3 && d4)break;
     t=time[0];
     }
    //---
     }
    
    

    Wir haben gelernt, dass das Extremum des Indikators nicht notwendigerweise ein Extremum auf dem Kurschart sein wird. Um Verzerrungen in unseren Chart zu korrigieren, haben wir daher die beiden Funktionen ArrayMinimum und ArrayMaximum (hervorgehoben) hinzugefügt. Diese Funktionen ermöglichen es, Hoch und Tief im Kurscharts zu identifizieren, auf der sich das Extremum des Indikators gebildet hat. Um kleinere Schwankungen des Indikators um die Nulllinie und die damit verbundenen Fehlsignale zu eliminieren, haben wir die Formel für die Bestimmung der Hochs und Tiefs modifiziert. Jetzt werden nur noch die Indikatorwerte berücksichtigt, die ein gemeinsames Potential haben (positiv oder negativ).

    //+-- Suchen eines Extremums ---------------------------------------+
    int Extremum(double a,double b,double c)
     {
     if(((a-b)*(b-c)<0) && ((a>0 && b>0 && c>0) || (a<0 && b<0 && c<0)))
     {
     if(c>b && b<0) return(1); //DN extremum
     if(c<b && b>0) return(-1);//UP extremum
     }
     return(0);
     }
    //+------
    
    

    Die Funktion ObjectGetValueByTime() verwenden wir auch, um den Wert der Zeile zu einem bestimmten Zeitpunkt einer Koordinate zu bestimmen. Diese Funktion wird mehrfach verwendet. Zur Vereinfachung wird es gesondert hinzugefügt.

    //+------------------------------------------------------------------+
    //|Rückgabe des Preises zum angegebenen Zeitpunkt des Objektes       |
    //+------------------------------------------------------------------+
    double CSampleExpert::ValueByTime(string label,int i)
     {
     double p=0.0;
    //---
     p=ObjectGetValueByTime(0,label,time[i],0);
     return(p);
     }
    //+------------------------------------------------------------------+
    
    

    Wie bereits erwähnt, werden wir keine Handelsfilter verwenden. Wir zielen nicht darauf ab, einen vollwertigen Handelsroboter zu schaffen, sondern nur die Effektivität der Strategie zu evaluieren. Deshalb ist das Modul der Signale sehr einfach. Wir stellen fest, ob die Linie in die gewünschte Richtung durchbrochen wird und in welche Richtung sich der Preis (der Indikator) gerade bewegt.

    //+------------------------------------------------------------------+
    //| Prüfen der Bedingungen für das Öffnen einer Verkaufsposition     |
    //+------------------------------------------------------------------+
    bool CSampleExpert::ShortOpened(void)
     {
     bool res=false;
    //---
     double pp1=EMPTY_VALUE,pp2=EMPTY_VALUE,pp3=EMPTY_VALUE,
     pp4=EMPTY_VALUE,pp5=EMPTY_VALUE,pp6=EMPTY_VALUE;
    //---
     if(ObjectFind(0,"Sell_2")!=-1)
     {
     pp1=ValueByTime("Sell_2",1);
     pp2=ValueByTime("Sell_2",2);
     pp3=ValueByTime("Sell_2",3);
     }
     if(ObjectFind(0,"Sell_1")!=-1)
     {
     pp4=ValueByTime("Sell_1",1);
     pp5=ValueByTime("Sell_1",2);
     pp6=ValueByTime("Sell_1",3);
     }
    //--- Prüfen, ob man verkaufen (SELL) sollte 
     if((pp1!=EMPTY_VALUE && close[1]<pp1 && close[2]>pp2&&close[0]<close[1])||
     (pp4!=EMPTY_VALUE && m_ind_1>m_ind_0 && ((m_ind_1<pp4 && m_ind_2>pp5) ||(m_ind_2<pp5 && m_ind_3>pp6))))
     {
     //--- Wir müssen den EA auf jeden Fall verlassen
     res=true;
     }
    //--- Ergebnis
     return(res);
     }
    //+------------------------------------------------------------------+
    
    
    

    Der obige Teil zeigt einen Block für die Eröffnung einer Verkaufsposition. Die Eröffnung von Kaufpositionen schaut ähnlich aus.

    Nachdem wir ein Signal (Liniendurchbruch) erhalten hatten, platzieren wir im Abstand InpOffset vom Extremum der Kerze eine entsprechende Order. Wenn diese Kerze die Linie durchbricht, wird die Order direkt während dieser Kerze abgeschickt. 

    //+------------------------------------------------------------------+
    //| Eröffnen einer Sell-Stop-Position                                |
    //+------------------------------------------------------------------+
    bool CSampleExpert::OpenSellStop(void)
     {
     bool res=false;
    //--- Ermitteln der Bar mit dem niedrigsten Tief der nächstgelegenen Kerzen
     int i=ArrayMinimum(low,0,3);
    //---
     if(ShortOpened())
     {
     double offset=InpOffset;                          // Abstand der Order vom Tief der Kerze
     double limit_price=m_symbol.Bid();
     double price=low[i]-offset*m_adjusted_point;;
     double tp =price-m_take_profit;
     double sl =price+m_stop_losse;
     //--- Prüfen des Kontostandes
     if(m_account.FreeMarginCheck(Symbol(),ORDER_TYPE_SELL_STOP,InpLots,price)<0.0)
     printf("We do not have money. Free margin = %f",m_account.FreeMargin());
     else
     {
     //--- Positionseröffnung
     if(m_trade.OrderOpen(Symbol(),ORDER_TYPE_SELL_STOP,InpLots,limit_price,price,sl,tp))
     {res=true; printf("Position by %s to be opened",Symbol());}
     else
     {
     printf("Error occurred while opening position SELL STOP %s : '%s'",Symbol(),m_trade.ResultComment());
     printf("Open parameters: price=%f,TP=%f",price,tp);
     }
     }
     }
    //--- Ergebnis
     return(res);
     }
    //+------------------------------------------------------------------+
    
    

    Wenn die Order noch nicht ausgelöst wurde und sich der Preis in der entgegengesetzten Richtung InpDellOrder überschreitet, sollte die Order gelöscht werden.

    //+------------------------------------------------------------------+
    //| Löschen nicht benötigter Aufträge                                |
    //+------------------------------------------------------------------+
    bool CSampleExpert::DelOrder(ulong ticket,string type)
     {
     bool res=false;
     if(m_trade.OrderDelete(ticket))
     printf("Position by %s to be opened",Symbol());
     else
     {
     res=true;// Setting the flag indicating that the order has not been deleted
     printf("Error occurred while deleting the order"+type+" %s : '%s'",Symbol(),m_trade.ResultComment());
     }
     return(res);
     }
    //+------------------------------------------------------------------+
    
    

    Kommen wir zurück zu unserem Hauptziel, d. h. zur Bewertung der Strategie. Die Schwierigkeit bei der Bewertung von Strategien, die an grafischen Konstruktionen arbeiten, besteht darin, dass sie nur im visuellen Modus ausgewertet werden können. Eine Optimierung im Automatikbetrieb ist nicht möglich. Das ist ein zeitraubender Prozess. Lassen Sie uns daher den Expert Advisor auf GBPUSD H1 starten, beginnend mit Anfang 2017. Beginnen wir mit den Standardeinstellungen.

    Hier ist das Ergebnis:




    Diese Methode kann kaum als völlig objektiv bezeichnet werden. Die erzielten Ergebnisse zeigen jedoch, dass die Strategie ein gutes Potenzial hat. Nach weiteren Verbesserungen kann sie sich langfristig zu einer wertvollen Strategie entwickeln.


    Schlussfolgerungen

    Dieser Ansatz ermöglichte es uns, eine durchaus praktikable Strategie zu entwickeln, die aber auch den Einsatz weiterer Instrumente erlaubt. Zu den Nachteilen dieser Strategie gehört die gelegentliche fehlerhafte Konstruktion von Indikatorlinien und die Notwendigkeit, diese manuell zu korrigieren. Dies erschwert die Automatisierung der Strategie und damit die Analyse. Dennoch zeigte die Forschung, dass nicht nur klassische Strategien existieren können.

    Die Programm dieses Artikels:

    #NameTyp Beschreibung 
    1Accelerator_DivIndikator

    Der Indikator zur Bestimmung der expliziten und versteckten Divergenz/Konvergenz auf der Grundlage des Indikators Accelerator

    2TestExpertExpert Advisor

    Ein Expert Advisor für den Strategie-Tester


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

    Beigefügte Dateien |
    MQL5.zip (10.12 KB)
    Optimieren einer Strategie unter Verwendung einer Kurve der Salden und dem Vergleich der Ergebnisse mit dem Kriterium "Balance + max Sharpe Ratio" Optimieren einer Strategie unter Verwendung einer Kurve der Salden und dem Vergleich der Ergebnisse mit dem Kriterium "Balance + max Sharpe Ratio"

    In diesem Artikel betrachten wir ein weiteres Kriterium für die Optimierung einer Strategie auf Basis einer grafischen Analyse der Salden. Die linearen Regression wird mit der Funktion aus der Bibliothek ALGLIB berechnet.

    Wir betrachten die adaptive Trendfolgemethode in der Praxis Wir betrachten die adaptive Trendfolgemethode in der Praxis

    Das besondere Merkmal des im Artikel vorgestellten Handelssystems besteht in der Verwendung mathematischer Werkzeuge für die Analyse von Börsenkursen. Im System werden digitale Filter und die Spektralschätzung diskreter Zeitreihen verwendet. Es werden theoretische Aspekte der Strategie beschrieben und ein Expert Advisor für das Testen der Strategie erstellt.

    Fuzzy-Logik in Handelsstrategien Fuzzy-Logik in Handelsstrategien

    Der Artikel befasst sich mit einem Beispiel für die Anwendung der Fuzzy-Logik, um ein einfaches Handelssystem unter Verwendung der Fuzzy-Bibliothek zu erstellen. Es werden Varianten zur Verbesserung des Systems durch Kombination von Fuzzy-Logik, genetischen Algorithmen und neuronalen Netzen vorgeschlagen.

    Vergleich verschiedener Typen gleitender Durchschnitte im Handel Vergleich verschiedener Typen gleitender Durchschnitte im Handel

    Es wurden 7 Typen gleitender Durchschnitte (MA) betrachtet; es wurde eine Handelsstrategie für das Arbeiten mit ihnen entwickelt. Verschiedene gleitende Durchschnitte wurden anhand einer Handelsstrategie getestet, des Weiteren wurden diese hinsichtlich der Effektivität der Anwendung verglichen.