MQL5 Wizard - Klasse für die Arbeit mit Kerzenformationen - Bibliothek für den MetaTrader 5

Einleitung

Der MQL5-Wizard erlaubt eine automatische Erstellung von Expert Advisor Codes auf Basis von Klassen von Handelssignalen, Position Tracking und Money Management. Die offene Struktur der Codes, mit welchen der MQL5 Wizard arbeitet, erleichtert das Schreiben und Testen unterschiedlicher Handelssysteme. Dafür reicht es, ein Modul von Handelssignalen zu schreiben.

Die Idee der Erstellung der Klassen von Handelssignalen sieht folgendermaßen aus: die Klasse von Handelssignalen wird von der Basisklasse CExpertSignal geerbt, dann werden in dieser Klasse (neben besonderen Daten und Zugangsmethoden zu Indikatoren) die Methoden zur Überprüfung der Bedingungen für das Eröffnen/Schließen von Long- und Short-Positionen CheckOpenLong(), CheckCloseLong(), CheckOpenShort() и CheckCloseShort() deklariert.

Das Buch "The Strategies of the Best Traders in the World" beschreibt Indikatoren und Handelsstrategien für die technische Analyse. Neben den traditionellen beschäftigt sich das Buch mit den Handelssignalen, die auf einer kombinierten Anwendung von Umkehrkerzenformationen mit der Bestätigung durch die Oszillatoren Stochastic, CCI, MFI und RSI beruhen. 

Am besten setzt man Methoden der Identifizierung von Umkehrkerzenformationen in einer separaten Klasse um, auf deren Basis dann Module von Handelssignalen mit verschiedenen Möglichkeiten der Bestätigung erstellt werden können.

Hier wird die Klasse CCandlePattern angeboten, die die Erstellung von Modulen von Handelssignalen, in welchen Kerzenformationen verwendet werden, deutlich erleichtert und vereinheitlicht.

Klasse CCandlePattern

Die Klasse CCandlePattern wird von der CExpertSignal Basisklasse des Generators von Handelssignalen abgeleitet:

class CCandlePattern : public CExpertSignal
  {
protected:
   //--- Indikatoren
   CiMA              m_MA;
   //--- Zeitreihen
   CiOpen            m_open;
   CiHigh            m_high;
   CiLow             m_low;
   CiClose           m_close;
   //--- Eingabeparameter
   int               m_ma_period;

public:
   //--- Konstruktor
                     CCandlePattern();
   //--- Methode zum Setzen von Eingabeparametern
   void              MAPeriod(int period)             { m_ma_period=period;                 } 
   //--- Methoden zur Initialisierung
   virtual bool      ValidationSettings();
   virtual bool      InitIndicators(CIndicators *indicators);

   //--- Methode zur Überprüfung der Bildung eines bestimmten Kerzenmusters
   bool              CheckCandlestickPattern(ENUM_CANDLE_PATTERNS CandlePattern);
   //--- Methoden zur Überprüfung der Formation bärischer/bullischer Muster
   bool              CheckPatternAllBullish();
   bool              CheckPatternAllBearish();

protected:
   //--- Methoden der Initialisierung von Indikatoren und Zeitreihen
   bool              InitMA(CIndicators *indicators);
   bool              InitOpen(CIndicators *indicators);
   bool              InitHigh(CIndicators *indicators);
   bool              InitLow(CIndicators *indicators);
   bool              InitClose(CIndicators *indicators);
   //--- Methoden, die für die Überprüfung von Kerzenformationen verwendet werden
   double            AvgBodySize(int ind);
   double            MA(int ind)                const { return(m_MA.Main(ind));             }
   double            Open(int ind)              const { return(m_open.GetData(ind));        }
   double            High(int ind)              const { return(m_high.GetData(ind));        }
   double            Low(int ind)               const { return(m_low.GetData(ind));         }
   double            Close(int ind)             const { return(m_close.GetData(ind));       }
   double            CloseAvg(int ind)          const { return(MA(ind));                    }
   double            MidPoint(int ind)          const { return(0.5*(High(ind)+Low(ind)));   }
   double            MidOpenClose(int ind)      const { return(0.5*(Open(ind)+Close(ind))); }
   //--- Methoden zur Überprüfung der Bildung von Mustern
   bool              CheckPatternThreeBlackCrows();
   bool              CheckPatternThreeWhiteSoldiers();
   bool              CheckPatternDarkCloudCover();
   bool              CheckPatternPiercingLine();
   bool              CheckPatternMorningDoji();
   bool              CheckPatternEveningDoji();
   bool              CheckPatternBearishEngulfing();
   bool              CheckPatternBullishEngulfing();
   bool              CheckPatternEveningStar();
   bool              CheckPatternMorningStar();
   bool              CheckPatternHammer();
   bool              CheckPatternHangingMan();
   bool              CheckPatternBearishHarami();
   bool              CheckPatternBullishHarami();
   bool              CheckPatternBearishMeetingLines();
   bool              CheckPatternBullishMeetingLines();
  };

Verwendung der Klasse CCandlePattern in Modulen von Handelssignalen

Für die Verwendung der Klasse CCandlePattern in einem Modul von Handelssignalen ist es erforderlich, die Datei CandlePatterns.mqh hinzuzugefügen sowie die Klasse von Handelssignalen von der Klasse CCandlePattern abzuleiten und ihr (neben anderen notwendigen Indikatoren und Methoden) die Methoden zur Überprüfung der Erfüllung von Bedingungen hinzuzufügen.

Die Bildung einer Kerzenformation kann als Handelssignal dienen, muss aber häufig bestätigt werden (z.B. durch Oszillatoren). Zur Generierung von Handelssignalen werden die folgenden Methoden verwendet:

• bool CheckOpenLong(double &price,double &sl,double &tp,datetime &expiration) überprüft die Bedingungen für das Eröffnen einer Long-Position;
  
• bool CheckCloseLong(double &price) überprüft die Bedingungen für das Schließen einer Long-Position;
  
• bool CheckOpenShort(double &price,double &sl,double &tp,datetime &expiration) überprüft die Bedingungen für das Eröffnen einer Short-Position;
  
• bool CheckCloseShort(double &price) überprüft die Bedingungen für das Schließen einer Short-Position;

//+------------------------------------------------------------------+
//|                                          CSampleCandleSignal.mqh |
//+------------------------------------------------------------------+
// Include-Datei mit der Klasse CCandlePattern
// die Datei candlepatterns.mqh muss in demselben Verzeichnis abgelegt werden
#include "CandlePatterns.mqh"
// wizard description start
//+------------------------------------------------------------------+
//| Description of the class                                         |
//| Title=Test signal                                                |
//| Type=Signal                                                      |
//| Name=CSampleCandleSignal                                         |
//| Class=CSampleCandleSignal                                        |
//| Page=                                                            |
//| Parameter=param1,int,9                                           |
....
//| Parameter=paramN,int,13                                          |
//| Parameter=MAPeriod,int,12                                        |
//+------------------------------------------------------------------+
// wizard description end
//+------------------------------------------------------------------+
class CSampleCandleSignal : public CCandlePattern
  {
protected:
   // --- Indikatoren
   ....
   //--- Eingabeparameter
   ...
public:
   //--- Konstruktor
                     CTestClass();
   //--- Methoden zum Setzen von Werten der Eingabeparameter
   ...
   //--- Initialisierung der Indikatoren und Überprüfung der Werte
   virtual bool      ValidationSettings();
   virtual bool      InitIndicators(CIndicators *indicators);
   //--- Methoden zur Überprüfung von Eröffnen/Schließen von Positionen
   +virtual bool      CheckOpenLong(double &price,double &sl,double &tp,datetime &expiration);
   virtual bool      CheckCloseLong(double &price);
   virtual bool      CheckOpenShort(double &price,double &sl,double &tp,datetime &expiration);
   virtual bool      CheckCloseShort(double &price);

protected:
   //--- Methoden zur Initialisierung der Indikatoren
   ...
   //--- Zugangsmethoden zu den Werten der Indikatoren
   ...
  };

Mehr Informationen über die Erstellung der Klasse von Handelssignalen finden Sie im Artikel "MQL5 Wizard: Wie man ein Modul von Handelssignalen erzeugt".

Beachten Sie den String:

//| Parameter=MAPeriod,int,12                                        |

in der Beschreibung der Klasse von Handelssignalen.

Der Parameter MAPeriod wird in der Elternklasse CCandlePattern für die Berechnung des durchschnittlichen Schlusspreises und gemittelter Werte des Kerzenkörpers verwendet. Der standardmäßige Wert m_ma_period=12 wird im Konstruktor CCandlePattern() gesetzt. Nichtsdestotrotz ist diese Periode am besten mithilfe vom Eingabeparameter einzugeben, die Funktion MAPeriod(int period) setzt den Wert m_ma_period.

So kann dieser Parameter im Strategietester optimiert werden.

Aufruf der Elternklassen ValidationSettings und InitIndicators

Die Methoden sind am besten ganz am Anfang aufzurufen:

bool CSampleCandleSignal ::ValidationSettings()
  {
//--- Aufruf der Methode ValidationSettings der Klasse CCandlePattern
   if(!CCandlePattern::ValidationSettings()) return(false);
..
//--- ok
   return(true);
  }

und in InitIndicators:

bool CSampleCandleSignal ::InitIndicators(CIndicators *indicators)
  {
//--- Aufruf der Methode InitIndicators der Klasse CCandlePattern
   if(!CCandlePattern::InitIndicators(indicators)) return(false);   
...
//--- ok
   return(true);
  }

Methoden zur Überprüfung von Kerzenformationen

Um die Formation eines Musters zu überprüfen ist es notwendig, die Methode bool CheckCandlestickPattern(ENUM_CANDLE_PATTERNS CandlePattern) für das als Parameter angegebene Muster aufzurufen. Dar+ber hinaus können Sie die Formation eines "bullischen/bärischen" Musters mithilfe der Methoden CheckPatternAllBullish() und CheckPatternAllBearish() überprüfen.

Für eine einfache und korrekte Arbeit wird die Aufzählung ENUM_CANDLE_PATTERNS verwendet:

enum ENUM_CANDLE_PATTERNS  // Kerzenformationen
  {
   CANDLE_PATTERN_THREE_BLACK_CROWS     = 1,
   CANDLE_PATTERN_THREE_WHITE_SOLDIERS  = 2,
   CANDLE_PATTERN_DARK_CLOUD_COVER      = 3,
   CANDLE_PATTERN_PIERCING_LINE         = 4,
   CANDLE_PATTERN_MORNING_DOJI          = 5,
   CANDLE_PATTERN_EVENING_DOJI          = 6,
   CANDLE_PATTERN_BEARISH_ENGULFING     = 7,
   CANDLE_PATTERN_BULLISH_ENGULFING     = 8,
   CANDLE_PATTERN_EVENING_STAR          = 9,
   CANDLE_PATTERN_MORNING_STAR          = 10,
   CANDLE_PATTERN_HAMMER                = 11,
   CANDLE_PATTERN_HANGING_MAN           = 12,
   CANDLE_PATTERN_BEARISH_HARAMI        = 13,
   CANDLE_PATTERN_BULLISH_HARAMI        = 14,
   CANDLE_PATTERN_BEARISH_MEETING_LINES = 15,
   CANDLE_PATTERN_BULLISH_MEETING_LINES = 16
  };

Methoden zur Überprüfung der Formation bullischer Muster:

///--- Überprüft die Formation des Musters "3 White Soldiers":
  CheckCandlestickPattern(CANDLE_PATTERN_THREE_WHITE_SOLDIERS)

///--- Überprüft die Formation des Musters "Piercing Line":
  CheckCandlestickPattern(CANDLE_PATTERN_PIERCING_LINE)

///--- Überprüft die Formation des Musters "Morning Doji":
  CheckCandlestickPattern(CANDLE_PATTERN_MORNING_DOJI)

///--- Überprüft die Formation des Musters "Bullish Engulfing":
  CheckCandlestickPattern(CANDLE_PATTERN_BULLISH_ENGULFING)

///--- Überprüft die Formation des Musters "Bullish Haramii":
  CheckCandlestickPattern(CANDLE_PATTERN_BULLISH_HARAMI)

///--- Überprüft die Formation des Musters "Morning Star":
  CheckCandlestickPattern(CANDLE_PATTERN_MORNING_STAR)

///--- Überprüft die Formation des Musters "Bullish Meeting Lines":
  CheckCandlestickPattern(CANDLE_PATTERN_BULLISH_MEETING_LINES)

///--- Überprüft die Formation des Musters "Hammer":
  CheckCandlestickPattern(CANDLE_PATTERN_HAMMER)

///--- Überprüft, ob mindestens eine der bullischen Kerzenformationen gebildet wird
  CheckPatternAllBullish();

Methoden zur Überprüfung der Formation bärischer Muster:

///--- Überprüft die Formation des Musters "3 Black Crows":
  CheckCandlestickPattern(CANDLE_PATTERN_THREE_BLACK_CROWS)

///--- Überprüft die Formation des Musters "Dark Cloud Cover":
  CheckCandlestickPattern(CANDLE_PATTERN_DARK_CLOUD_COVER)

///--- Überprüft die Formation des Musters "Evening Doji":
  CheckCandlestickPattern(CANDLE_PATTERN_EVENING_DOJI)

///--- Überprüft die Formation des Musters "Bearish Engulfing":
  CheckCandlestickPattern(CANDLE_PATTERN_BEARISH_ENGULFING)

///--- Überprüft die Formation des Musters "Evening Star":
  CheckCandlestickPattern(CANDLE_PATTERN_EVENING_STAR)

///--- Überprüft die Formation des Musters "Hanging Man":
  CheckCandlestickPattern(CANDLE_PATTERN_HANGING_MAN)

///--- Überprüft die Formation des Musters "Bearish Harami":
  CheckCandlestickPattern(CANDLE_PATTERN_BEARISH_HARAMI)

///--- Überprüft die Formation des Musters "Bearish Meeting Lines":
  CheckCandlestickPattern(CANDLE_PATTERN_BEARISH_MEETING_LINES)

///--- Überprüft, ob mindestens eine der bärischen Kerzenformationen gebildet wird
  CheckPatternAllBearish();

Beispiele für die Anwendung dieser Methoden in den Methoden zur Überprüfung der Bedingungen für das Eröffnen/Schließen von Positionen:

Eröffnen einer Long-Position:

//-----------------------------------------------------------------------------------------------+
//| Methode zur Überprüfung der Erfüllung der Bedingungen für das Eröffnen einer Long-Position   |
//| true: die Bedingungen sind erfüllt sind                                                      |
//| false: die Bedingungen sind nicht erfüllt sind                                               |
//+----------------------------------------------------------------------------------------------+
bool CSampleCandleSignal::CheckOpenLong(double &price,double &sl,double &tp,datetime &expiration)
  {
//--- Überprüfung der Bedingungen für das Eröffnen einer Long-Position
//--- hier können Sie neben Ihren Indikatoren die Methoden
//--- zur Überprüfung der Formation von Mustern verwenden
//--- z.B. überprüfen wir die Kerzenformation "3 weiße Soldaten":
   if CheckCandlestickPattern(CANDLE_PATTERN_THREE_WHITE_SOLDIERS) return(true):
//--- sonst wird das Signal für das Eröffnen einer Long-Position nicht gesendet
   return(false);
  }

Schließen einer Long-Position:

//------------------------------------------------------------------------------------------------+
//| Methode zur Überprüfung der Erfüllung der Bedingungen für das Schließen einer Long-Position   |
//| true: die Bedingungen sind erfüllt sind                                                       |
//| false: die Bedingungen sind nicht erfüllt sind                                                |
//+-----------------------------------------------------------------------------------------------+
bool CSampleCandleSignal::CheckCloseLong(double &price)
  {
/--- Überprüfung der Bedingungen für das Schließen einer Long-Position
//--- hier können Sie neben Ihren Indikatoren die Methoden
//--- zur Überprüfung der Formation von Mustern verwenden
//--- z.B. überprüfen wir die Formation eines der bärischen Muster:
   if CheckPatternAllBearish() return(true):
//--- kein Signal
   return(false);
  }

Eröffnen einer Short-Position:

//------------------------------------------------------------------------------------------------+
//| Methode zur Überprüfung der Erfüllung der Bedingungen für das Schließen einer Short-Position  |
//| true: die Bedingungen sind erfüllt sind                                                       |
//| false: die Bedingungen sind nicht erfüllt sind                                                |
//+-----------------------------------------------------------------------------------------------+
bool CSampleCandleSignal::CheckOpenShort(double &price,double &sl,double &tp,datetime &expiration)
  {
//--- Überprüfung der Bedingungen für das Eröffnen einer Short-Position
//--- hier können Sie neben Ihren Indikatoren die Methoden
//--- zur Überprüfung der Kerzenformaiton "3 schwarze Krähen" verwenden:
    if CheckCandlestickPattern(CANDLE_PATTERN_THREE_BLACK_CROWS) return(true):
//--- sonst kein Signal zum Eröffnen einer Short-Position
   return(false);
  }

Schließen einer Short-Position:

//------------------------------------------------------------------------------------------------+
//| Methode zur Überprüfung der Erfüllung der Bedingungen für das Schließen einer Short-Position  |
//| true: die Bedingungen sind erfüllt sind                                                       |
//| false: die Bedingungen sind nicht erfüllt sind                                                |
//+-----------------------------------------------------------------------------------------------+
bool CSampleCandleSignal::CheckCloseShort(double &price)
  {
//--- Überprüfung der Bedingungen für das Schließen einer Short-Position
//--- hier können Sie neben Ihren Indikatoren die Methoden
//--- zur Überprüfung der Formation von Mustern verwenden
//--- z.B. überprüfen wir die Formation eines der bullischen Muster:
   if CheckPatternAllBullish() return(true):
//--- sonst wird kein Signal für das Schließen einer Short-Position gesendet
   return(false);
  }

Empfehlungen

Die Verwendung von Umkehrkerzenformationen zusammen mit Signalen von Oszillatoren, reduziert die Anzahl der falschen Signale und erhöht die Effizienz des Handelssystems.

Das Buch "The Strategies of the Best Traders in the World" beschreibt die folgenden Kerzenformationen (bullische/bärische):

• 3 Black Crows/3 White Soldiers
• Dark Cloud Cover/Piercing Line
• Morning Doji/Evening Doji
• Bearish Engulfing/Bullish Engulfing
  
• Evening Star/Morning Star
  
• Hammer/Hanging Man
  
• Bearish Harami/Bullish Harami
  
• SBearish Meeting Lines/Bullish Meeting Lines
  

mit der Bestätigung durch Handelssignale der Oszillatoren Stochastic, CCI, MFI und RSI.

In den weiteren Veröffentlichungen werden Beispiele für die Umsetzung von Modulen der Handelssignale angeführt, die auf den beschriebenen Mustern beruhen.