MQL5 Wizard - Classe di modelli Candlestick - libreria per MetaTrader 5

La MQL5 Wizard consente di creare Expert Advisor già pronti basati sulle classi della libreria Standard fornite insieme al terminale client. Consente di verificare rapidamente le tue idee di trading, tutto ciò di cui hai bisogno è creare la tua classe di segnali di trading. La struttura di questa classe ed esempio può essere trovata nell'articolo MQL5 Wizard: How to Create a Module of Trading Signals .

L'idea generica è la seguente: la classe dei segnali di trading è derivata da CExpertSignal , la successiva, è necessario sovrascrivere i metodi virtuali LongCondition() e ShortCondition() con i propri metodi.

C'è un libro "Strategie dei migliori trader " (in russo), ci sono molte strategie di trading che sono considerate lì, ci concentreremo sui modelli di candele di inversione, confermati dagli oscillatori Stochastic , CCI , MFI e RSI .

Il modo migliore è creare la classe separata, derivata da CExpertSignal per il controllo della formazione di pattern di candele. Per la conferma dei segnali di trading, generati da modelli di candlestick, è sufficiente scrivere la classe, derivata da CCandlePattern e aggiungere lì le caratteristiche necessarie (ad esempio, conferma da oscillatori).

Qui considereremo la classe CCandlePattern, che consente di semplificare la creazione di classi di segnali di trading con modelli di candele per MQL5 Wizard.

CCandlePattern class

La classe CCandlePattern è derivata dalla classe CExpertSignal (classe base dei segnali di trading)

class CCandlePattern : public CExpertSignal
  {
protected:
   //--- indicators
   CiMA              m_MA;
   //--- time series
   CiOpen            m_open;
   CiHigh            m_high;
   CiLow             m_low;
   CiClose           m_close;
   //--- input parameters
   int               m_ma_period;

public:
   //--- constructor
                     CCandlePattern();
   //--- method of input parameter setting
   void              MAPeriod(int period)             { m_ma_period=period;                 } 
   //--- initialization methods
   virtual bool      ValidationSettings();
   virtual bool      InitIndicators(CIndicators *indicators);

   //--- check formation of a certain candlestick pattern
   bool              CheckCandlestickPattern(ENUM_CANDLE_PATTERNS CandlePattern);
   //--- check formation of bullish/bearish candlestick pattern
   bool              CheckPatternAllBullish();
   bool              CheckPatternAllBearish();

protected:
   //--- initialization of indicators and time series
   bool              InitMA(CIndicators *indicators);
   bool              InitOpen(CIndicators *indicators);
   bool              InitHigh(CIndicators *indicators);
   bool              InitLow(CIndicators *indicators);
   bool              InitClose(CIndicators *indicators);
   //--- methods, used for candlestick checking
   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))); }
   //--- methods for checking of a certain candlestick model
   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();
  };

Utilizzo di CCandlePattern nelle classi di segnali di trading per MQL5 Wizard

La classe CCandlePattern può essere utilizzata come classe madre per le classi di segnali di trading per MQL5 Wizard. E' necessario derivare la classe del segnale di trading dalla classe CCandlePattern, inoltre è necessario aggiungere metodi per il controllo dell'apertura/chiusura delle posizioni long/short (oltre agli indicatori, ecc...).

La formazione di un modello di candela di inversione può essere utilizzata come segnale di trading, ma è meglio controllare la conferma (ad esempio, utilizzando gli oscillatori).

• bool CheckOpenLong(double &price,double &sl,double &tp,datetime &expiration) - Checks conditions of long position opening;
  
• bool CheckCloseLong(double &price)  - Checks conditions of long position closing;
  
• bool CheckOpenShort(double &price,double &sl,double &tp,datetime &expiration) - Checks conditions of short position opening;
  
• bool CheckCloseShort(double &price) - Checks conditions of short position closing;

//+------------------------------------------------------------------+
//|                                          CSampleCandleSignal.mqh |
//+------------------------------------------------------------------+
// include CCandlePattern class
// the candlepatterns.mqh must be located in the same folder
#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:
   //--- indicators
   ....
   //--- input parameters
   ...
public:
   //--- constructor
                     CTestClass();
   //--- methods for setting of input parameters
   ...
   //--- initialization of indicators and time series/checking of input parameters
   virtual bool      ValidationSettings();
   virtual bool      InitIndicators(CIndicators *indicators);
   //--- checking of trade signals
   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:
   //--- methods of indicators initialization
   ...
   //--- methods for access to indicator's values
   ...
  };

I dettagli sulla struttura delle classi di segnali di trading, utilizzate in MQL5 Wizard, possono essere trovati nell'articolo MQL5 Wizard: How to Create a Module of Trading Signals .

Dai un'occhiata alla riga:

//| Parameter=MAPeriod,int,12                                        |

nella sezione di descrizione della MQL5 Wizard.

Il metodo MAPeriod viene utilizzato nella classe madre CCandlePattern per il calcolo del prezzo medio di chiusura e dei valori medi del corpo della candela. Per impostazione predefinita, m_ma_period=12 è impostato nel costruttore di classi CCandlePattern(). Tuttavia, è meglio impostarlo utilizzando il parametro di input, ti consentirà di utilizzarlo in Strategy Tester di MetaTrader 5.

Non dimenticare di chiamare ValidationSettings() e InitIndicators() della classe madre

È meglio chiamare prima questi metodi:

//| Parameter=MAPeriod,int,12                                        |

nella sezione di descrizione del MQL5 wizard.

Il metodo MAPeriod è usato nella classe madre CCandlePattern per il calcolo del prezzo medio di chiusura e dei valori medi del corpo della candela. Per default, m_ma_period=12 è impostato nel costruttore della classe CCandlePattern(). Tuttavia, è meglio impostarlo usando il parametro di input, vi permetterà di usarlo in Strategy Tester of MetaTrader 5.

Non dimenticare di chiamare ValidationSettings() e InitIndicators() della classe madre

È meglio chiamare prima questi metodi:

bool CSampleCandleSignal ::ValidationSettings()
  {
//--- call of ValidationSettings of parent CCandlePattern class
   if(!CCandlePattern::ValidationSettings()) return(false);
//--- your code
..
//--- ok
   return(true);
  }

Lo stesso vale per il metodo InitIndicators():

bool CSampleCandleSignal ::InitIndicators(CIndicators *indicators)
  {
//--- call of InitIndicators of parent CCandlePattern class 
   if (!CCandlePattern::InitIndicators(indicators)) return ( false );   
//--- your code
...
//--- ok 
   return ( true );
  }

Controllo dei modelli di candele

Per verificare la formazione di un determinato pattern candlestick è necessario chiamare il metodo CheckCandlestickPattern(ENUM_CANDLE_PATTERNS CandlePattern) con pattern, passato alla funzione.

Inoltre puoi controllare la formazione di uno dei pattern candlestick rialzisti/ribassisti utilizzando i metodi CheckPatternAllBullish() e CheckPatternAllBearish().

Per semplificare il lavoro dei modelli di candele, viene utilizzata l'enumerazione ENUM_CANDLE_PATTERNS:

enum ENUM_CANDLE_PATTERNS  // candlestick patterns list
  {
   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
  };

Controllo dei modelli di candele rialziste:

///--- Controlla la formazione del modello "3 Soldati Bianchi" :
  CheckCandlestickPattern(CANDLE_PATTERN_THREE_WHITE_SOLDIERS)

///--- Verifica la formazione del pattern "Piercing Line" :
  CheckCandlestickPattern(CANDLE_PATTERN_PIERCING_LINE)

///--- Verifica la formazione del pattern "Morning Doji" :
  CheckCandlestickPattern(CANDLE_PATTERN_MORNING_DOJI)

///--- Verifica la formazione del pattern "Bullish Engulfing" :
  CheckCandlestickPattern(CANDLE_PATTERN_BULLISH_ENGULFING)

///--- Controlla la formazione del modello "Bullish Haramii" :
  CheckCandlestickPattern(CANDLE_PATTERN_BULLISH_HARAMI)

///--- Verifica la formazione del pattern "Morning Star" :
  CheckCandlestickPattern(CANDLE_PATTERN_MORNING_STAR)

///--- Verifica la formazione del pattern "Bullish Meeting Lines" :
  CheckCandlestickPattern(CANDLE_PATTERN_BULLISH_MEETING_LINES)

///--- Verifica la formazione del pattern "Hammer" :
  CheckCandlestickPattern(CANDLE_PATTERN_HAMMER)

///--- Controlla la formazione di uno dei pattern di candele rialziste
  CheckPatternAllBullish();

Controllo dei modelli di candele ribassiste:

///--- Controlla la formazione del pattern "3 Black Crows":
  CheckCandlestickPattern(CANDLE_PATTERN_THREE_BLACK_CROWS)

///--- Verifica la formazione del pattern "Dark Cloud Cover" :
  CheckCandlestickPattern(CANDLE_PATTERN_DARK_CLOUD_COVER)

///--- Verifica la formazione del pattern "Evening Doji" :
  CheckCandlestickPattern(CANDLE_PATTERN_EVENING_DOJI)

///--- Controlla la formazione del pattern "Bearish Engulfing" :
  CheckCandlestickPattern(CANDLE_PATTERN_BEARISH_ENGULFING)

///--- Controlla la formazione del modello "Evening Star" :
  CheckCandlestickPattern(CANDLE_PATTERN_EVENING_STAR)

///--- Controlla la formazione del modello "Hanging Man" :
  CheckCandlestickPattern(CANDLE_PATTERN_HANGING_MAN)

///--- Controlla la formazione del modello "Bearish Harami" :
  CheckCandlestickPattern(CANDLE_PATTERN_BEARISH_HARAMI)

///--- Verifica la formazione del pattern "Bearish Meeting Lines" :
  CheckCandlestickPattern(CANDLE_PATTERN_BEARISH_MEETING_LINES)

///--- Controlla la formazione di uno dei pattern ribassisti
  CheckPatternAllBearish();

Ecco alcuni esempi di utilizzo dei metodi:

1. Aprire una posizione long

//+------------------------------------------------------------------+
//| Checking condition of long position opening                      |
//+------------------------------------------------------------------+
bool CSampleCandleSignal::CheckOpenLong(double &price,double &sl,double &tp,datetime &expiration)
  {
//--- check conditions to open long position
//--- it's better to use this code in addition to indicator's checking
//--- for example, let's check formation of "3 white soldiers" pattern:
   if CheckCandlestickPattern(CANDLE_PATTERN_THREE_WHITE_SOLDIERS) return(true):
//--- no signal
   return(false);
  }

2. Chiudere la posizione long

//-------------------------------------------------------------------+
//| Checking condition of long position closing                      |
//+------------------------------------------------------------------+
bool CSampleCandleSignal::CheckCloseLong(double &price)
  {
//--- check conditions to close long position
//--- for example, let's check formation of one of the bearish pattern:
   if CheckPatternAllBearish() return(true):
//--- no signal
   return(false);
  }

3. Aprire una posizione short

//-------------------------------------------------------------------+
//| Checking condition of short position opening                     |
//+------------------------------------------------------------------+
bool CSampleCandleSignal::CheckOpenShort(double &price,double &sl,double &tp,datetime &expiration)
  {
//--- check conditions to open short position
//--- it's better to use this code in addition to indicator's checking
//--- for example, let's check formation of "3 black crows" pattern:
    if CheckCandlestickPattern(CANDLE_PATTERN_THREE_BLACK_CROWS) return(true):
//--- no signal
   return(false);
  }

4. Chiudere la posizione short

//-------------------------------------------------------------------+
//| Checking condition of short position closing                     |
//+------------------------------------------------------------------+
bool CSampleCandleSignal::CheckCloseShort(double &price)
  {
//--- check conditions to close short position
//--- it's better to use this code in addition to indicator's checking
//--- for example, let's check formation of one of the bullish pattern:
   if CheckPatternAllBullish() return(true):
//--- no signal
   return(false);
  }

Raccomandazioni

Per ridurre i falsi segnali, i modelli di candele di inversione devono essere confermati da altri indicatori, come gli oscillatori.

I seguenti modelli sono considerati nel libro "Strategie dei migliori trader":

• 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
  
• Bearish Meeting Lines/Bullish Meeting Lines
  

confermato da oscillatori Stochastic , CCI , MFI e RSI .

Successivamente forniremo le classi di segnali di trading da utilizzare in MQL5 Wizard.