Esplorazione delle classi di strategia di trading della libreria standard. Personalizzazione delle strategie
132
0
Introduzione
Questo articolo è destinato agli utenti principianti che vogliono avvicinarsi a un qualche tipo di personalizzazione con funzionalità e senza scrivere un EA da zero.
Su MetaTrader 5 abbiamo una grande possibilità di trading esperto con una conoscenza (e competenze) minima o nulla sul linguaggio di programmazione e sulla codifica delle sorgenti grazie alla funzionalità unica di MetaEditor: Wizard MQL5. Il Wizard (non spiegheremo il suo funzionamento dettagliato qui in questo articolo) ha lo scopo di generare programmi finiti (file .mq5 e .ex5), algoritmi e codice. Beneficia dell'utilizzo della libreria standard MQL5 e delle sue classi di strategia di trading (che sono grandi risorse).
Ci sono molte classi di strategia di trading presenti nella libreria standard in realtà. Alcune di esse sono già molto buone e provengono da studi più o meno famosi sui mercati finanziari e sull'analisi della redditività. Esiste almeno una strategia per ogni indicatore dal set standard di indicatori fornito con MetaTrader 5.
Per stabilire i segnali di trading da queste classi di strategia di trading, il Wizard MQL5 utilizza un meccanismo che chiama i comportamenti dell'indicatore costituiti da una logica codificata sotto forma di "modelli di trading". E ogni specifico EA generato chiama gli indicatori (tramite istruzioni #include) e i loro set di modelli e decisioni di trading che vengono poi importati nel nucleo di EA ai fini del trading.
Wizard MQL5
Il primo passaggio consiste nel creare un Expert Advisor utilizzando il Wizard MQL5. Per aprire il Wizard MQL5 su MetaEditor, seleziona "New" dal menu "File" o premi il pulsante "New", quindi seleziona l'opzione "Expert Advisor (generate)".
Nominiamo il nostro Expert Advisor generato nel Wizard MQL5 come "MyExpert".
Quindi aggiungiamo due indicatori / segnali per lavorare con esso (puoi selezionare tutte le condizioni che desideri dagli indicatori disponibili). Per il nostro esempio aggiungiamo due famosi indicatori: Indice di forza relativa (RSI) e media mobile (MA). Aggiungi prima l'indicatore RSI e quindi l'indicatore MA.
Possiamo impostare alcuni parametri come vogliamo o lasciare i parametri predefiniti per il nostro esempio.
Dopo aver cliccato su OK e aver continuato con il Wizard, non selezioneremo (per ora) alcun Trailing stop nella finestra successiva, ma se lo desideri puoi aggiungerlo: non influenzerà l'argomento di questo articolo. Nella finestra successiva selezioneremo 5,0 come percentuale di trading e 0,1 lotti o qualsiasi altro parametro tu voglia: ancora una volta, questo non influenzerà l'argomento del nostro articolo.
Analisi del codice generato
Dopo aver terminato avrai il file "MyExpert.mq5". Analizziamo i punti principali del codice generato.
//+------------------------------------------------------------------+ //| MyExpert.mq5 | //| Harvester | //| https://www.mql5.com/en/users/Harvester | //+------------------------------------------------------------------+ #property copyright "Harvester" #property link "https://www.mql5.com/en/users/Harvester" #property version "1.00" //+------------------------------------------------------------------+ //| Include | //+------------------------------------------------------------------+ #include <Expert\Expert.mqh> //--- available signals #include <Expert\Signal\SignalRSI.mqh> #include <Expert\Signal\SignalMA.mqh> //--- available trailing #include <Expert\Trailing\TrailingNone.mqh> //--- available money management #include <Expert\Money\MoneyFixedLot.mqh>
Per prima cosa noterai i file #include aggiunti al codice generato dal Wizard. Possiamo vedere:
- Expert.mqh
- SignalRSI.mq
- SignalMA.mqh
Quindi la seguente parte di codice:
//--- Creating filter CSignalRSI CSignalRSI *filter0=new CSignalRSI; if(filter0==NULL) { //--- failed printf(__FUNCTION__+": error creating filter0"); ExtExpert.Deinit(); return(-3); } signal.AddFilter(filter0);
Come suggerisce il titolo, è il "filtro" che verrà applicato alle condizioni di mercato dell'EA generato che deve essere allegato a un grafico o testato nello Strategy Tester. Il filter0 è quindi il primo filtro con un "indice" pari a zero e per questo primo filtro abbiamo selezionato RSI nel nostro esempio.
CSignalRSI indica la Classe Segnale RSI. Questa classe viene utilizzata per chiamare l'indicatore RSI e applicare ad esso alcune condizioni per la creazione di segnali di acquisto o vendita attraverso l'uso della logica dei modelli del Wizard. RSI quindi è il nostro primo filtro (filtro numero 0).
Nella seguente parte di codice ci sono alcuni parametri del filtro, quindi la sezione Trailing Stop (abbiamo optato per nessun trailing) e, successivamente, la parte di codice che riguarda la gestione del denaro.
Andando avanti, abbiamo:
//--- Tuning of all necessary indicators if(!ExtExpert.InitIndicators()) { //--- failed printf(__FUNCTION__+": error initializing indicators"); ExtExpert.Deinit(); return(-10); } //--- ok return(0); }
Questa sezione appartiene al file include Expert.mqh. Si tratta dell'inizializzazione degli indicatori necessari per il funzionamento di expert.
E l'ultima parte del codice EA generato riguarda la deinizializzazione e gli altri soliti eventi dell’Expert Advisor:
//+------------------------------------------------------------------+ //| Deinitialization function of the expert | //+------------------------------------------------------------------+ void OnDeinit(const int reason) { ExtExpert.Deinit(); } //+------------------------------------------------------------------+ //| "Tick" event handler function | //+------------------------------------------------------------------+ void OnTick() { ExtExpert.OnTick(); } //+------------------------------------------------------------------+ //| "Trade" event handler function | //+------------------------------------------------------------------+ void OnTrade() { ExtExpert.OnTrade(); } //+------------------------------------------------------------------+ //| "Timer" event handler function | //+------------------------------------------------------------------+ void OnTimer() { ExtExpert.OnTimer(); } //+------------------------------------------------------------------+
In realtà, questo EA utilizza due indicatori (RSI e MA) per le decisioni di trading attraverso la libreria standard di classi di trading che utilizzano la logica "filtri" e "pesi". Puoi trovare maggiori informazioni a riguardo nella sezione Moduli di segnali di trading MQL5 Reference. Ma il nostro scopo è quello di utilizzare le nostre strategie di trading come nuovi filtri.
Quindi per il primo passo (utilizzando le nostre strategie di trading) modificheremo leggermente il nostro MyExpert.mq5. Prima di tutto, aggiungiamo un altro filtro. Sarà il filter2 e lo posizioneremo subito dopo la porzione di codice filter1.
//--- Creating filter CSignalCCIxx CSignalCCIxx *filter2=new CSignalCCIxx; if(filter2==NULL) { //--- failed printf(__FUNCTION__+": error creating filter2"); ExtExpert.Deinit(); return(-4); } signal.AddFilter(filter2); //--- Set filter parameters filter2.PeriodCCIxx(Signal_CCIxx_PeriodCCI); filter2.Applied(Signal_CCIxx_Applied); filter2.Weight(Signal_CCIxx_Weight);
Torniamo ai file #include, i quali sono il nucleo dei filtri e del processo decisionale del mercato. Il primo è il file #include <expert\Expert.mqh>. Questo file include, a sua volta, include altri file:
- #include "ExpertBase.mqh"
- #include "ExpertTrade.mqh"
- #include "ExpertSignal.mqh"
- #include "ExpertMoney.mqh"
- #include "ExpertTrailing.mqh"
Questi file include sono rispettivamente la struttura principale dell’EA, la struttura di trading, la gestione del segnale, del denaro e del trailing stop. Non analizzeremo a fondo questi file né li modificheremo. Il nostro scopo è quello di concentrarci sull'aggiunta delle nostre strategie utilizzando gli indicatori esistenti dal set standard di indicatori MetaTrader 5 e aggiungendo il loro file include.
Nel codice MyExpert.mq5 abbiamo i file #include degli indicatori RSI e MA che abbiamo usato in questo esempio come segnali / filtri per la decisione di mercato del trading. A questo punto, aggiungiamo il nostro file include personalizzato. A tale scopo utilizzeremo una versione modificata ("migliorata") di segnali appartenenti all'indicatore CCI.
//+------------------------------------------------------------------+ //| Include | //+------------------------------------------------------------------+ #include <Expert\Expert.mqh> //--- available signals #include <Expert\Signal\SignalRSI.mqh> #include <Expert\Signal\SignalMA.mqh> #include <Expert\Signal\SignalCCIxx.mqh> // This is our own 'custom' indicator for custom Signal management of the EA
Il file SignalCCIxx.mqh deve essere inserito nella cartella \MQL5\Include\Expert\Signal\ e deve corrispondere all'integrabilità del Wizard generato dall’EA, come le altre classi di trading #include della libreria standard, i file di segnale già presenti in questa cartella (SignalRSI.mqh e SignalMA.mqh).
Per questo esempio, copieremo il file CCI originale, ne creeremo un altro chiamato CCIxx con un codice leggermente modificato e lo useremo come file #include. Ora, per semplicità, usiamo solo una versione copiata dell'indicatore CCI dalla libreria standard.
Quello che dobbiamo fare è copiare il file "\MQL5\Include\Expert\Signal\SignalCCI.mqh" nel file "\MQL5\Include\Expert\Signal\SignalCCIxx.mqh". Il modo più semplice per farlo è fare una copia del file nella cartella e quindi rinominarlo.
Diamo un'occhiata a questo file ora. L'integrazione di questo modo 'personalizzato' nel MyExpert.mq5 generato dal Wizard è solo un lavoro finito. Abbiamo aggiunto il codice filter2, come spiegato sopra, e ora completeremo in seguito quanto segue. Quindi non ci concentreremo più sul file MyExpert.mq5, ma d'ora in poi ci concentreremo sul file SignalCCIxx.mqh, il vero nucleo dell'EA grazie al suo segnale di trading filter2 dell'indicatore CCI.
Strategia di personalizzazione
Torniamo ad aggiungere i filtri strategici 'semi-custom' che chiamiamo CCIxx, la versione modificata del SignalCCI.mqh. Lo definisco semi-personalizzato perché in realtà non è un segnale personalizzato totalmente nuovo, ma piuttosto una versione ridisegnata dell'indicatore CCI dal set standard di indicatori che abbiamo con MetaTrader 5. In questo modo, anche gli utenti e i programmatori inesperti possono modificare leggermente modelli e filtri di un EA generato dal Wizard MQL5 utilizzando il gran numero di indicatori esistenti, quindi in altre parole è possibile creare le proprie versioni di filtri e modelli per generare segnali di mercato di acquisto e vendita. Questa è ancora un'ottima base per lavorare con le strategie.
Diamo un'occhiata a questo esempio. Sarà utile per chi ha solo bisogno di questa funzione (per aggiungere alcuni pattern personalizzati agli indicatori esistenti) e per chi vuole partecipare all’ Automated Trading Championship semplicemente utilizzando il Wizard per creare rapidamente un EA completamente funzionale (e valido) che abbia alcuni tipi di personalizzazioni.
Questo può essere ottenuto solo in 1 ora di lavoro, creando un EA Championship-friendly, completamente funzionale, con Trailing Stop, Money Management e tutto il necessario per il trading competitivo. Concentrandosi ancora sul fatto che l'EA è generato dal Wizard Championship-friendly, come l'ho definito io, questo in realtà significa che il codice generato è privo di errori, quindi i partecipanti non devono correggere nulla o temere bug o errori!
L'EA si limita a fare trading e sarà perfetto per il trading, almeno per coloro che vogliono partecipare, ma non conoscono la programmazione e non vogliono ordinare un EA nel servizio Jobs (una bella alternativa per partecipare al campionato). Ci sono molti parametri di input che possono essere assegnati per avere il tuo robot di trading vicino alla strategia che hai in mente.
Ma in realtà puoi utilizzare solo il set standard di indicatori con il set standard di filtri / modelli offerti da MetaQuotes tramite il Wizard e la libreria standard delle classi di strategia di trading. Offre un gran numero di combinazioni e possibilità di trading di successo, in quanto gli indicatori hanno molti parametri (timeframe, simbolo) e tutti i parametri degli indicatori stessi, ad esempio Periodo, Prezzo applicato, ecc. In questo articolo imparerai rapidamente e facilmente come personalizzare e aggiungere modelli / filtri per gli indicatori standard MetaTrader 5.
Continuiamo sul file SignalCCIxx.mqh per personalizzarne e modificarne il comportamento, per creare il nostro modello di trading del segnale CCI (CCIxx). Prima di tutto, nel file MyExpert.mq5 aggiungiamo nuove variabili per il nuovo codice nella sezione di input, come il seguente esempio (vedi codice evidenziato):
//+------------------------------------------------------------------+ //| Inputs | //+------------------------------------------------------------------+ //--- inputs for expert input string Expert_Title ="MyExpert"; // Document name ulong Expert_MagicNumber =26287; // bool Expert_EveryTick =false; // //--- inputs for main signal input int Signal_ThresholdOpen =40; // Signal threshold value to open [0...100] input int Signal_ThresholdClose=60; // Signal threshold value to close [0...100] input double Signal_PriceLevel =0.0; // Price level to execute a deal input double Signal_StopLevel =50.0; // Stop Loss level (in points) input double Signal_TakeLevel =50.0; // Take Profit level (in points) input int Signal_Expiration =4; // Expiration of pending orders (in bars) input int Signal_RSI_PeriodRSI =8; // Relative Strength Index(8,...) Period of calculation input ENUM_APPLIED_PRICE Signal_RSI_Applied =PRICE_CLOSE; // Relative Strength Index(8,...) Prices series input double Signal_RSI_Weight =0.7; // Relative Strength Index(8,...) Weight [0...1.0] input int Signal_MA_PeriodMA =90; // Moving Average(12,0,...) Period of averaging input int Signal_MA_Shift =0; // Moving Average(12,0,...) Time shift input ENUM_MA_METHOD Signal_MA_Method =MODE_SMA; // Moving Average(12,0,...) Method of averaging input ENUM_APPLIED_PRICE Signal_MA_Applied =PRICE_CLOSE; // Moving Average(12,0,...) Prices series input double Signal_MA_Weight =0.6; // Moving Average(12,0,...) Weight [0...1.0] input int Signal_CCIxx_PeriodCCI =8; // Commodity Channel Index(8,...) Period of calculation input ENUM_APPLIED_PRICE Signal_CCIxx_Applied =PRICE_CLOSE; // Commodity Channel Index(8,...) Prices series input double Signal_CCIxx_Weight =0.8; // Commodity Channel Index(8,...) Weight [0...1.0]
Abbiamo modificato i valori delle variabili Signal_RSI_Weight e Signal_MA_Weight rispettivamente da 1,0 a 0,7 e 0,6 e abbiamo aggiunto le righe evidenziate sopra. Per poter lavorare correttamente con i parametri di input per la versione modificata CCIxx del pattern appartenente all'indicatore CCI nelle classi di strategia di trading, abbiamo infatti copiato queste 3 righe di codice dal file SignalCCI.mqh e appena aggiunto il postfix "xx" dopo "CCI".
Nella sezione "protetta" della dichiarazione di classe ci sono molti elementi interessanti:
class CSignalCCI : public CExpertSignal { protected: CiCCI m_cci; // object-oscillator //--- adjusted parameters int m_periodCCI; // the "period of calculation" parameter of the oscillator ENUM_APPLIED_PRICE m_applied; // the "prices series" parameter of the oscillator //--- "weights" of market models (0-100) int m_pattern_0; // model 0 "the oscillator has required direction" int m_pattern_1; // model 1 "reverse behind the level of overbuying/overselling" int m_pattern_2; // model 2 "divergence of the oscillator and price" int m_pattern_3; // model 3 "double divergence of the oscillator and price" //--- variables double m_extr_osc[10]; // array of values of extremums of the oscillator double m_extr_pr[10]; // array of values of the corresponding extremums of price int m_extr_pos[10]; // array of shifts of extremums (in bars) uint m_extr_map; // resulting bit-map of ratio of extremums of the oscillator and the price
Dai un'occhiata ai tipi int chiamati m_pattern. Queste variabili sono progressivamente numerate da 0 a 3, ognuna di esse è un "pattern" o, in altre parole, un modello delle condizioni decisionali del mercato per l'acquisto e la vendita di uno strumento finanziario.
Aggiungeremo 2 modelli personalizzati: m_pattern_4 e m_pattern_5. Ciò avviene semplicemente aggiungendo due righe di codice, due variabili di tipo intero.
//--- "weights" of market models (0-100) int m_pattern_0; // model 0 "the oscillator has required direction" int m_pattern_1; // model 1 "reverse behind the level of overbuying/overselling" int m_pattern_2; // model 2 "divergence of the oscillator and price" int m_pattern_3; // model 3 "double divergence of the oscillator and price" int m_pattern_4; // model 4 "our own first new pattern: values cross the zero" int m_pattern_5; // model 5 "our own second new pattern: values bounce around the zero"
Se continui a guardare il codice, capirai la logica dell'acquisto e della vendita e tutto il resto. Ma ci concentreremo qui solo sulle sezioni sul come aggiungere i nostri modelli, poiché non spiegheremo riga per riga quelli che includono i file (a questo scopo, il lettore può aprire i file stessi e studiarli e c'è anche MQL5 Reference per aiutare nella comprensione).
Vogliamo anche fare questo: nel file CSignalCCIxx.mqh premi CTRL + H, cerca "CCI" e sostituisci con "CCIxx". Fai clic su "Sostituisci tutto": verranno trovate e sostituite 41 occorrenze. Andiamo qui, nella parte superiore del file:
//+------------------------------------------------------------------+ //| Class CSignalCCIxx. | //| Purpose: Class of generator of trade signals based on | //| the 'Commodity Channel Index' oscillator. | //| Is derived from the CExpertSignal class. | //+------------------------------------------------------------------+ class CSignalCCIxx : public CExpertSignal { protected: CiCCIxx m_CCIxx; // object-oscillator
e cambia questo:
protected: CiCCIxx m_CCIxx; // object-oscillator
con questo come nell'originale SignalCCI.mqh:
protected: CiCCI m_CCIxx; // object-oscillator
Lo facciamo perché CiCCI è chiamato da un altro include e, se cambiamo il suo nome, ci saranno diversi errori ovviamente. Ora possiamo compilare il file SignalCCIxx.mqh e dovrebbero esserci 0 errori e 0 avvisi. Se ce ne sono alcuni, è possibile che tu abbia commesso alcuni errori e dovresti ripetere la procedura.
Ora andiamo al nocciolo dell'aggiunta dei nostri pattern. Solo per pura fantasia, aggiungiamo 2 modelli di comportamento di trading del mercato. In totale avremo nuovi 4 segnali (pattern), 2 di un tipo per l'acquisto e 2 di un tipo per la vendita. La porzione da cambiare è questa:
//+------------------------------------------------------------------+ //| Constructor CSignalCCIxx. | //| INPUT: no. | //| OUTPUT: no. | //| REMARK: no. | //+------------------------------------------------------------------+ void CSignalCCIxx::CSignalCCIxx() { //--- initialization of protected data m_used_series=USE_SERIES_HIGH+USE_SERIES_LOW; //--- setting default values for the oscillator parameters m_periodCCIxx =14; //--- setting default "weights" of the market models m_pattern_0 =90; // model 0 "the oscillator has required direction" m_pattern_1 =60; // model 1 "reverse behind the level of overbuying/overselling" m_pattern_2 =100; // model 2 "divergence of the oscillator and price" m_pattern_3 =50; // model 3 "double divergence of the oscillator and price" m_pattern_4 =90; // model 4 "our own first new pattern: " m_pattern_5 =90; // model 5 "our own second new pattern: }
Abbiamo assegnato il valore 90 ai m_pattern_4 e m_pattern_5, ma dovresti (devi) cambiarli con i tuoi: questi sono i pesi che vuoi assegnare ai tuoi nuovi modelli di mercato in quanto influenzano l'intero comportamento di trading dell’Expert Advisor.
Per la fantasia aggiungiamo due nuovi modelli di mercato. Saranno molto semplici: sono solo a scopo educativo e sono segnali di trading non testati, quindi non fare trading con loro. Il mirino titledegli studi di lineatitle ci aiuterà a identificare i valori dell'indicatore CCI nelle figure seguenti per le barre corrispondenti.
Primo modello
Attraversare la linea dello zero dal basso verso l'alto
Questo è il nostro primo modello per: "votare che il prezzo crescerà".
- La Figura 5 mostra il valore CCI che corrisponde alla barra 1 (una barra prima della barra corrente). Il suo valore è 45,16 quindi > 0.
- La Figura 6 mostra il valore CCI che corrisponde alla barra 2 (due barre prima della barra corrente). Il suo valore era -53,92 quindi < 0.
- La linea zero (valore 0,00) dell'indicatore CCI è stata attraversata dal basso verso l'alto entro 2 barre.
Attraversare la linea dello zero dall'alto al basso
Questo è il nostro primo modello per: "votare che il prezzo scenderà".
- Nella Figura 7 viene illustrato il valore CCI che corrisponde alla barra 1 (una barra prima della barra corrente). Il suo valore è -28,49 quindi < 0.
- La Figura 8 mostra il valore CCI che corrisponde alla barra 2 (due barre prima della barra corrente). Il suo valore era 2,41 quindi > 0.
- La linea zero (valore 0,00) dell'indicatore CCI è stata attraversata dall'alto verso il basso entro 2 barre.
Secondo modello
Attraversare la linea dello zero dall'alto verso il basso e tornare indietro sopra
Questo è il nostro secondo modello per: "votare che il prezzo crescerà".
- La Figura 9 mostra il valore CCI che corrisponde alla barra 1 (una barra prima della barra corrente). Il suo valore è 119,06 quindi > 0.
- La Figura 10 mostra il valore CCI che corrisponde alla barra 2 (due barre prima della barra corrente). Il suo valore era -20,38 quindi < 0.
- La Figura 11 mostra il valore CCI che corrisponde alla barra 3 (tre barre prima della barra corrente). Il suo valore era 116,85, quindi > di nuovo 0.
- La linea zero (valore 0,00) dell'indicatore CCI è stata attraversata dall'alto verso il basso. Quindi la linea dell'indicatore CCI è tornata sopra rimbalzando intorno alla linea dello zero entro 3 barre.
Attraversare la linea dello zero dal basso verso l'alto e tornare indietro sotto
Questo è il nostro secondo modello per: "votare che il prezzo scenderà".
- Nella Figura 12 viene illustrato il valore CCI corrispondente alla barra 1 (una barra prima della barra corrente). Il suo valore è -58,72 quindi < 0.
- La Figura 13 mostra il valore CCI che corrisponde alla barra 2 (due barre prima della barra corrente). Il suo valore era 57,65 quindi > 0.
- La Figura 14 mostra il valore CCI che corrisponde alla barra 3 (tre barre prima della barra corrente). Il suo valore era -85,54 quindi < di nuovo 0.
- La linea zero (valore 0,00) dell'indicatore CCI è stata attraversata dal basso verso l'alto. Quindi la linea dell'indicatore CCI è tornata sotto rimbalzando intorno alla linea dello zero entro 3 barre.
Implementazione di modelli
Per implementare queste 4 condizioni (due per modello), dobbiamo modificare la seguente sezione di codice in questo modo. In basso abbiamo aggiunto le righe di codice evidenziate per la condizione "acquista" (vedi sopra nei commenti: "Votare" che il prezzo crescerà).
//+------------------------------------------------------------------+ //| "Voting" that price will grow. | //| INPUT: no. | //| OUTPUT: number of "votes" that price will grow. | //| REMARK: no. | //+------------------------------------------------------------------+ int CSignalCCIxx::LongCondition() { int result=0; int idx =StartIndex(); //--- if(Diff(idx)>0.0) { //--- the oscillator is directed upwards confirming the possibility of price growth if(IS_PATTERN_USAGE(0)) result=m_pattern_0; // "confirming" signal number 0 //--- if the model 1 is used, search for a reverse of the oscillator upwards behind the level of overselling if(IS_PATTERN_USAGE(1) && Diff(idx+1)<0.0 && CCIxx(idx+1)<-100.0) result=m_pattern_1; // signal number 1 //--- if the model 2 or 3 is used, perform the extended analysis of the oscillator state if(IS_PATTERN_USAGE(2) || IS_PATTERN_USAGE(3)) { ExtState(idx); //--- if the model 2 is used, search for the "divergence" signal if(IS_PATTERN_USAGE(2) && CompareMaps(1,1)) // 00000001b result=m_pattern_2; // signal number 2 //--- if the model 3 is used, search for the "double divergence" signal if(IS_PATTERN_USAGE(3) && CompareMaps(0x11,2)) // 00010001b return(m_pattern_3); // signal number 3 } // if the model 4 is used, look for crossing of the zero line if(IS_PATTERN_USAGE(4) && CCIxx(idx+1)>0.0 && CCIxx(idx+2)<0.0) result=m_pattern_4; // signal number 4 // if the model 5 is used, look for the bouncing around the zero line if(IS_PATTERN_USAGE(5) && CCIxx(idx+1)>0.0 && CCIxx(idx+2)<0.0 && CCIxx(idx+3)>0.0) result=m_pattern_5; // signal number 5 } //--- return the result return(result); }
Modifichiamo la sezione di codice corrispondente per la condizione "vendi". In basso abbiamo aggiunto le righe di codice evidenziate per la condizione "vendi" (vedi sopra nei commenti: "Votare" che il prezzo scenderà).
//+------------------------------------------------------------------+ //| "Voting" that price will fall. | //| INPUT: no. | //| OUTPUT: number of "votes" that price will fall. | //| REMARK: no. | //+------------------------------------------------------------------+ int CSignalCCIxx::ShortCondition() { int result=0; int idx =StartIndex(); //--- if(Diff(idx)<0.0) { //--- the oscillator is directed downwards confirming the possibility of falling of price if(IS_PATTERN_USAGE(0)) result=m_pattern_0; // "confirming" signal number 0 //--- if the model 1 is used, search for a reverse of the oscillator downwards behind the level of overbuying if(IS_PATTERN_USAGE(1) && Diff(idx+1)>0.0 && CCIxx(idx+1)>100.0) result=m_pattern_1; // signal number 1 //--- if the model 2 or 3 is used, perform the extended analysis of the oscillator state if(IS_PATTERN_USAGE(2) || IS_PATTERN_USAGE(3)) { ExtState(idx); //--- if the model 2 is used, search for the "divergence" signal if(IS_PATTERN_USAGE(2) && CompareMaps(1,1)) // 00000001b result=m_pattern_2; // signal number 2 //--- if the model 3 is used, search for the "double divergence" signal if(IS_PATTERN_USAGE(3) && CompareMaps(0x11,2)) // 00010001b return(m_pattern_3); // signal number 3 } if(IS_PATTERN_USAGE(4) && CCIxx(idx+1)<0.0 && CCIxx(idx+2)>0.0) result=m_pattern_4; // signal number 4 if(IS_PATTERN_USAGE(5) && CCIxx(idx+1)<0.0 && CCIxx(idx+2)>0.0 && CCIxx(idx+3)<0.0) result=m_pattern_5; // signal number 5 } //--- return the result return(result); }
Il (idx+1) o (idx+2) ... (idx+n) delle ultime righe aggiunte è un punto molto semplice, ma molto importante della domanda: +1, +2, +3, ecc. sono solo il numero di barre che precedono quella attuale (quella attuale è la "candela" effettivamente vivente, la barra 0).
Quindi, più idx + N, più barre indietro andiamo. Ogni barra (idx+n) corrisponde al valore dell'indicatore nella stessa posizione "verticale" sullo stesso intervallo di tempo.
In questa Figura 16, la barra zero (la prima candela più a destra, corrispondente a idx o (idx+0) nel codice) ha il valore CCI corrispondente inferiore a 0,00. Anche la seconda barra (idx+1) e la terza barra (idx+2) hanno valori inferiori alla riga 0,00. Non abbiamo segnalato altre barre con una freccia verticale, ma se passi il mouse sulla 4a barra posteriore (idx + 3), puoi vedere che il suo valore CCI corrispondente è superiore a 0,00.
Per la maggior parte degli utenti questo fatto è ovvio, ma per gli utenti inesperti è meglio sapere come le barre / candele grafiche del grafico dei prezzi, la vista grafica dell'indicatore CCI e rispettivamente la variabile (idx) e il valore dell'indicatore CCIxx corrispondono tra loro.
Questo è importante per visualizzare gli indicatori selezionati su un grafico e cercare di "visualizzare" (o scoprire) le corrispondenze tra barre di prezzo / candele e il comportamento dell'indicatore selezionato, cercando di fare una supposizione per una strategia che si può facilmente codificare utilizzando l'indice a barre (idx) e il valore della variabile indicatore.
Nel file SignalCCIxx.mqh il seguente codice:
CCIxx(idx+1)>0.0 && CCIxx(idx+2)<0.0
scritto a parole significa:
CCI Indicator value (one bar before, named idx+1) is above the zero line of CCI indicator AND CCI Indicator value (two bars before, named idx+2) is below the zero line of CCI indicator
Questo è il più piccolo esempio di come aggiungere semplicemente due modelli personalizzati solo in base al valore dell'indicatore che scegliamo (in questo caso - CCI).
La condizione di "il prezzo crescerà" o "il prezzo scenderà" deve essere scritta e aggiunta nei Modelli in questo modo e nessuno vieta di creare condizioni più complesse. Prima del test finale, diamo un'occhiata ai meccanismi con cui le posizioni vengono aperte e chiuse.
Il meccanismo e la logica sono spiegati molto bene già nel Manuale di riferimento MQL5 nella sezione classi di strategia di trading della libreria standard.
In breve, nel file MyExpert.mq5 abbiamo 2 parametri di input (due variabili intere):
//--- inputs for main signal input int Signal_ThresholdOpen =40; // Signal threshold value to open [0...100] input int Signal_ThresholdClose=60; // Signal threshold value to close [0...100]
Queste soglie per apertura e chiusura sono due valori che vengono utilizzati per il calcolo, se (secondo i nostri modelli di trading) un trade viene aperto long o short e poi chiuso. Le soglie presuppongono un numero di tipo intero da 0 a 100. Cosa significano questi parametri?
Signal_ThresholdOpen è il valore per aprire una posizione long o short, Signal_ThresholdClose è il valore per chiudere una posizione aperta in precedenza. Questi valori sono calcolati nel contesto di un meccanismo semplice, ma brillante, il quale è incollato all'intera logica degli EA generati dal Wizard.
Ogni segnale nei file Signal__.mqh (__ sta per il nome dell'indicatore utilizzato, nel nostro caso, MA, RSI e CCIxx) è costituito da modelli, come abbiamo visto prima in dettaglio. Diamo un'occhiata di nuovo a loro nel nostro esempio. Dal file SignalMA.mqh abbiamo 4 pattern con il loro relativo "peso" per ogni pattern:
//--- setting default "weights" of the market models m_pattern_0 =80; // model 0 "price is on the necessary side from the indicator" m_pattern_1 =10; // model 1 "price crossed the indicator with opposite direction" m_pattern_2 =60; // model 2 "price crossed the indicator with the same direction" m_pattern_3 =60; // model 3 "piercing"
e per RSI dal file SignalRSI.mqh nello stesso modo:
//--- setting default "weights" of the market models m_pattern_0 =70; // model 0 "the oscillator has required direction" m_pattern_1 =100; // model 1 "reverse behind the level of overbuying/overselling" m_pattern_2 =90; // model 2 "failed swing" m_pattern_3 =80; // model 3 "divergence of the oscillator and price" m_pattern_4 =100; // model 4 "double divergence of the oscillator and price" m_pattern_5 =20; // model 5 "head/shoulders"
Nel "nostro" SignalCCIxx.mqh (che è quasi affatto una copia di SignalCCI.mqh) abbiamo questi valori:
//--- setting default "weights" of the market models m_pattern_0 =90; // model 0 "the oscillator has required direction" m_pattern_1 =60; // model 1 "reverse behind the level of overbuying/overselling" m_pattern_2 =100; // model 3 "divergence of the oscillator and price" m_pattern_3 =50; // model 4 "double divergence of the oscillator and price" m_pattern_4 =80; // model 4 "our own first new pattern: " m_pattern_5 =90; // model 5 "our own second new pattern: "
Questi sono gli standard 0, 1, 2, 3 più i nostri modelli 4 e 5 con gli ultimi due valori di 80 e 90. Quando colleghiamo MyExpert.ex5 al grafico o lo testiamo nello Strategy Tester, i modelli di tutti i segnali che abbiamo selezionato (RSI, MA e CCIxx) vengono calcolati continuamente.
Se una o più condizioni del modello hanno successo, il segnale di quel modello viene attivato per il calcolo successivo. Ad esempio, se si verifica m_pattern_4 dal file SignalCCIxx.mqh, dalla condizione:
// if the model 4 is used, look for crossing of the zero line if(IS_PATTERN_USAGE(4) && CCIxx(idx+1)>0.0 && CCIxx(idx+2)<0.0) result=m_pattern_4; // signal number 4
diventa un potenziale segnale di trading. In altre parole, se il valore CCI alla barra 1 è > 0,0 e allo stesso tempo il valore di CCI alla barra 2 era < 0,0, come nella Figura 5 e nella Figura 6, la condizione sta accadendo e il m_pattern_4 (numero di segnale 4) è attivato.
Il valore di peso che abbiamo impostato per questo segnale della nostra strategia CCIxx è pari al valore assoluto di 80, ma assumerà -80 per il caso "votare che il prezzo scenderà" e 80 per il caso "votare che il prezzo crescerà". "Votare che il prezzo scenderà" ha solo messo un segno negativo al valore originale del peso del modello.
Supponendo che la condizione del m_pattern_4 abbia successo, un'operazione viene aperta solo se:
Il segnale numero 4 (m_pattern_4) è l'unico segnale la cui condizione è vera (segnale attivato) E ha raggiunto l'obiettivo di Signal_ThresholdOpen (il suo valore moltiplicato per un coefficiente, ha raggiunto e superato il valore Signal_ThresholdOpen)
Il segnale numero 4 ha raggiunto l'obiettivo di Signal_ThresholdOpen mentre competeva con altri segnali della propria controparte della strategia CCIxx (i segnali /pattern "votare che il prezzo scenderà" della strategia CCIxx) e con tutti gli altri segnali di altri indicatori (segnali RSI e segnali MA) di direzioni opposte (in questo caso la direzione opposta è la direzione breve, perché stiamo analizzando la m_pattern_4 sul "votare che il prezzo crescerà").
Quindi possiamo considerare ogni modello come un concorrente in 2 fazioni: segnali di toro e segnali di orso. Quando questi modelli / segnali della stessa direzione ("votare che il prezzo crescerà") hanno successo (attivati), vengono sommati tra loro e la somma viene confrontata con il valore Signal_ThresholdOpen. Se nessuna posizione è stata aperta o la somma viene confrontata con il valore Signal_ThresholdClose nel caso di una posizione precedentemente opposta (in questo esempio, una posizione short), il m_pattern_4 di SignalCCIxx.mqh ha il valore di:
- 80 in caso di condizione di "price-grow"
- -80 in caso di condizione "price-fall"
Supponiamo che TUTTI gli altri modelli di TUTTI i segnali (SignalRSI.mqh, SignalMA.mqh e i modelli 0,1,2,3 e 5 di SignalCCIxx.mqh) ottengano un valore di 0. Questo è come se i "concorrenti di segnale" siano fuori dal "gioco" e gli unici concorrenti siano i due di m_pattern_4, uno per l'acquisto e uno per la vendita. Quindi abbiamo solo il m_pattern_4 funzionante, perché ha un valore diverso da 0, cioè 80.
//--- setting default "weights" of the market models m_pattern_0 =0; // model 0 "price is on the necessary side from the indicator" m_pattern_1 =0; // model 1 "price crossed the indicator with opposite direction" m_pattern_2 =0; // model 2 "price crossed the indicator with the same direction" m_pattern_3 =0; // model 3 "piercing"
E nello stesso modo per RSI dal file SignalRSI.mqh:
//--- setting default "weights" of the market models m_pattern_0 =0; // model 0 "the oscillator has required direction" m_pattern_1 =0; // model 1 "reverse behind the level of overbuying/overselling" m_pattern_2 =0; // model 2 "failed swing" m_pattern_3 =0; // model 3 "divergence of the oscillator and price" m_pattern_4 =0; // model 4 "double divergence of the oscillator and price" m_pattern_5 =0; // model 5 "head/shoulders"
Nel "nostro" SignalCCIxx.mqh (che è quasi affatto una copia di SignalCCI.mqh) abbiamo questi valori:
//--- setting default "weights" of the market models m_pattern_0 =0; // model 0 "the oscillator has required direction" m_pattern_1 =0; // model 1 "reverse behind the level of overbuying/overselling" m_pattern_2 =0; // model 3 "divergence of the oscillator and price" m_pattern_3 =0; // model 4 "double divergence of the oscillator and price" m_pattern_4 =80; // model 4 "our own first new pattern: " m_pattern_5 =0; // model 5 "our own second new pattern: "
All'inizio dell'articolo abbiamo aggiunto queste righe:
input int Signal_CCIxx_PeriodCCI =8; // Commodity Channel Index(8,...) Period of calculation input ENUM_APPLIED_PRICE Signal_CCIxx_Applied =PRICE_CLOSE; // Commodity Channel Index(8,...) Prices series input double Signal_CCIxx_Weight =0.8; // Commodity Channel Index(8,...) Weight [0...1.0]
Ci siamo concentrati sulla variabile Signal_CCIxx_Weight che ha valore di 0,8. Il Signal_ThresholdOpen viene raggiunto (attivato) quando viene raggiunto il valore di soglia. Il valore viene calcolato in questo modo:
0.8 (Signal_CCIxx_Weight input parameter) * 80 (m_pattern_4's weight value) = 64 is the signal strength for the "voting that price will grow"
È "votare che il prezzo crescerà", perché l'algoritmo ha catturato un segnale di "crescita del prezzo" (m_pattern_4 di SignalCCIxx) e il valore è 80.
Se ipoteticamente ha preso un "votare che il prezzo scenderà" (m_pattern_4 di SignalCCIxx), il valore è -80. Per "prezzo in calo" l'algoritmo ha semplicemente messo un segno meno al valore del modello. Supponendo il caso di "votare che il prezzo scenderà", i calcoli sono i seguenti:
0.8 (Signal_CCIxx_Weight input parameter) * -80 (m_pattern_4's weight value) = -64 = the negative value is considered for short positions
-64 64 (in valore assoluto) è la potenza del segnale per il "votare che il prezzo cadrà". La potenza del segnale è sempre espressa in valore assoluto, mentre i valori di posizione short sono preceduti da un segno meno e i valori di posizione long da un segno più.
Torniamo ad un esempio precedente della posizione long con valore raggiunto di 64 e potenza del segnale di 64. Se non ci sono altri segnali opposti (con segno negativo) (m_pattern_N di Signal__) che competono, si raggiunge il Signal_ThresholdOpen che ha valore di 40, perché la forza del segnale lungo è 64 e il livello 40 di Signal_ThresholdOpen è raggiunto e superato da 24 (40+24=64). Poiché è stata raggiunta la Signal_ThresholdOpen, viene aperta una posizione long.
Ad esempio, se impostiamo il valore 0,4 a Signal_CCIxx_Weight, non verrà aperta alcuna posizione long perché:
0.4 (the Signal_CCIxx_Weight) * 80(m_pattern_4) = 32 (strength of "long signal")
e il livello 40 (Signal_ThresholdOpen) non viene raggiunto perché 32 < 40, quindi non vengono aperte posizioni long.
L'esempio di set di valori di cui sopra (tutti i valori 0 tranne 80 in m_pattern_4 di SignalCCIxx.mqh) è solo usato per assurdo, per farci capire l'ottima logica alla base del Wizard e del sistema di pesi e soglie. Nella programmazione normale si assegna un peso preferito a ciascuno di m_pattern_N di ogni Signal__. Se si assegna il valore 0 a un modello, significa solo che questo modello non verrà utilizzato.
Se cambiassimo un altro valore nell'esempio sopra (con tutti i parametri impostati su 0 ad eccezione di m_pattern_4 di SignalCCIxx.mqh), diciamo m_pattern_1 di SignalRSI.mqh a 100, i calcoli cambiano in modo che ora abbiamo 4 concorrenti:
- m_pattern_4 (Bull) e m_pattern_4 (Bear) dal file SignalCCIxx.mqh, valori rispettivamente di 80 e -80.
- m_pattern_1 (Bull) e m_pattern_1 (Bear) dal file SignalRSI.mqh, valori rispettivamente di 100 e -100.
m_pattern_4 Bullish --> 0.8 * 80 = 64 m_pattern_2 Bullish --> 0.7 * 100 = 70
m_pattern_4 Bearish --> 0.8 * (-80) = -64 m_pattern_2 Bearish --> 0.7 * (-100) = -70
Quindi avremo 4 possibili combinazioni:
A) m_pattern_4 Bullish + m_pattern_2 Bullish = {[0.8 * (80)] + [0.7 * (100)]}/2 = [64 + (70)]/2 = 134/2 = 67
B) m_pattern_4 Bullish + m_pattern_2 Bearish = {[0.8 * (80)] + [0.7 * (-100)]}/2 = [64 + (-70)]/2 = -6/2 = -3
C) m_pattern_4 Bearish + m_pattern_2 Bullish = {[0.8 * (-80)] + [0.7 * (100)]}/2 = [(-64) + 70]/2 = 6/2 = 3
D) m_pattern_4 Bearish + m_pattern_2 Bearish = {[0.8 * (-80)] + [0.7 * (-100)]}/2 = [(-64) + (-70)]/2 = -134/2 = -67
Caso A
Valore positivo di 67. La posizione long viene aperta perché Signal_ThresholdOpen con valore di 40 viene raggiunto e superato. La posizione long viene successivamente chiusa quando viene raggiunta la Signal_ThresholdClose con valore 60 e superata dal valore assoluto del caso D = -67 = |67| (valore assoluto), perché la forza del caso D in valore assoluto 67 > 60 (cioè la soglia di Signal_ThresholdClose).
Caso B
Valore negativo -3. Non vengono aperte posizioni short, perché Signal_ThresholdOpen con valore di 40 non viene raggiunto e superato dal valore assoluto del caso B: -3 è diventato 3 quando consideriamo il suo valore assoluto per calcolare la "potenza del segnale" e 3 < 40 (valore per un segnale per aprire la posizione). Non ci sono posizioni short aperte e ovviamente non ci sono calcoli per la chiusura di posizioni short.
Caso C
Valore positivo 3. Non vengono aperte posizioni long, perché Signal_ThresholdOpen con valore di 40 non viene raggiunto e superato dal valore del caso C dal 3 < 40 (valore per un segnale per aprire la posizione). Non ci sono posizioni long aperte e ovviamente non ci sono calcoli per la chiusura di posizioni long.
Caso D
Valore negativo -67. La posizione short viene aperta perché Signal_ThresholdOpen con valore di 40 viene raggiunto e superato dalla potenza del segnale, la quale viene calcolata semplicemente con il valore assoluto di -67 che è 67 e 67 > 40. La posizione short ,viene chiusa quando viene raggiunto Signal_ThresholdClose con valore di 60 e superato dal valore del caso A = 67, poiché 67 (la forza del caso A) > 60 (cioè la soglia di Signal_ThresholdClose).
In altre parole, per l'apertura di posizioni short, prima dobbiamo identificare la direzione a causa del valore negativo dei segnali, poi il valore negativo viene trasformato nel suo valore assoluto per calcolare la potenza del segnale da confrontare con il valore Signal_ThresholdOpen per vedere se il primo > = il secondo.
La chiusura delle posizioni long viene eseguita in modo simile: prima consideriamo il valore negativo per chiudere la posizione long (al contrario, il valore per la chiusura della posizione short è positivo), poi questo valore negativo viene trasformato nel suo valore assoluto da confrontare con il Signal_ThresholdClose per vedere se il primo > = il secondo.
Per l'apertura di posizioni long e la chiusura di posizioni short i calcoli vengono eseguiti su numeri positivi (non ci sono segnali con segno meno), quindi non è necessario considerare i valori assoluti per i calcoli. L'apertura delle posizioni long è innescata da un valore positivo della potenza del segnale e la chiusura della posizione short è attivata anche da un valore positivo della potenza del segnale.
In primo luogo sono considerati il segno più e il segno meno per aprire una posizione long o short e, rispettivamente, per chiudere una posizione short o chiudere una posizione lunga. Quindi abbiamo calcolato i loro valori assoluti per il confronto con i valori soglia di Signal_ThresholdOpen e Signal_ThresholdClose, che sono sempre calcolati con segno positivo (nessun segno negativo per Signal_ThresholdOpen e Signal_ThresholdClose).
Dettagli posizione
Continuiamo ad approfondire i dettagli della posizione:
- Trading normale. La posizione viene aperta e quindi chiusa. Successivamente, la posizione non viene riaperta immediatamente.
- Inversione di posizione. La posizione viene aperta, quindi chiusa e quindi riaperta nella direzione opposta.
La posizione long viene aperta se:
Open_long >= Signal_ThresholdOpen | IF Signal_ThresholdClose <= Signal_ThresholdOpen | ||
|---|---|---|
|
| IF Signal_ThresholdClose >= Signal_ThresholdOpen | ||
|---|---|---|
|
In caso di Signal_ThresholdClose >= Signal_ThresholdOpen, è il booleano "OR" perché Signal_ThresholdClose >= Signal_ThresholdOpen, incorporando già il valore di Signal_ThresholdOpen. Pertanto, la posizione verrà chiusa e sovrascritta dal valore di Signal_ThresholdClose > = Signal_ThresholdOpen. Sarà comunque invertita a breve.
La posizione short viene aperta se:
Open_short >= Signal_ThresholdOpen. | Signal_ThresholdClose <= Signal_ThresholdOpen | ||
|---|---|---|
|
| IF Signal_ThresholdClose >= Signal_ThresholdOpen | ||
|---|---|---|
|
In caso di Signal_ThresholdClose >= Signal_ThresholdOpen, è il booleano "OR" perché Signal_ThresholdClose >= Signal_ThresholdOpen, incorporando già il valore di Signal_ThresholdOpen. Pertanto, la posizione verrà chiusa e sovrascritta dal valore di Signal_ThresholdClose > = Signal_ThresholdOpen. Sarà comunque invertita a lungo.
Il meccanismo di apertura e chiusura delle posizioni degli EA generati dal Wizard è molto perspicace e intelligente, in quanto si basa su un sistema di pesi, valori e soglie. Utilizzando questo meccanismo, le posizioni saranno gestite con grande "metodologia" e senza errori logici.
Livello di prezzo e scadenza del segnale
C'è un'altra variabile importante:
input double Signal_PriceLevel =0.0; // Price level to execute a deal
Questa variabile è molto importante per la comprensione di base del meccanismo EA generato dal Wizard e può essere semplificata in questo modo:
Signal_PriceLevel determina se il segnale long verrà elaborato come Buy-Stop o Buy-Limit o se il segnale short verrà elaborato come Sell-Stop o Sell-Limit. Per i dettagli sugli ordini Stop e Limit, vedi la corrispondente sezioneAiuto di MetaTrader 5.
I valori negativi assegnati alla variabile di input Signal_PriceLevel significano sempre Stop-Orders (Buy o Sell).
I valori positivi assegnati alla variabile di input Signal_PriceLevel significano sempre Limit-Orders (Buy o Sell).
Per esempio:
EURUSD, posizioni long
Signal_PriceLevel = -70 (meno 70)
quindi quando Signal Open è attivato (ad esempio prezzo corrente = 1,2500),
l'EA piazzerà un ordine Buy Stop composto da 1,2500 + 70 = 1,2570
(peggio del prezzo attuale, dal punto di vista rialzista)
Signal_PriceLevel = 60 (più 60)
quindi quando Signal Open è attivato (ad esempio prezzo corrente = 1,2500),
l'EA piazzerà un ordine Buy Limit composto da 1,2500 - 60 = 1,2440
(migliore del prezzo attuale, dal punto di vista rialzista)
EURUSD, posizioni short
Signal_PriceLevel = -70 (meno 70)
quindi quando Signal Open è attivato (ad esempio prezzo corrente = 1,2500),
l'EA piazzerà un ordine Sell Stop composto da 1,2500 - 70 = 1,2430
(migliore del prezzo attuale, dal punto di vista ribassista)
Signal_PriceLevel = 60 (più 60)
quindi quando Signal Open è attivato (ad esempio prezzo corrente = 1,2500),
l'EA piazzerà un ordine Sell Limit composto da 1,2500 + 60 = 1,2560
(peggiore del prezzo corrente, dal punto di vista ribassista)
Infine, la variabile di input
input int Signal_Expiration =4; // Expiration of pending orders (in bars)
determina quante volte (espresse in barre) gli ordini Stop/Limit saranno attivi.
Diagramma di flusso
Per un'ulteriore comprensione, puoi prendere in considerazione questo diagramma di flusso semplificato che mostra più o meno il meccanismo della dinamica di funzionamento degli EA generati dal Wizard.
Strategy Tester
Ora torniamo al contesto della nostra strategia personalizzata e compiliamo il file SignalCCIxx.mqh. Se non ci sono errori, tutto dovrebbe andare bene. Bene, in realtà ora abbiamo aggiunto 2 nuovi modelli di modelli di decisione di trading di mercato. Ogni modello ha una condizione di acquisto e vendita, nonché condizioni di apertura e chiusura.
Ora compiliamo il file MyExpert.mq5 e, se tutto è OK, ci saranno 0 errori e 0 avvisi. Bene, testiamolo nello Strategy Tester. Ho utilizzato alcuni parametri nello Strategy Tester per il simbolo EUR/USD, per un periodo simile a quello dell'ultimo Automated Trading Championship 2011.
Nonostante mostri risultati "buoni" e più doppi nel deposito iniziale in meno di 3 mesi con un importo fisso del lotto, non consiglio di utilizzare questo EA per il trading reale, ma piuttosto ti incoraggio ad aggiungere i tuoi pattern / modelli e sperimentarli, ottimizzando fino a ottenere risultati ottimali che ti si addicono.
Ad ogni modo, il nostro scopo qui è quello di dimostrare che l'idea di amplificare le classi di strategia di trading esistenti funziona.
È possibile creare nuovi pattern / modelli e condividerli con la MQL5.community. Utilizzando il Wizard MQL5 e questo semplice metodo discusso in questo articolo, sarà facile testarli e provarli. Questo articolo è solo un esempio di come esplorare le classi di strategia di trading della libreria standard e di quanto sia semplice modificare le librerie per creare i propri sistemi di trading.
Conclusione
Abbiamo facilmente aggiunto 2 nuovi filtri / modelli al segnale CCI. Puoi fare lo stesso per tutti gli altri indicatori e costruire il tuo gruppo di segnali personalizzati. Se fai un lavoro molto strutturato e ponderato, può diventare uno strumento molto potente per il trading.
Questo è un modo potente e conveniente per aggiungere le proprie strategie concentrandosi solo sulle strategie di base che lavorano con gli indicatori. Lascia che il Wizard MQL5 faccia tutto il resto del lavoro relativo alle funzioni di trading e alle operazioni dell'EA: questo è un risparmio di tempo e anche una garanzia di correttezza dell’Expert Advisor.
Puoi scrivere facilmente le tue strategie utilizzando gli indicatori standard MetaTrader 5 e impacchettandoli in un EA pronto per l’ATC.
Tradotto dall’inglese da MetaQuotes Ltd.
Articolo originale: https://www.mql5.com/en/articles/488
Strategia statistica del carry trade
MetaQuotes ID nel terminale mobile MetaTrader
Reti neurali: dalla teoria alla pratica
Introduzione al metodo di decomposizione empirica
- 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