MQL5-Assistent-Techniken, die Sie kennen sollten (Teil 39): RSI (Relative Strength Index)

Einführung

Im letzten Artikel haben wir uns mit der Verwendung von Bollinger Bändern in einer nutzerdefinierten Signalklasse für assistentengestützte Expert Advisors befasst. Wir haben uns bis zu 6 der vorgesehenen 8 möglichen Setups angesehen, die für einen Händler innerhalb einer nutzerdefinierten Signalklasse bei der Gewichtung von Kauf- und Verkaufs-Bedingungen nützlich sein können. Da der Artikel zu lang war, wurden die letzten beiden Setups sowie ein kombinierter Test aller möglichen Bollinger-Band-Setups oder Muster, wie wir sie damals nannten, veröffentlicht. Fahren wir also mit dem Muster 6 fort.

Verbreiterung der Bänder nach einem Abwärtstrend oder nach einem Aufwärtstrend

Unser siebtes Setup, das wir als Muster 6 bezeichnen, dreht sich in erster Linie um die steigende Volatilität. Die Vergrößerung des Abstands zwischen dem oberen und dem unteren Bollinger-Band wird immer als Hinweis auf eine steigende Volatilität gewertet. Da dieser Volatilitätsanstieg am Ende eines Trends auftritt, sind die Märkte in der Regel von starken Kursschwankungen geprägt, was zu der Annahme führt, dass eine Umkehr des vorherigen Trends bevorsteht.

Bei der Interpretation dieser Konstellation wird daher ein sich vergrößernder Abstand zwischen dem oberen und dem unteren Band nach einem Aufwärtslauf als Verkaufssignal betrachtet, während ähnliche sich vergrößernde Abstände nach einem Abwärtslauf auf ein Kaufsignal hindeuten. Es handelt sich also um ein konträres Signal, das nach Gelegenheiten sucht, Positionen zu eröffnen, die dem vorherrschenden Trend entgegengesetzt sind. Wir implementieren dieses Muster wie folgt in MQL5:

//+------------------------------------------------------------------+
//| Check for Pattern 6.                                             |
//+------------------------------------------------------------------+
bool CSignalBollingerBands::IsPattern_6(ENUM_POSITION_TYPE T)
{  m_bands.Refresh(-1);
   m_close.Refresh(-1);
   m_high.Refresh(-1);
   m_low.Refresh(-1);
   if(Gap(StartIndex()) > Gap(StartIndex() + 1) && Gap(StartIndex() + 1) > Gap(StartIndex() + 2))
   {  if(T == POSITION_TYPE_BUY && m_close.GetData(StartIndex() + 2) < m_close.GetData(StartIndex() + 3) && m_close.GetData(StartIndex() + 3) < m_close.GetData(StartIndex() + 4))
      {  return(true);
      }
      else if(T == POSITION_TYPE_SELL && m_close.GetData(StartIndex() + 2) > m_close.GetData(StartIndex() + 3) && m_close.GetData(StartIndex() + 3) > m_close.GetData(StartIndex() + 4))
      {  return(true);
      }
   }
   return(false);
}

Wie aus dem obigen Code ersichtlich, ist die Prüfung auf steigende Volatilität eine Voraussetzung sowohl für Käufe wie auch für Verkäufe. Sobald diese Prüfung bestanden ist, wird der vorherige Trend vom Beginn der Volatilitätsexpansion an berücksichtigt, nicht der aktuelle Trend. Wir betrachten nicht den aktuellen Trend, da, wie oben dargelegt, in diesem volatilen Umfeld die Richtung nicht eindeutig ist. Allerdings war der Trend vor dem Volatilitätsanstieg oft deutlicher.

Diese Situation, in der die aktuellen Trends nicht eindeutig sind, birgt daher immer das Risiko einer Ausbruchsfortsetzung, bei der der Kurs nicht wie erwartet umkehrt, sondern einfach aus dieser „Konsolidierungszone“ ausbricht und den vorherigen Trend vor dem Volatilitätsanstieg fortsetzt. Dies rechtfertigt daher eine Integration mit der Volumenanalyse. Wenn sich die Bänder bei sinkendem Volumen verbreitern, dient dies als Bestätigung der These der Trendumkehr. Wenn das Volumen nicht abnimmt, sollten Händler besser auf einen geeigneteren Umkehrpunkt warten. Wie wir in Muster 2 im vorherigen Artikel gesehen haben, war dies der Hauptteil unserer These.

Und wie bereits erwähnt, sind Informationen über das Volumen schwer zu bekommen, weshalb wir uns in erster Linie auf die Preisspannen als Näherungswert verlassen haben. Ein alternativer Indikator wie der RSI, den wir weiter unten betrachten, kann ebenfalls als Bestätigung für zu viel gekaufte und zu viel verkaufte Preise verwendet werden. Beim Testen unseres vom Assistenten zusammengestellten Expert Advisors erhalten wir die folgenden Ergebnisse:

Orientierung der Bänder und die Änderung der Winkel

Das letzte Muster, das wir für Bollinger Bänder in Betracht ziehen, bezieht sich auf eine Asymmetrie zwischen dem oberen und dem unteren Band. Wenn das untere Band schneller ansteigt als das obere Band, und zwar um ein Vielfaches des Eingangsparameters für die Abweichung des Bollinger Bandes oder darüber hinaus, interpretieren wir dies als ein Aufwärtssignal. Dies liegt daran, dass diese Art von Muster auf einen Ausbruch nach oben durch den Widerstand des oberen Bandes hindeutet. Eine Bestätigung in Form eines tatsächlichen Kursausbruchs kann dieses Signal ergänzen, um die Einstiegspunkte zu schärfen. Wenn die Höchststände schneller fallen als die Tiefststände, fungiert das untere Band als Unterstützung, die bald durchbrochen wird. Auch hier kann ein Bestätigungssignal für diesen Durchbruch verwendet werden, z. B. wenn der Kurs unter den unteren Band schließt. Wir setzen dies in MQL5 wie folgt um:

//+------------------------------------------------------------------+
//| Check for Pattern 7.                                             |
//+------------------------------------------------------------------+
bool CSignalBollingerBands::IsPattern_7(ENUM_POSITION_TYPE T)
{  m_bands.Refresh(-1);
   m_close.Refresh(-1);
   m_high.Refresh(-1);
   m_low.Refresh(-1);
   if
   (
      T == POSITION_TYPE_BUY &&
      Lower(StartIndex()) > Lower(StartIndex() + 1) &&
      Lower(StartIndex() + 1) > Lower(StartIndex() + 2) &&
      Upper(StartIndex()) >= Upper(StartIndex() + 1) &&
      Upper(StartIndex() + 1) >= Upper(StartIndex() + 2) &&
      Lower(StartIndex()) - Lower(StartIndex() + 2) >= m_deviation * (Upper(StartIndex()) - Upper(StartIndex() + 2))
   )
   {  return(true);
   }
   else if
   (
      T == POSITION_TYPE_SELL &&
      Upper(StartIndex()) < Upper(StartIndex() + 1) &&
      Upper(StartIndex() + 1) < Upper(StartIndex() + 2) &&
      Lower(StartIndex()) <= Lower(StartIndex() + 1) &&
      Lower(StartIndex() + 1) <= Lower(StartIndex() + 2) &&
      Upper(StartIndex() + 2) - Upper(StartIndex()) >= m_deviation * (Lower(StartIndex() + 2) - Lower(StartIndex()))
   )
   {  return(true);
   }
   return(false);
}

Diese Quelle kann, wie oben erwähnt, mit einer Preisausbruchsbestätigung ergänzt werden, und der Leser kann dies tun, da der vollständige Quellcode am Ende des Artikels beigefügt ist. Wenn wir unseren zusammengestellten Expert Advisor mit einer Eingabe-Schema für Muster testen, die als 80 verwendet wird, was genau dem achten Muster entspricht, erhalten wir die folgenden Ergebnisse:

Dies ist einer der besten Optimierungsläufe nur mit dem Muster 7. Wie bereits erwähnt, haben wir jedoch unser nutzerdefiniertes Signal geändert, indem wir von der Konvention abgewichen sind und die gleichzeitige Verwendung mehrerer Muster erlaubt haben. Wenn wir also einige Optimierungsläufe auf der Suche nach der besten Kombination von Mustern und ihren jeweiligen Öffnungs-/Schließwerte durchführen, erhalten wir eine Reihe von plausiblen Testergebnissen, wie das Folgende:

Es gibt einen Unterschied in diesen Ergebnissen, und deshalb könnte man sich dafür aussprechen, mehrere Muster mit Bollinger-Bändern zu nutzen, und das könnte plausibel sein, vorausgesetzt, man bedenkt, dass sich diese Signale zwar an verschiedene Marktumgebungen anpassen, sich aber auch gegenseitig aufheben. Dies macht es schwieriger, dieses System zu beweisen oder zu validieren, aber wenn dies mit qualitativ hochwertigen Testdaten erreicht werden kann, kann das System weiter entwickelt werden.  Die Kauf- und Verkaufs-Bedingungen, die das Eingabe-Schema nach Mustern durchsuchen, die für diese nutzerdefinierte Signalklasse „Bollinger-Bänder“ verwendet werden, sind identisch mit denen, die wir unten mit der nutzerdefinierten RSI-Klasse verwenden. Die Auflistung der typischen Kauf-Bedingung, die einfach die Verkaufs-Bedingung widergespiegelt, wird unten angeführt:

//+------------------------------------------------------------------+
//| "Voting" that price will grow.                                   |
//+------------------------------------------------------------------+
int CSignalRSI::LongCondition(void)
{  int result  = 0, results = 0;
//--- if the model 0 is used and "Price Crossing the Upper Band or the Lower Band"
   if(((m_patterns_used & 0x01) != 0) && IsPattern_0(POSITION_TYPE_BUY))
   {  result += m_pattern_0;
      results++;
   }
//--- if the model 1 is used and "Price Bouncing Off Lower Band or Upper Band "
   if(((m_patterns_used & 0x02) != 0) && IsPattern_1(POSITION_TYPE_BUY))
   {  result += m_pattern_1;
      results++;
   }
//--- if the model 2 is used and "Price Squeeze Followed by a Breakout Above Upper Band or Below Lower Band "
   if(((m_patterns_used & 0x04) != 0) && IsPattern_2(POSITION_TYPE_BUY))
   {  result += m_pattern_2;
      results++;
   }
//--- if the model 3 is used and "Price Double Bottoms Near Lower Band or Double Top Near Upper Band "
   if(((m_patterns_used & 0x08) != 0) && IsPattern_3(POSITION_TYPE_BUY))
   {  result += m_pattern_3;
      results++;
   }
//--- if the model 4 is used and "Price Bounces Off the Middle Band from Above & Bounce Off from Below "
   if(((m_patterns_used & 0x10) != 0) && IsPattern_4(POSITION_TYPE_BUY))
   {  result += m_pattern_4;
      results++;
   }
//--- if the model 5 is used and "Volume Divergence at Lower Band or Upper Band  "
   if(((m_patterns_used & 0x20) != 0) && IsPattern_5(POSITION_TYPE_BUY))
   {  result += m_pattern_5;
      results++;
   }
//--- if the model 6 is used and "Bands Widening After Downtrend or After Uptrend "
   if(((m_patterns_used & 0x40) != 0) && IsPattern_6(POSITION_TYPE_BUY))
   {  result += m_pattern_6;
      results++;
   }
//--- if the model 7 is used and "Bands Orientation and Angle Changes "
   if(((m_patterns_used & 0x80) != 0) && IsPattern_7(POSITION_TYPE_BUY))
   {  result += m_pattern_7;
      results++;
   }
//--- return the result
   if(results > 0)
   {  return(int(round(result / results)));
   }
   return(0);
}

In beiden Fällen wird mit bitweisen Operationen geprüft, ob das Eingabe-Schema für die verwendeten Muster die Verwendung eines bestimmten Musters zulässt. Wie wir bei den Bollinger Bändern gesehen haben, haben die 8 Muster ihre eigenen Indizes 1, 2, 4, 8, 10, 20, 40 und 80. Da das Eingabe-Schema für die verwendeten Muster eine ganze Zahl im Bereich von 0 bis 255 ist, prüfen wir einfach, ob jedes dieser Muster auf der Grundlage des Eingabewerts ausgewählt ist. Zum Beispiel bedeutet ein Wert des Eingabe-Schemas von 107, dass nur die Muster 0, 1, 3, 5 und 6 ausgewählt werden. Bei unserem letzten Lauf für die Bollinger-Bänder haben wir neben anderen Schwellenwerten vor allem für dieses Eingabe-Schema optimiert. Wir setzen unseren Artikel nun fort, indem wir den RSI unten betrachten. 

Der Index der relativen Stärke

Der RSI ist ein sehr beliebter Oszillator, auf den sich viele Händler beim Platzieren und Schließen von Handelsgeschäften verlassen. Wie in der Zusammenfassung des Artikels und in dem gemeinsam genutzten Link beschrieben, handelt es sich um einen Index, der sich mit der Verfolgung der Preisveränderungsrate befasst, um etwaige bevorstehende Umkehrungen eines bestimmten Preistrends zu antizipieren. Wenn man einen Schritt zurücktritt und darüber nachdenkt, bewegt sich der EURUSD technisch gesehen seit Juni 2002 bis heute in einer Spanne zwischen 0,95 und 1,60, und man kann davon ausgehen, dass er sich auch in den nächsten 22 Jahren innerhalb dieser Spanne bewegen könnte. Im Gegensatz zu den Aktienindizes, die sich seit 2002 fast durchweg nach oben bewegt haben, handelt es sich hier um enorme Bewegungen, die eine Menge Pips ausmachen. Daher ist es für viele Händler nach wie vor von entscheidender Bedeutung, zu erkennen, wann ein Devisenpaar überkauft oder überverkauft ist. Seine Formel lautet wie folgt:

wobei:

• RS ist die Relative Stärke, definiert als das Verhältnis von durchschnittlichen Gewinnen zu durchschnittlichen Verlusten über einen bestimmten Zeitraum:

Der Zeitraum, für den diese durchschnittlichen Gewinne/Verluste berechnet werden, ist ein Eingabeparameter für den RSI-Indikator. Die Implementierung dieser Funktion in MQL5 wird bereits durch Bibliothekscode erledigt. Bleiben wir bei unserem Thema des letzten Artikels und betrachten wir 8 weitere Muster des RSI. Wir betrachten jedes dieser Muster in einem ähnlichen Modus wie im letzten Artikel, wo die Testergebnisse jedes einzelnen Musters zusammen mit der Beschreibung des Musters vorgestellt werden. Wir testen auf dem täglichen Zeitrahmen mit dem Devisenpaar USDJPY für das Jahr 2023.

Überkaufte/überverkaufte Niveaus (traditionell)

Unser Muster 0 für den RSI ist der traditionelle Durchbruch unter oder über den Oszillatorwerten von 30 bzw. 70. Dies ist die vorherrschende Art und Weise, wie dieser Indikator verwendet wird, und angesichts der Beliebtheit dieses Oszillators liegt es nahe, dass es sich um ein zuverlässiges Setup handeln muss. Durchbrüche unter der 30er-Marke weisen also auf ein überverkauftes Wertpapier hin und signalisieren oft eine Gelegenheit zum Kauf, während Durchbrüche über der 70er-Marke das Gegenteil signalisieren. Wir implementieren dies in unserer nutzerdefinierten Signalklasse wie folgt:

//+------------------------------------------------------------------+
//| Check for Pattern 0.                                             |
//+------------------------------------------------------------------+
bool CSignalRSI::IsPattern_0(ENUM_POSITION_TYPE T)
{  m_rsi.Refresh(-1);
   if(T == POSITION_TYPE_BUY && Base(StartIndex()) <= 30.0)
   {  return(true);
   }
   else if(T == POSITION_TYPE_SELL && Base(StartIndex()) >= 70.0)
   {  return(true);
   }
   return(false);
}

Bei Testläufen mit einem durch einen Assistenten zusammengestellten Expert Advisor, für den es hier und hier Anleitungen gibt, wie man den beigefügten Code zur Erstellung eines Expert Advisors verwendet, erhalten wir folgende Ergebnisse:

Diese traditionelle Verwendung des RSI ist, wie die meisten Oszillatoren, nicht frei von Mängeln, da der Oszillator in Trendmärkten über einen längeren Zeitraum oberhalb der 70er-Marke bleiben kann (wenn er nach oben tendiert) oder unterhalb der 30er-Marke in Abwärtsszenarien. Dies bedeutet oft, dass dieser Oszillator mit anderen Indikatoren wie gleitenden Durchschnitten oder sogar Oszillatoren wie dem MACD kombiniert werden kann, um aktuelle Signale richtig zu ermitteln. Darüber hinaus könnte die Anpassung dieser Oszillatorstufen von 70/30 auf z.B. 80/20 bei sehr volatilen Vermögenswerten geeignet sein, um die vorzeitige Eröffnung von Wertpapierpositionen zu verhindern.

Wie bereits in der Einleitung erwähnt, ist die Verwendung dieses Musters in schwankenden oder sich konsolidierenden Märkten sicherlich ideal, und auch die Oszillatorwerte können als verlässliche Richtschnur für den Ausstieg aus Positionen dienen, da sie, wie bereits erwähnt, Marktexzesse anzeigen.

RSI Fehlimpulse (Umkehrungen)

Dieses zweite Muster ähnelt zwar zunächst dem Muster 0, unterscheidet sich aber insofern, als dass es nach dem Testen der Schlüsselniveaus nach einem Umkehrpunkt im Oszillator sucht. Das macht sie schärfer. Ein Kauf-Signal ist ein Test der 30er-Marke, gefolgt von einem Durchbruch darüber, während ein Verkaufs-Signal durch einen Anstieg über 70, gefolgt von einem Schlusskurs darunter, signalisiert wird. Wir setzen dies in MQL5 wie folgt um:

//+------------------------------------------------------------------+
//| Check for Pattern 1.                                             |
//+------------------------------------------------------------------+
bool CSignalRSI::IsPattern_1(ENUM_POSITION_TYPE T)
{  m_rsi.Refresh(-1);
   if(T == POSITION_TYPE_BUY && Base(StartIndex() + 1) < 30.0 && Base(StartIndex()) > 30.0)
   {  return(true);
   }
   else if(T == POSITION_TYPE_SELL && Base(StartIndex() + 1) > 70.0 && Base(StartIndex()) < 70.0)
   {  return(true);
   }
   return(false);
}

Testläufe zum Nachweis der Handelbarkeit von Muster 1 liefern folgende Ergebnisse:

Muster 1, die Fehlimpulse, bieten in der Regel stärkere Signale als das bloße Über- oder Unterschreiten der Schwellenwerte der Schlüsseloszillatoren, da sie einen Wechsel der Marktstimmung bestätigen, der durch mehr als eine RSI-Bewegung bestätigt wird. Sie deuten darauf hin, dass sich die Stimmung umkehrt, ohne dass es unbedingt einer Kursbestätigung bedarf. Dieser letzte Punkt, so wird argumentiert, macht Fehlimpulse des RSI zuverlässiger als RSI-Divergenzen mit der Kursrichtung, die ebenfalls ein RSI-Signal sein können, wie wir unten hervorheben.

RSI-Divergenz (Kauf/Verkauf-Divergenz)

Muster 2 tritt auf, wenn sich der RSI in eine bestimmte Richtung bewegt und der Kurs sich in die entgegengesetzte Richtung bewegt, was wiederum auf eine mögliche Verschiebung der Marktdynamik hinweist. Diese Divergenz signalisiert, dass sich der vorherrschende Aufwärts- oder Abwärtstrend abschwächen könnte, sodass eine Umkehr bevorstehen könnte. Diese Divergenzen können entweder auf oder abwärts tendieren, wobei eine Aufwärts-Divergenz signalisiert wird, wenn der Kurs niedrigere Tiefs erreicht, während der RSI höhere Tiefs erreicht, und eine Abwärts-Divergenz, wenn der Kurs höhere Hochs erreicht, der RSI aber höhere Tiefs erreicht. Um dieses Muster in unserer nutzerdefinierten Signalklasse zu kodieren, verwenden wir das folgende Listing:

//+------------------------------------------------------------------+
//| Check for Pattern 2.                                             |
//+------------------------------------------------------------------+
bool CSignalRSI::IsPattern_2(ENUM_POSITION_TYPE T)
{  m_rsi.Refresh(-1);
   m_close.Refresh(-1);
   if(T == POSITION_TYPE_BUY && 
   Close(StartIndex()) < Close(StartIndex() + 1) && 
   Close(StartIndex() + 1) < Close(StartIndex() + 2) && 
   Base(StartIndex()) > Base(StartIndex() + 1) && 
   Base(StartIndex() + 1) > Base(StartIndex() + 2)
   )
   {  return(true);
   }
   else if(T == POSITION_TYPE_SELL && 
   Close(StartIndex()) > Close(StartIndex() + 1) && 
   Close(StartIndex() + 1) > Close(StartIndex() + 2) && 
   Base(StartIndex()) < Base(StartIndex() + 1) && 
   Base(StartIndex() + 1) < Base(StartIndex() + 2)
   )
   {  return(true);
   }
   return(false);
}

Testläufe unseres mit dem Assistenten zusammengestellten Expert Advisors, die ausschließlich das Muster 2 verwenden, für das das verwendete Eingabe-Schema 4 sein muss, führen zu den folgenden Ergebnissen:

Die RSI-Divergenz ist, wie bereits unter Muster 1 erwähnt, nicht so widerstandsfähig, dient aber hauptsächlich als Frühwarnindikator für Kursumkehrungen. Sie sind besonders wichtig für Märkte, die sich im Trend befinden, oder für Situationen, in denen es sehr starke Trends gibt. Die Divergenzsignale, die sie liefern, könnten jedoch auf einen Pullback und nicht auf eine Trendwende hindeuten, weshalb man argumentiert, sie seien nicht so zuverlässig. Aus diesem Grund wird er häufig durch zusätzliche Indikatoren wie gleitende Durchschnitte sowie Unterstützungs- und Widerstandstrendlinien ergänzt.

Die Notwendigkeit, falsche Divergenzsignale herauszufiltern, ist hier also sehr wichtig. Was helfen könnte, ist, sich auf größere Zeitrahmen zu verlassen, da diese zwar nicht so produktiv bei der Generierung von Signalen sind, dafür aber etwas zuverlässiger. Bemerkenswert sind auch die versteckten Divergenzen. Diese dienen als Anhaltspunkte für eine Trendfortsetzung, wobei eine Aufwärtsbewegung daraus abgeleitet wird, dass der Kurs höhere Tiefststände und der RSI niedrigere Tiefststände aufweist, während die versteckte Abwärtsdivergenz aus niedrigeren Höchstständen des Kurses und höheren Höchstständen des RSI abgeleitet wird.

RSI kreuzt oberhalb/unterhalb der Mittellinie (50er Marke)

Muster 3 konzentriert sich auf den RSI-Mittelwert, d.h. 50, und wertet alle Überschreitungen unter diesem Wert als Abwärtstrend, während alle Durchbrüche über diesem Wert als Aufwärtstrend gewertet werden. Standardmäßig sollte das Vorhandensein des RSI in der Nähe der 50er-Marke darauf hinweisen, dass kein klares Signal vorliegt. Daher sind Überschreitungen dieser Marke erwartungsgemäß nur suggestiv und bedürfen oft einer Bestätigung, oder sie dienen anderen Trendindikatoren als Filter.

Die Mittellinie kann sowohl als Trendfortsetzungs- als auch als Trendumkehrindikator dienen, da sie „auf der Kippe“ steht. Die Trendfortsetzung wird für ein Aufwärtssignal bestätigt, wenn der RSI über die 50 klettert, und für ein Abwärtssignal, wenn er in die entgegengesetzte Richtung klettert. Umkehrungen werden auch als Bestätigung des Abwärtsbewegung verstanden, wenn der RSI die 50er-Marke von unten durchbricht, bevor er wieder darunter fällt, und für die Aufwärtsbewegung in einem entgegengesetzten U-Muster über dieser Mittellinie. Wir implementieren unser Muster 3 wie folgt:

//+------------------------------------------------------------------+
//| Check for Pattern 3.                                             |
//+------------------------------------------------------------------+
bool CSignalRSI::IsPattern_3(ENUM_POSITION_TYPE T)
{  m_rsi.Refresh(-1);
   m_close.Refresh(-1);
   m_high.Refresh(-1);
   m_low.Refresh(-1);
   if(T == POSITION_TYPE_BUY && Base(StartIndex() + 1) < 50.0 && Base(StartIndex()) > 50.0)
   {  return(true);
   }
   else if(T == POSITION_TYPE_SELL && Base(StartIndex() + 1) > 50.0 && Base(StartIndex()) < 50.0)
   {  return(true);
   }
   return(false);
}

Testläufe nur mit diesem Muster, bei denen unser Eingabeparameter für verwendete Muster mit 8 belegt ist, führen zu folgenden Ergebnissen:

Das Kreuzen der Mittellinie ist eine übermäßige Vereinfachung aller bisher betrachteten Muster, was es wiederum zum am wenigsten aussagekräftigen potenziellen Signal macht. Die Verwendung von schwebenden Aufträgen mit dieser Art von Signalen ist daher üblich, ebenso wie ihre Verwendung über mehrere Zeitrahmen hinweg. Darüber hinaus kann Muster 3 auch für Trailing-Stops verwendet werden, bei denen Händler in einer Kaufposition bleiben, solange der RSI über der 50er-Mittellinie liegt, und aus der Position aussteigen, sobald der RSI dieses Niveau kreuzt oder unterschreitet. Für Verkaufspositionen würde ein umgekehrtes Muster gelten.

RSI, Bruch der Trendlinie

Muster 4 ist wahrscheinlich das komplizierteste unter den 8 Mustern, die wir in diesem Artikel betrachten, da es die Höchst- oder Tiefstwerte entlang des RSI sowie einen Bruch der jeweiligen Trendlinien berücksichtigt. Bei diesem Musteraufbau wird ein Aufwärtssignal interpretiert, wenn auf absteigende Spitzen des RSI ein Anstieg des RSI folgt, der die Trendlinie der Spitzen durchbricht. Umgekehrt werden steigende RSI-Tiefs, gefolgt von einem Durchbrechen oder Unterschreiten der Trendlinie dieser Tiefs durch den aktuellen RSI-Wert, als Zeichen für ein Abwärtssignal gewertet. Wir führen dies wie folgt auf:

//+------------------------------------------------------------------+
//| Check for Pattern 4.                                             |
//+------------------------------------------------------------------+
bool CSignalRSI::IsPattern_4(ENUM_POSITION_TYPE T)
{  m_rsi.Refresh(-1);
   if(T == POSITION_TYPE_BUY && 
   Base(StartIndex()) > Base(StartIndex() + 1) && 
   Base(StartIndex() + 1) < Base(StartIndex() + 2) && 
   Base(StartIndex() + 2) > Base(StartIndex() + 3) && 
   Base(StartIndex() + 3) < Base(StartIndex() + 4) && 
   Base(StartIndex() + 4) > Base(StartIndex() + 2) && 
   Base(StartIndex()) >= 2.0*Base(StartIndex() + 2)-Base(StartIndex() + 4)
   )
   {  return(true);
   }
   else if(T == POSITION_TYPE_SELL && 
   Base(StartIndex()) < Base(StartIndex() + 1) && 
   Base(StartIndex() + 1) > Base(StartIndex() + 2) && 
   Base(StartIndex() + 2) < Base(StartIndex() + 3) && 
   Base(StartIndex() + 3) > Base(StartIndex() + 4) && 
   Base(StartIndex() + 4) < Base(StartIndex() + 2) && 
   Base(StartIndex()) <= 2.0*Base(StartIndex() + 2)-Base(StartIndex() + 4)
   )
   {  return(true);
   }
   return(false);
}

Beachten Sie, dass wir nicht unbedingt nach den letzten echten Höchst- oder Tiefstständen des RSI suchen, sondern vielmehr prüfen, ob in den letzten 5 RSI-Messwerten eine Abfolge von Höchstständen (für ein Kaufsignal) oder Tiefstständen (für ein Verkaufssignal) zu erkennen ist. Wenn diese Prüfung nur innerhalb der letzten 5 RSI-Werte positiv ausfällt, dann prüfen wir einfach, ob die Trendlinie gebrochen wurde. Auch hier gehen wir nicht auf die Geometrie der tatsächlichen Linie ein, die diese Spitzen oder Talsohlen verbindet, sondern betrachten einfach die Veränderung des RSI zwischen diesen beiden Extrempunkten. Wenn er sich nicht im gleichen Tempo wie der aktuelle RSI-Wert fortsetzt, interpretieren wir dies als Verletzung der Trendlinie, denn wenn die Höchst- oder Tiefstwertlinie beibehalten worden wäre, wäre der aktuelle Wert genauso weit vom letzten Höchst- oder Tiefstwert entfernt gewesen wie sein Vorgänger in der Abfolge. Ein Test mit nur diesem Muster 4, bei dem die Eingabe für die verwendeten Muster 10 beträgt, ergibt folgende Ergebnisse:

Der in diesem Artikel genutzte RSI-Trendlinienbruch, wie er in der gemeinsamen Quelle angegeben ist, berücksichtigt oder prüft dieses Muster nur in den letzten 5 Messwerten des RSI. Ein umfassenderer Ansatz, bei dem die fraktalen oder Hochs/Tiefs des RSI untersucht werden, könnte interessantere Ergebnisse liefern.

RSI in überkauften/überverkauften Zonen mit Bestätigung des gleitenden Durchschnitts

Muster 5 ist einfach eine Kombination von Muster 0 mit der Bestätigung des gleitenden Durchschnitts. Daher gelten die für das obige Muster 0 beschriebenen Aufwärts-Bedingungen sowie ein Kurs oberhalb des gleitenden Durchschnitts, um die Kaufposition zu definieren, während die gleichen Abwärts-Bedingungen mit einem Kurs unterhalb des gleitenden Durchschnitts als Bestätigung für eine Verkaufsposition gelten würden. Mit nur dieser Anpassung definieren wir dies als Funktion in MQL5 wie folgt:

//+------------------------------------------------------------------+
//| Check for Pattern 5.                                             |
//+------------------------------------------------------------------+
bool CSignalRSI::IsPattern_5(ENUM_POSITION_TYPE T)
{  m_rsi.Refresh(-1);
   m_close.Refresh(-1);
   m_ma.Refresh(-1);
   if(T == POSITION_TYPE_BUY && Base(StartIndex()) < 30.0 && Close(StartIndex()) > m_ma.Main(StartIndex()))
   {  return(true);
   }
   else if(T == POSITION_TYPE_SELL && Base(StartIndex()) > 70.0 && Close(StartIndex()) < m_ma.Main(StartIndex()))
   {  return(true);
   }
   return(false);
}

Und exklusive Testläufe, die nur dieses Muster verwenden, wobei das Eingabe-Schema für die verwendeten Muster 20 beträgt, führen zu den folgenden Ergebnissen:

RSI Muster doppeltes Tief/Hoch

Dieses Muster ähnelt auch insofern dem Muster 1, als es das Testen der wichtigen RSI-Oszillatorwerte von 70 und 30 erfordert. Im Gegensatz zu Muster 1, für das nur ein einziger Höchst- oder Tiefststand erforderlich ist, sind für Muster 6 jedoch zwei erforderlich, sodass zwei aufeinander folgende Tiefststände unter der 30er-Linie, denen jeweils eine Erholung von diesem Niveau folgt, ein Aufwärtssignal darstellen. Ebenso wird ein doppelte Spitze über der 70er-Marke, gefolgt von einem Schlusskurs unter dieser Marke, als rückläufiges Signal gewertet. Dies setzen wir wie folgt um:

//+------------------------------------------------------------------+
//| Check for Pattern 6.                                             |
//+------------------------------------------------------------------+
bool CSignalRSI::IsPattern_6(ENUM_POSITION_TYPE T)
{  m_rsi.Refresh(-1);
   if(T == POSITION_TYPE_BUY && Base(StartIndex()) < 30.0 && 
   Base(StartIndex()) > Base(StartIndex() + 1) && 
   Base(StartIndex() + 1) < Base(StartIndex() + 2) && 
   Base(StartIndex() + 2) > Base(StartIndex() + 3) && 
   Base(StartIndex() + 3) < Base(StartIndex() + 4)
   )
   {  return(true);
   }
   else if(T == POSITION_TYPE_SELL && Base(StartIndex()) > 70.0 && 
   Base(StartIndex()) < Base(StartIndex() + 1) && 
   Base(StartIndex() + 1) > Base(StartIndex() + 2) && 
   Base(StartIndex() + 2) < Base(StartIndex() + 3) && 
   Base(StartIndex() + 3) > Base(StartIndex() + 4)
   )
   {  return(true);
   }
   return(false);
}

Ein Test mit nur diesem Muster 6, bei dem der Eingabeparameter für die verwendeten Muster 40 sein muss, führt zu den folgenden Ergebnissen:

RSI mit mehreren Zeitfenstern

Unser letztes Muster, Muster 7, nimmt einfach Muster 0, das traditionelle und beliebteste Muster für den RSI, und wendet es auf mehrere Zeitrahmen an. Die Auf- uns Abwärts-Bedingungen sind daher identisch mit denen, die wir oben im Muster 0 gesehen haben. Der zusätzliche Eingangsparameter, den unsere nutzerdefinierte Signalklasse für diesen Zweck verwenden wird, ist der zusätzliche Zeitrahmen, der die Konstruktion des zweiten RSI-Handles unterstützt. Für effiziente Testzwecke und zur Vermeidung des Preisrauschens, das in kürzeren Zeiträumen vorherrschen kann, wird unser zweiter Zeitrahmen größer sein als der Standard-Testzeitrahmen. Die Kodierung wird im Folgenden erläutert:

//+------------------------------------------------------------------+
//| Check for Pattern 7.                                             |
//+------------------------------------------------------------------+
bool CSignalRSI::IsPattern_7(ENUM_POSITION_TYPE T)
{  m_rsi.Refresh(-1);
   m_rsi_alt.Refresh(-1);
   if(T == POSITION_TYPE_BUY && Base(StartIndex()) <= 30.0 && Alt(StartIndex()) <= 30.0)
   {  return(true);
   }
   else if(T == POSITION_TYPE_SELL && Base(StartIndex()) >= 70.0 && Alt(StartIndex()) >= 70.0)
   {  return(true);
   }
   return(false);
}

Das Testen nur dieses Musters mit dem als 80 verwendeten Eingabe-Schemas ergibt die folgenden Ergebnisse:

Wie schon bei den Bollinger Bändern, siehe oben, gibt es auch für diese nutzerdefinierte Signalklasse eine Option für mehrere Muster. Wie bei den Bollinger-Bändern optimieren wir die Eingabemuster, die zur Abbildung einer ganzen Zahl von 0 bis 255 verwendet werden, um die ideale Kombination von Mustern zu finden, die für den RSI-Oszillator ideal sein könnten. Unser Optimierungslauf ergab das Schema für die als 189 verwendeten Muster. Im Binärformat ist das 10111101, was bedeutet, dass die einzigen Muster aus unserem Optimierungslauf, die „ungeeignet“ sind, Muster 1 und Muster 6 sind (die RSI-Fehlimpulse und doppelte Hoch/Tiefs). Dies galt natürlich für das Paar USDJPY, und eine Kreuzvalidierung wurde nicht durchgeführt. Dennoch werden die Testergebnisse im Folgenden mitgeteilt:

Schlussfolgerung

Abschließend haben wir in diesem Artikel den RSI-Oszillator, einen sehr beliebten technischen Indikator, untersucht, indem wir seine Signalmuster beleuchtet haben. Einige dieser Muster sind sehr gebräuchlich und lassen sich leicht mit dem RSI in Verbindung bringen, wie das traditionelle Muster 0, während andere, wie der Trendlinienbruch oder das Muster 4, einigen Händlern fremd erscheinen mögen. Unsere nutzerdefinierte Signalklasse testet jedoch nicht nur jedes einzelne Muster unter Ausschluss aller anderen, sondern nimmt sich auch die Freiheit, die für die Eingabe verwendeten Schemas als Maske zu verwenden, um mehr als ein Muster auszuwählen, sodass die Muster, die eine bestimmte Position öffnen, nicht unbedingt die gleichen sind, die bestimmen, wann sie geschlossen wird. 

Außerdem könnte es sich für die Leser lohnen, zusätzliche Muster zu erforschen, die wir in diesem Artikel nicht berücksichtigt haben. Wir haben nur 8 Muster verwendet, was bedeutet, dass unsere Eingabe für die verwendeten Muster nicht mehr als 2 hoch 8 minus 1 (255) betrug. Wenn wir diese Anzahl von Mustern addieren und sagen, dass sie bis zu 10 gehen soll, dann wird unsere Eingabe-Schema für die verwendeten Muster von 0 bis zu 2 hoch 10 minus 1 reichen, was 1023 ergibt. Weitere Muster, die in Betracht gezogen werden könnten, sind die RSI-Breakout-Strategie, bei der, wenn der Preis eines Vermögenswerts über einen wichtigen Widerstand auf dem Preisdiagramm steigt und gleichzeitig die 70er-Marke auf dem RSI-Chart durchbricht, dieses Signal, im Gegensatz zu den bisher betrachteten Mustern, als stark steigend und als Beginn eines wichtigen Trends interpretiert wird. Ebenso würde ein rückläufiges Signal folgen, wenn der Kurs unter einen wichtigen charttechnischen Widerstand fällt und der RSI ebenfalls unter 30 fällt. Dies steht auch im Widerspruch zu der Interpretation des RSI in diesem Artikel. Die Kodierung setzt voraus, dass der Händler die wichtigsten Unterstützungs- und Widerstandsniveaus des Wertpapiers, mit dem er handelt, kennt, sodass die Umsetzung dem Leser (Händler) überlassen bleibt.