Wizard MQL5: Come creare un modulo di trailing delle posizioni aperte
110
0
Introduzione
MetaTrader 5 possiede un potente strumento per il controllo rapido delle idee di trading. Questo è il generatore di strategie dii trading Wizard MQL5. L'utilizzo del Wizard MQL5 per la creazione automatica del codice sorgente di Experts Advisor è descritto nell’articolo "Wizard MQL5: Creating Expert Advisors without Programming". L'apertura del sistema di generazione del codice consente di integrare le classi standard con classi personalizzate di segnali di trading, sistemi di gestione del denaro e moduli finali.
Questo articolo descrive i principi di scrittura dei moduli di posizione finale aperta per il loro ulteriore utilizzo nel Wizard MQL5.
Un Expert Advisor creato utilizzando il Wizard MQL5 si basa su quattro classi base:
Figura 1. Struttura della classe base CExpert.
La classe CExpert (o la sua sottoclasse) è il "motore" principale del robot di trading. L'istanza della classe CExpert contiene istanze delle classi CExpertSignal, CExpertMoney e CExpertTrailing (o le loro sottoclassi):
- CExpertSignal è il principale generatore di segnali di trading. L'istanza della sottoclasse CExpertSignal inclusa nella classe CExpert fornisce all'Expert Advisor le informazioni circa le possibilità di ingresso nel mercato, i livelli di ingresso e l'impostazione degli ordini di protezione sulla base di algoritmi interni. La decisione finale sull'esecuzione delle operazioni trading è presa dall'Expert Advisor. Puoi leggere come scrivere un modulo di segnali di trading nell’articolo "Il Wizard MQL5: Come creare un modulo di segnali di trading".
- CExpertMoney è il principale sistema di gestione del denaro e del rischio. L'istanza della sottoclasse CExpertMoney calcola i volumi di posizione da aprire e gli ordini in sospeso da inserire. La decisione finale sui volumi spetta all'Expert Advisor. I principi di sviluppo dei moduli di gestione del denaro e del rischio sono descritti nell’articolo "Il Wizard MQL5: Come creare un modulo di gestione del rischio e del denaro".
- CExpertTrailing è il modulo principale per seguire le posizioni aperte. L'istanza della sottoclasse CExpertTrailing comunica all'Expert Advisor se è necessario modificare gli ordini di protezione di una posizione. La decisione finale sulla modifica dell'ordine è presa dall'Expert Advisor.
Oltre a questo, le seguenti istanze di classe sono i membri della classe CExpert:
- CExpertTrade (per l'esecuzione di operazioni commerciali)
- CIndicators (per la gestione degli indicatori e delle serie temporali utilizzate nel funzionamento dell'Expert Advisor)
- CSymbolInfo (per ottenere le informazioni su un simbolo)
- CAccountInfo (per ottenere informazioni sullo stato del conto di trading)
- CPositionInfo (per ottenere informazioni sulle posizioni)
- COrderInfo (per ottenere informazioni sugli ordini in sospeso)
Più avanti in questo articolo, per "Expert Advisor" si intenderà un'istanza della classe CExpert della sua sottoclasse.
Una descrizione più dettagliata della classe CExpert e del processo di utilizzo verrà fornita in un altro articolo.
1. Classe base CExpertTrailing
CExpertTrailing è la base del modulo delle seguenti posizioni aperte. Per interagire con lo "spazio esterno", la classe CExpertTrailing dispone di un insieme di metodi virtuali pubblici:
| Inizializzazione | Descrizione |
| virtual Init | L'inizializzazione dell'istanza di classe prevede la sincronizzazione dei dati del modulo con i dati dell'EA |
| virtual ValidationSettings | Convalida dei parametri impostati |
| virtual InitIndicators | Creazione e inizializzazione di tutti gli indicatori e le serie temporali necessarie per il funzionamento del generatore di segnali di trading |
| Segnali di modifica delle posizioni |
|
| virtual CheckTrailingStopLong | Generazione di un segnale per la modifica di una posizione long con determinazione del nuovo prezzo per l'ordine Stop |
| virtual CheckTrailingStopShort | Generazione di un segnale per la modifica di una posizione short con determinazione del nuovo prezzo per l'ordine Stop |
Descrizione dei metodi
1.1. Metodi di inizializzazione
1.1.1 Init
Il metodo Init() viene chiamato automaticamente subito dopo aver aggiunto l'istanza della classe all'Expert Advisor. Non è richiesta la riscrittura del metodo.
virtual bool Init(CSymbolInfo* symbol, ENUM_TIMEFRAMES period, double adjusted_point);
1.1.2 ValidationSettings
Il metodo ValidationSettings() viene chiamato dall'Expert Advisor dopo aver impostato tutti i parametri. È necessario riscrivere il metodo se sono presenti impostazioni di configurazione.
virtual bool ValidationSettings();
Il metodo riscritto deve restituire true se tutti i parametri sono corretti (adatti per l'uso). Se uno dei parametri non è valido, il parametro deve restituire false (l'ulteriore operazione è impossibile).
1.1.3 InitIndicators
Il metodo InitIndicators() crea e inizializza tutti gli indicatori e le serie temporali richiesti. Viene chiamato dall'Expert Advisor dopo che tutti i parametri sono stati impostati e convalidati. Il metodo deve essere ignorato nel caso in cui il generatore di segnali di trading utilizzi almeno un indicatore o delle serie temporali.
virtual bool InitIndicators(CIndicators* indicators);
Gli indicatori e/o le serie temporali devono essere utilizzati tramite il corrispondente della Libreria Standard. I puntatori di tutti gli indicatori e/o le serie temporali devono essere aggiunti alla raccolta di indicatori dell'Expert Advisor (puntatore a cui viene passato come parametro).
Il metodo riscritto deve restituire true se tutte le manipolazioni con gli indicatori e/o le serie temporali hanno avuto successo (sono adatti per l'uso). Se almeno un'operazione con gli indicatori e/o le serie temporali fallisce, il metodo deve restituire false (l'ulteriore operazione è impossibile).
1.2. Metodi di controllo del segnale di modifica della posizione
1.2.1 CheckTrailingStopLong
Il metodo CheckTrailingStopLong() genera un segnale di modifica di una posizione long, definendo un nuovo prezzo dell'ordine Stop Loss (oltre che per l'ordine Take Profit se necessario). Viene chiamato dall'Expert Advisor per determinare se è necessario modificare una posizione long. Deve essere riscritto se si desidera generare un segnale di modifica di una posizione long.
virtual bool CheckTrailingStopLong(CPositionInfo* position,double& sl,double& tp)
Il metodo deve implementare l'algoritmo di verifica della condizione di modifica della posizione long. Se la condizione è soddisfatta, alla variabile sl (oltre a tp, se necessario) deve essere assegnato il valore appropriato e il metodo deve restituire true. I collegamenti alle variabili sl e tp devono essere passati come parametri. Se la condizione non è soddisfatta, il metodo deve restituire false.
1.2.2 CheckTrailingStopShort
Il metodo CheckTrailingStopShort() genera un segnale di modifica della posizione short, determinando un nuovo prezzo dell'ordine Stop Loss (oltre che dell'ordine Take Profit, se necessario). Viene chiamato dall'Expert Advisor per determinare se è necessario modificare una posizione short. Il metodo deve essere sovrascritto se si desidera generare un segnale di una modifica della posizione short.
virtual bool CheckTrailingStopShort(CPositionInfo* position,double& sl,double& tp)
Il metodo deve implementare l'algoritmo di verifica della condizione per modificare una posizione short. Se la condizione è soddisfatta, alla variabile sl (oltre a tp, se necessario) deve essere assegnato il valore appropriato e il metodo deve restituire true. I collegamenti alle variabili sl e tp devono essere passati come parametri. Se la condizione non è soddisfatta, il metodo deve restituire false.
2. Scrivere il proprio modulo per seguire le posizioni aperte
Adesso, dopo aver rivisto la struttura della classe base CExpertTrailing, puoi iniziare a creare il tuo modulo per seguire le posizioni aperte.
Come accennato in precedenza, la classe CExpertTrailing è un insieme di "ropes" virtuali pubbliche, ovvero dei metodi attraverso il cui utilizzo l'Expert Advisor può conoscere l'opinione del modulo delle posizioni aperte finali sulla necessità di modifica degli ordini di protezione.
Pertanto, il nostro obiettivo principale è creare una nostra classe per seguire le posizioni aperte, derivandola dalla classe CExpertTrailing e riscrivendo i metodi virtuali appropriati, implementando gli algoritmi richiesti.
Il nostro secondo obiettivo (non meno importante) è rendere la nostra classe "visibile" al Wizard MQL5. Ma andiamo con ordine.
2.1. Creare la classe di generatori di segnali di trading
Cominciamo.
Innanzitutto, creiamo (ad esempio, utilizzando lo stesso Wizard MQL5) un file include con l'estensione mqh.
Vai su File e seleziona "Create" (o digita la combinazione Ctrl+N) e indica la creazione di un file include:
Figura 2. Crea un file include utilizzando il Wizard MQL5.
Da notare che affinché il file venga poi "rilevato" dal Wizard MQL5 come modulo di posizioni aperte finali, deve essere creato nella cartella Include\Expert\.
Per cestinarlo nella Libreria Standard, crea la nostra cartella Include\Expert\Trailing\MyTrailing, in cui creiamo il file SampleTrailing.mqh, specificando questi parametri in МQL5 Wizard:
Figura 3. Impostare la posizione del file include.
Come risultato dell'operazione Wizard MQL5 abbiamo il seguente schema:
//+------------------------------------------------------------------+ //| SampleTrailing.mqh | //| Copyright 2010, MetaQuotes Software Corp. | //| https://www.mql5.com | //+------------------------------------------------------------------+ #property copyright "Copyright 2010, MetaQuotes Software Corp." #property link "https://www.mql5.com" //+------------------------------------------------------------------+ //| defines | //+------------------------------------------------------------------+ // #define MacrosHello "Hello, world!" // #define MacrosYear 2010 //+------------------------------------------------------------------+ //| DLL imports | //+------------------------------------------------------------------+ // #import "user32.dll" // int SendMessageA(int hWnd,int Msg,int wParam,int lParam); // #import "my_expert.dll" // int ExpertRecalculate(int wParam,int lParam); // #import //+------------------------------------------------------------------+ //| EX5 imports | //+------------------------------------------------------------------+ // #import "stdlib.ex5" // string ErrorDescription(int error_code); // #import //+------------------------------------------------------------------+
Quello che segue è soltanto un lavoro da svolgere "manualmente". Rimuovi le parti non necessarie e aggiungi ciò che ti occorre (includi il file ExpertTrailing.mqh della Libreria Standard e una descrizione della classe che ora è vuota).
//+------------------------------------------------------------------+ //| SampleTrailing.mqh | //| Copyright 2010, MetaQuotes Software Corp. | //| https://www.mql5.com | //+------------------------------------------------------------------+ #property copyright "Copyright 2010, MetaQuotes Software Corp." #property link "https://www.mql5.com" //+------------------------------------------------------------------+ //| include files | //+------------------------------------------------------------------+ #include <Expert\ExpertTrailing.mqh> //+------------------------------------------------------------------+ //| Class CSampleTrailing. | //| Purpose: Class for trailing of open positions. | //| Is derived from the CExpertTrailing class. | //+------------------------------------------------------------------+ class CSampleTrailing : public CExpertTrailing { }; //+------------------------------------------------------------------+
Ora è necessario scegliere gli algoritmi.
Prendiamo il seguente algoritmo come base del nostro modulo di posizioni aperte finali: sposta l'ordine Stop a un livello senza perdite, se il prezzo va nella direzione richiesta di una distanza specificata. Rifletti ciò nel nostro file.
//+------------------------------------------------------------------+ //| SampleTrailing.mqh | //| Copyright 2010, MetaQuotes Software Corp. | //| https://www.mql5.com | //+------------------------------------------------------------------+ #property copyright "Copyright 2010, MetaQuotes Software Corp." #property link "https://www.mql5.com" //+------------------------------------------------------------------+ //| include files | //+------------------------------------------------------------------+ #include <Expert\ExpertTrailing.mqh> //+------------------------------------------------------------------+ //| Class CSampleTrailing. | //| Purpose: Class for trailing of open positions by | //| moving the Stop order "to the loseless level". | //| Is derived from the CExpertTrailingclass. | //+------------------------------------------------------------------+ class CSampleTrailing : public CExpertTrailing { }; //+------------------------------------------------------------------+
Adesso, definiamo quali dati sono necessari per prendere decisioni in merito alla modifica degli ordini di protezione. Nel nostro caso è il profitto di una posizione modificata in punti.
Definisci l'elenco dei parametri di impostazione del nostro modulo per le seguenti posizioni aperte. Abbiamo bisogno di due parametri:
- Il numero di punti di profitto della posizione necessari per suggerire di spostare l'ordine Stop a un livello senza perdite.
- Il livello senza perdite, ovvero quanti punti di profitto fissiamo dall'ordine Stop spostato.
Le impostazioni del modulo verranno archiviate sui dati membri protetti della classe. L'accesso alle impostazioni sarà attuato attraverso apposite modalità pubbliche.
Includiamo queste modifiche nel nostro file:
//+------------------------------------------------------------------+ //| SampleTrailing.mqh | //| Copyright 2010, MetaQuotes Software Corp. | //| https://www.mql5.com | //+------------------------------------------------------------------+ #property copyright "Copyright 2010, MetaQuotes Software Corp." #property link "https://www.mql5.com" //+------------------------------------------------------------------+ //| include files | //+------------------------------------------------------------------+ #include <Expert\ExpertTrailing.mqh> //+------------------------------------------------------------------+ //| Class CSampleTrailing. | //| Purpose: Class for trailing of open positions | //| by moving Stop order to a lossless level. | //| Is derived from the CExpertTrailing class. | //+------------------------------------------------------------------+ class CSampleTrailing : public CExpertTrailing { protected: int m_profit; //threshold level of profit int m_stop_level; // lossless level public: //--- methods of setting adjustable parameters void Profit(int value) { m_profit=value; } void StopLevel(int value) { m_stop_level=value; } }; //+------------------------------------------------------------------+
Per inizializzare i parametri regolabili con valori predefiniti, è necessario aggiungere il costruttore della classe.
Per convalidare le impostazioni, sovrascrivere il metodo virtuale ValidationSettings (secondo la descrizione della classe base).
Descrizione della classe:
//+------------------------------------------------------------------+ //| SampleTrailing.mqh | //| Copyright 2010, MetaQuotes Software Corp. | //| https://www.mql5.com | //+------------------------------------------------------------------+ #property copyright "Copyright 2010, MetaQuotes Software Corp." #property link "https://www.mql5.com" //+------------------------------------------------------------------+ //| include files | //+------------------------------------------------------------------+ #include <Expert\ExpertTrailing.mqh> //+------------------------------------------------------------------+ //| Class CSampleTrailing. | //| Purpose: Class for trailing of open positions | //| by moving Stop order to a lossless level. | //| Is derived from the CExpertTrailing class. | //+------------------------------------------------------------------+ class CSampleTrailing : public CExpertTrailing { protected: int m_profit; // threshold level of profit int m_stop_level; // lossless level public: CSampleTrailing(); //--- methods of setting adjustable parameters void Profit(int value) { m_profit=value; } void StopLevel(int value) { m_stop_level=value; } //--- method of validating the adjustable parameters virtual bool ValidationSettings(); }; //+------------------------------------------------------------------+
Implementazione del metodo ValidationSettings():
//+------------------------------------------------------------------+ //| Validation of adjustable parameters. | //| INPUT: no. | //| OUTPUT: true if parameter are correct, false - if not. | //| REMARK: no. | //+------------------------------------------------------------------+ bool CSampleTrailing::ValidationSettings() { if(!CExpertTrailing::ValidationSettings()) return(false); //--- check wheter the Init method is called if(m_symbol==NULL) return(false); //--- check parameters if((m_profit-m_stop_level)*m_adjusted_point<=m_symbol.StopsLevel()*m_symbol.Point() && m_profit!=0.0) { printf(__FUNCTION__+": threshold level of profit must be greater than the level of setting of orders"); return(false); } //--- ok return(true); }
Tutti i lavori preparatori sono stati completati.
Prendiamo di nuovo in considerazione i nostri algoritmi in modo più dettagliato.
1. Un segnale per la modifica di una posizione long appare quando sono soddisfatte le seguenti condizioni:
- I parametri delle impostazioni del modulo implicano che la posizione deve essere modificata (se imposti Profit=0, la modifica non verrà eseguita);
- La posizione non è stata ancora modificata (l'ordine stop non è stato spostato a un livello senza perdite);
- Il profitto della posizione ha superato un livello di soglia impostato nei parametri.
In questo caso, è consigliabile modificare l'ordine Stop in base alle impostazioni. A tal fine, riscrivi il metodo virtuale CheckTrailingStopLong e compilalo con la funzionalità corrispondente.
2. Un segnale di modifica della posizione short appare quando sono soddisfatte le seguenti condizioni:
- I parametri delle impostazioni del modulo implicano che la posizione deve essere modificata (se imposti Profit=0, la modifica non verrà eseguita);
- La posizione non è stata ancora modificata (l'ordine stop non è stato spostato a un livello senza perdite);
- Il profitto della posizione ha superato un livello di soglia impostato nei parametri.
In questo caso, è consigliabile modificare l'ordine Stop in base alle impostazioni. A tal fine, riscrivi il metodo virtuale CheckTrailingStopShort e compilalo con la funzionalità corrispondente.
Descrizione della classe:
class CSampleTrailing : public CExpertTrailing { protected: int m_profit; // threshold level of profit int m_stop_level; // lossless level public: CSampleTrailing(); //--- methods of setting adjustable parameters void Profit(int value) { m_profit=value; } void StopLevel(int value) { m_stop_level=value; } //--- method of validation of adjustable parameters virtual bool ValidationSettings(); //--- methods of generation of position modification signals virtual bool CheckTrailingStopLong(CPositionInfo* position,double& sl,double& tp); virtual bool CheckTrailingStopShort(CPositionInfo* position,double& sl,double& tp); };
Implementazione dei metodi CheckTrailingStopLong e CheckTrailingStopShort:
//+------------------------------------------------------------------+ //| Check for modification of stop orders of a long position. | //| INPUT: position - pointer to a position object, | //| sl - link for a new price of stop loss order, | //| tp - link for a new price of take profit order. | //| OUTPUT: true if condition is satisfied, false - if not. | //| REMARK: no. | //+------------------------------------------------------------------+ bool CSampleTrailing::CheckTrailingStopLong(CPositionInfo* position,double& sl,double& tp) { //--- check of pointer if(position==NULL) return(false); //--- check of parameter if(m_profit==0.0) return(false); //--- already in a lossless zone? double open=position.PriceOpen(); if(position.StopLoss()>=open) return(false); //--- check of profit sl=EMPTY_VALUE; tp=EMPTY_VALUE; if(m_symbol.Bid()-open>m_profit*m_adjusted_point) sl=m_symbol.NormalizePrice(open+m_stop_level*m_adjusted_point); //--- return(sl!=EMPTY_VALUE); } //+------------------------------------------------------------------+ //| Check for modification of stop orders of a short position. | //| INPUT: position - pointer to a position object, | //| sl - link to a new price of stop loss order, | //| tp - link to a new price of take profit order. | //| OUTPUT: true if condition is satisfied, false - if not. | //| REMARK: нет. | //+------------------------------------------------------------------+ bool CSampleTrailing::CheckTrailingStopShort(CPositionInfo* position,double& sl,double& tp) { //--- check of pointer if(position==NULL) return(false); //--- check of parameter if(m_profit==0.0) return(false); //--- already in a lossless zone? double open=position.PriceOpen(); if(position.StopLoss()<=open) return(false); //--- check of profit sl=EMPTY_VALUE; tp=EMPTY_VALUE; if(open-m_symbol.Ask()>m_profit*m_adjusted_point) sl=m_symbol.NormalizePrice(open-m_stop_level*m_adjusted_point); //--- return(sl!=EMPTY_VALUE); }
2.2. Scrivere una descrizione della classe creata dei segnali di trading per il Wizard MQL5
Passiamo ora alla risoluzione del secondo problema. Il nostro modulo di inseguimento delle posizioni aperte deve essere "riconosciuto" dal generatore di strategie di trading Wizard MQL5.
Abbiamo soddisfatto la prima condizione necessaria: abbiamo posizionato il file dove verrà "trovato" dal Wizard MQL5. Ma ciò non è sufficiente. Il Wizard MQL5 non deve solo "trovare" il file, ma anche "riconoscerlo". Per fare ciò dobbiamo aggiungere al testo originale il descrittore di classe per il Wizard MQL5.
Prendiamo in considerazione queste regole.
1. Il blocco di commenti deve iniziare con le seguenti righe:
// wizard description start //+------------------------------------------------------------------+ //| Description of the class |
2. La riga successiva è un descrittore di testo (ciò che vedremo nella procedura guidata MQL5 quando si sceglie il segnale) nel formato "//| Title=<Text> |". Se il testo è troppo grande per una riga, puoi aggiungere dopo quest’ultima un'altra riga (ma non di più). </p>
Nel nostro caso abbiamo quanto segue:
//| Title=Signal on the crossing of a price and the MA | //| entering on its back movement |
3. Ecco che arriva una riga con il tipo di classe specificato nel formato "//| Type=<Type> |". Il campo <Type> deve avere il valore Signal (oltre ai segnali, il Wizard MQL5 conosce altri tipi di classi).
Scrivi:
//| Type=Trailing |
4. La riga seguente nel formato "//| Name=<Name> |" è il nome breve del segnale (viene utilizzato dal Wizard MQL5 per generare i nomi delle variabili globali dell'expert).
Otteniamo quanto segue:
//| Name=BreakEven |
5. Il nome di una classe è un elemento importante della descrizione. Nella riga con il formato "//| Class=<ClassNameа> |", il parametro <ClassName> deve corrispondere al nome della nostra classe:
//| Class=CSampleTrailing |
6. Non compiliamo questa riga, ma deve essere presente (questo è un collegamento alla sezione di riferimento del linguaggio):
//| Page= | 7. Inoltre, ci sono le descrizioni dei parametri delle impostazioni del modulo.
Questo è un insieme di righe (il numero di righe è uguale al numero di parametri).
Il formato di ogni riga è "//| Parameter=<NameOfMethod>,<TypeOfParameter>,<DefaultValue> |".
Ecco il nostro set di parametri:
//| Parameter=Profit,int,20 | //| Parameter=StopLevel,int,0 |
8. Il blocco di commento deve terminare con le seguenti righe:
//+------------------------------------------------------------------+ // wizard description end
Aggiungiamo il descrittore al codice sorgente.
//+------------------------------------------------------------------+ //| SampleTrailing.mqh | //| Copyright 2010, MetaQuotes Software Corp. | //| https://www.mql5.com | //+------------------------------------------------------------------+ #property copyright "Copyright 2010, MetaQuotes Software Corp." #property link "https://www.mql5.com" //+------------------------------------------------------------------+ //| include files | //+------------------------------------------------------------------+ #include <Expert\ExpertTrailing.mqh> // wizard description start //+------------------------------------------------------------------+ //| Description of the class | //| Title=Moving a position to a lossless level | //| Type=Trailing | //| Name=BreakEven | //| Class=CSampleTrailing | //| Page= | //| Parameter=Profit,int,20 | //| Parameter=StopLevel,int,0 | //+------------------------------------------------------------------+ // wizard description end //+------------------------------------------------------------------+ //| Class CSampleTrailing. | //| Purpose: Class for trailing of open positions | //| by moving Stop order to a lossless level. | //| Is derived from the CExpertTrailing class. | //+------------------------------------------------------------------+ class CSampleTrailing : public CExpertTrailing { protected: int m_profit; // threshold level of profit int m_stop_level; // lossless level public: CSampleTrailing(); //--- method of setting adjustable parameters void Profit(int value) { m_profit=value; } void StopLevel(int value) { m_stop_level=value; } //--- method of validation of adjustable settings virtual bool ValidationSettings(); //--- methods of generation of position modification signals virtual bool CheckTrailingStopLong(CPositionInfo* position,double& sl,double& tp); virtual bool CheckTrailingStopShort(CPositionInfo* position,double& sl,double& tp); }; //+------------------------------------------------------------------+ //| Constructor CSampleTrailing. | //| INPUT: no. | //| OUTPUT: no. | //| REMARK: no. | //+------------------------------------------------------------------+ void CSampleTrailing::CSampleTrailing() { //--- setting default values m_profit =20; m_stop_level=0; } //+------------------------------------------------------------------+ //| Check of adjustable parameters. | //| INPUT: no. | //| OUTPUT: true if the parameters are correct, false if not. | //| REMARK: no. | //+------------------------------------------------------------------+ bool CSampleTrailing::ValidationSettings() { //--- what if the Init has not been called? if(m_symbol==NULL) return(false); //--- check of parameters if((m_profit-m_stop_level)*m_adjusted_point<=m_symbol.StopsLevel()*m_symbol.Point() && m_profit!=0.0) { printf(__FUNCTION__+": threshold level of profit must be greater than the level of setting stop orders"); return(false); } //--- ok return(true); } //+------------------------------------------------------------------+ //| Check for modification of stop orders of a long position. | //| INPUT: position - pointer to a position object, | //| sl - link for a new price of stop loss order, | //| tp - link for a new price of take profit order. | //| OUTPUT: true if condition is satisfied, false if not. | //| REMARK: no. | //+------------------------------------------------------------------+ bool CSampleTrailing::CheckTrailingStopLong(CPositionInfo* position,double& sl,double& tp) { //--- check of pointer if(position==NULL) return(false); //--- check of parameters if(m_profit==0.0) return(false); //--- already in a lossless zone? double open=position.PriceOpen(); if(position.StopLoss()>=open) return(false); //--- check of profit sl=EMPTY_VALUE; tp=EMPTY_VALUE; if(m_symbol.Bid()-open>m_profit*m_adjusted_point) sl=m_symbol.NormalizePrice(open+m_stop_level*m_adjusted_point); //--- return(sl!=EMPTY_VALUE); } //+------------------------------------------------------------------+ //| Check for modification of stop orders of a short position. | //| INPUT: position - pointer to a position object, | //| sl - link for a new price of stop loss order, | //| tp - link for a new take profit order. | //| OUTPUT: true if condition is satisfied, false if not. | //| REMARK: no. | //+------------------------------------------------------------------+ bool CSampleTrailing::CheckTrailingStopShort(CPositionInfo* position,double& sl,double& tp) { //--- check of pointer if(position==NULL) return(false); //--- check of parameters if(m_profit==0.0) return(false); //--- already in a lossless zone? double open=position.PriceOpen(); if(position.StopLoss()<=open) return(false); //--- check of profit sl=EMPTY_VALUE; tp=EMPTY_VALUE; if(open-m_symbol.Ask()>m_profit*m_adjusted_point) sl=m_symbol.NormalizePrice(open-m_stop_level*m_adjusted_point); //--- return(sl!=EMPTY_VALUE); } //+------------------------------------------------------------------+
Bene, questo è tutto. Il modulo di trailing è pronto per l'uso.
Affinché il generatore di strategie di trading Wizard MQL5 sia in grado di utilizzare il nostro modulo, dobbiamo riavviare MetaEditor (il Wizard MQL5 esegue la scansione della cartella Include\Expert solo all'inizio).
Dopo aver riavviato MetaEditor, il modulo creato per la gestione delle posizioni aperte può essere utilizzato nel Wizard MQL5:
Figura 5. Il modulo creato per la gestione delle posizioni aperte sul Wizard MQL5.
Sono ora disponibili i parametri di input specificati nella sezione di descrizione dei parametri del modulo per la gestione delle posizioni aperte:
Figura 6. I parametri di input del modulo creato di gestione delle posizioni aperte nel Wizard MQL5.
I migliori valori dei parametri di input della strategia di trading implementata possono essere trovati utilizzando lo Strategy Tester del MetaTrader 5.
Conclusione
Il generatore di strategie di trading del Wizard MQL5 semplifica enormemente il test delle idee di trading. Il codice dell'expert generato si basa sulle classi di strategie di trading della Libreria Standard, le quali vengono utilizzate per creare determinate implementazioni di classi di segnali di trading, classi di gestione del denaro e del rischio e classi di supporto della posizione.
L'articolo parla di come scrivere e connettere al generatore di strategie di trading Wizard MQL5 la tua classe di gestione delle posizioni aperte spostando il livello di Stop Loss a una zona senza perdite quando il prezzo va nella direzione della posizione, consentendo di diminuire i drawdown durante il trading. Descrive anche la struttura e il formato della descrizione della classe creata per il Wizard MQL5.
Tradotto dal russo da MetaQuotes Ltd.
Articolo originale: https://www.mql5.com/ru/articles/231
Il Wizard MQL5: Come creare un modulo di gestione del rischio e del denaro
Gli indicatori dei trend micro, medie e principali
Il Wizard MQL5: Come creare un modulo di segnali di trading
Creare Expert Advisor multipli sulla base dei modelli di trading
- App di trading gratuite
- Oltre 8.000 segnali per il copy trading
- Notizie economiche per esplorare i mercati finanziari
Accetti la politica del sito e le condizioni d’uso