English Русский 中文 Español Deutsch 日本語 Português 한국어 Français Türkçe
preview
I Fondamenti dei Testing in MetaTrader 5

I Fondamenti dei Testing in MetaTrader 5

MetaTrader 5Tester | 9 dicembre 2021, 14:07
400 0
MetaQuotes
MetaQuotes

Perché Abbiamo Bisogno di uno Strategy Tester

L'idea di ​di trading automatico è attraente per il fatto che il robot di trading è in grado di lavorare ininterrottamente per 24 ore al giorno, sette giorni alla settimana. Il robot non si stanca, non ha dubbi o paure, è totalmente esente da problemi psicologici. E' sufficiente formalizzare in modo chiaro le regole di trading e la loro attuazione negli algoritmi ed il robot è pronto a lavorare senza sosta. Ma innanzitutto, è necessario assicurarsi che siano soddisfatte le seguenti due importanti condizioni:

  • L'Expert Advisor svolge operazioni di trading in conformità alle regole del sistema di trading;
  • La strategia di trading, implementata nell'EA, dimostra un profitto sulla cronologia.

Per ottenere risposte a queste domande, ci rivolgiamo allo Strategy Tester, incluso nel client terminal MetaTrader 5.


Modalità Generazione Tick

Un Expert Advisor è un programma, scritto in MQL5, che viene eseguito ogni volta in risposta ad alcuni eventiesterni. L’ EA ha una corrispondente funzione (event handler) per ogni evento predefinito.

L'evento NewTick (variazione di prezzo) è l'evento principale per l'EA e, di conseguenza, abbiamo bisogno di generare una sequenza di tick per testare l' EA. Ci sono 3 modalità di generazione tick implementate nello Strategy Tester del client terminal di MetaTrader 5:

  • Ogni tick
  • 1 minuto OHLC (prezzi OHLC con barre minuto)
  • Solo prezzi di apertura

La modalità base e la più dettagliata è la modalità "Ogni tick", le altre due modalità sono le semplificazioni della base, e verranno descritte rispetto alla modalità "Ogni tick". Considerate tutte le tre modalità per capire le loro differenze.


"Every Tick"

I dati storici di quotazioni di strumenti finanziari vengono trasferiti dal server di trading al client terminal MetaTrader 5 sotto forma di barre di minuti impacchettate . Informazioni dettagliate sulla presenza delle richieste e la costruzione del timeframe richiesto può essere ottenuta dal capitolo Organizzare i Dati di Accesso nel manuale di Riferimento MQL5.

L'elemento minimo dello storico dei prezzi è la barra dei minuti, da cui è possibile ottenere informazioni sui quattro valoridel prezzo:

  • Open - il prezzo al quale è stata aperta la barra dei minuti;
  • High - il massimo che è stato raggiunto nel corso di questa barra dei minuti;
  • Low - il minimo che è stato raggiunto nel corso di questa barra dei minuti;
  • Close - il prezzo di chiusura della barra.

La nuova barra dei minuti non viene aperta nel momento in cui inizia il nuovo minuto (il numero di secondi diventa uguale a 0), ma quando si verifica un tick - un cambiamento di prezzo di almeno un punto. La figura mostra la prima barra di minuti della nuova settimana di trading che ha orario di apertura 10.01.2011 00:00. Il divario di prezzo tra venerdì e lunedì, che vediamo sul grafico, è comune, poiché i tassi di cambio fluttuano anche nei fine settimana in risposta alle notizie in arrivo.

Fig. 1. Il divario di prezzo tra Venerdì e Lunedì

Per questa barra, si sa solo che la barra dei minuti è stata aperta il 10 gennaio 2011 alle ore 00 e 00 minuti, ma non sappiamo nulla circa i secondi. Avrebbe potuto essere aperta alle 00:00:12 o 00:00:36 (12 o 36 secondi dopo l'inizio di un nuovo giorno) o in qualsiasi altro momento entro tale minuto. Tuttavia, sappiamo che il prezzo di apertura di EURUSD era a 1,28940 al tempo di apertura della nuova barra dei minuti.

Non sappiamo nemmeno, in un secondo, quando è stato ricevuto il tick corrispondente al prezzo di chiusura della barra dei minuti considerata. Sappiamo solo una cosa - l'ultimo prezzo Close della barra dei minuti. Per questo minuto, il prezzo era 1,28958. Anche il tempo di comparsa di prezzi High e Low è sconosciuto , ma sappiamo che i prezzi minimi e massimi sono stati rispettivamente a livello di 1,28958 e 1,28940.

Per testare la strategia di trading, abbiamo bisogno di una sequenza di tick in cui verrà simulato il lavoro dell'Expert Advisor. Così, per ogni barra dei minuti, sappiamo che i 4 punti di controllo, dove il prezzo è stato sicuramente. Se un bar ha solo 4 tick, allora questa è un’ informazione sufficiente per effettuare un testjng, ma di solito il volume di tick è superiore a 4.

Quindi, vi è la necessità di generare punti di controllo supplementari per i tick che si sono verificati tra i prezzi Open, High, Low e Close. Il principio della generazione tick modalità "Ogni tick" è descritto nell' Algoritmo di Generazione dei Tick all'interno dello Strategy Tester del Terminale MetaTrader del quale una figura viene presentata di seguito.

Fig. 2. Algoritmo di generazione dei tick

Durante il testing in modalità "Ogni Tick", la funzione OnTick() dell'EA verrà chiamata ad ogni punto di controllo. Ogni punto di controllo è un tick da una sequenza generata. L' EA riceverà l'orario ed il prezzo del tick simulato, così come accadrebbe quando si lavora online.

Importante: la modalità di testing "Ogni tick" è la più precisa, ma al tempo stesso, quella che richiede più tempo. Per un testing iniziale della maggioranza delle strategie di trading, è generalmente sufficiente utilizzare una delle altre due modalità di test.


"1 Minute OHLC"

La modalità "Ogni tick" è la più accurata delle tre modalità, ma al tempo stesso, è la più lenta. La gestione dell'handler OnTick() si verifica ad ogni tick, mentre il volume tick può essere abbastanza grande. Per una strategia in cui la sequenza di tick del movimento del prezzo durante la barra non ha importanza, c'è una modalità di simulazione più veloce e più grezza - "1 minute OHLC".

Nella modalità "1 minuto OHLC", la sequenza tick è costruita solo dai prezzi OHLC delle barre dei minuti , il numero dei punti di controllo generati è significativamente ridotto - quindi, e di conseguenza, viene ridotto il tempo di test. Il lancio della funzione OnTick () viene eseguito su tutti i punti di controllo, che sono costruiti dai prezzi delle barre OHLC dei minuti.

Il rifiuto di generare ulteriori tick intermedi tra i prezzi Open, High, Low e Close, porta ad un aspetto di rigido determinismo nello sviluppo dei prezzi, dal momento che viene determinato il prezzo di apertura. Ciò permette di creare un "Graal dei Test", che mostra un bel grafico ascendente del bilancio dei test.

Un esempio di tale Graal è presentato nel Code Base - Grr-al.

Fig. 3. L'Expert Advisor Grr-al, utilizza le caratteristiche dei prezzi OHLC

La figura mostra un grafico molto interessante di questo testing dell’EA. Come è stato ottenuto? Conosciamo 4 prezzi per una barra dei minuti e sappiamo anche che il primo è il prezzo di apertura e l'ultimo è il prezzo di chiusura. Abbiamo i prezzi High e Low tra loro, e la sequenza del loro verificarsi è sconosciuta, ma è noto che il prezzo High è maggiore o uguale al prezzo Open (ed il prezzo Low è minore o uguale al prezzo Open.

È sufficiente per determinare il tempo di ricezione del prezzo Open e quindi analizzare il tick successivo per determinare se il prezzo Alto o Basso viene prima di esso. Se il prezzo è inferiore al prezzo Open, allora abbiamo un prezzo Low ed il buy in questo tick; il tick successivo corrisponderà al prezzo High, al quale noi chiudiamo il buy e apriamo per sell. Il tick successivo è l'ultimo, questo è il prezzo Close e chiudiamo la vendita su di esso. 

Se dopo il prezzo, riceviamo un tick con un prezzo superiore al prezzo di apertura, allora la sequenza di operazioni è invertita. Elabora una barra dei minuti in questa modalità "cheat" ed attende la prossima.

Durante il testing di questo EA sulla cronologia, tutto va liscio, ma una volta che lo lanciamo on-line, la verità comincia a rivelarsi - la linea di saldo rimane costante, ma punta verso il basso. Per esporre questo escamotage, dobbiamo semplicemente eseguire l'EA nella modalità "Ogni tick".

Nota: Se i risultati dell'EA nelle modalità di testing approssimative ("OHLC 1 minuto" e "Solo Prezzi di Apertura") sembrano troppo buoni, assicurati di provarlo in modalità "Ogni Tick".


“Solo Prezzi Open”

In questa modalità i tick vengono generati sulla base dei prezzi OHLC del timeframe selezionato per il test. La funzione OnTick() dell' Expert Advisor gira solo all'inizio della barra al prezzo Open. Grazie a questa caratteristica, i livelli di stop e in sospeso possono innescare un prezzo che differisce da quello specificato (soprattutto nel testing su intervalli superiori). Invece, abbiamo la possibilità di eseguire rapidamente un testing di valutazione dell'Expert Advisor.

I periodi W1 e MN1 sono le eccezioni in modalità di generazione tick "Open Price Only": per questi intervalli i tick vengono generati per i prezzi OHLC di ogni giorno, non i prezzi OHLC della settimana o del mese.

Supponiamo di testare un Expert Advisor su EURUSD H1 nella modalità "Solo Prezzi di Apertura". In questo caso, il numero totale di tick (punti di controllo) sarà non più di 4*numero di barre un-ora all'interno dell'intervallo testato. Ma l'handler OnTick() viene chiamato solo all'apertura della barra un’-ora. I controlli richiesti per un testing corretto si verificano sul resto dei tick (che sono "nascosti" dall’EA).
  • Il calcolo dei requisiti di margine;
  • L'attivazione di Stop Loss e Take Profit;
  • L'innesco di ordini in sospeso;
  • La rimozione di ordini in sospeso scaduti

Se non ci sono posizioni aperte o ordini in sospeso, non abbiamo bisogno di effettuare tali controlli sui tick nascosti e l'incremento della velocità può essere sostanzialmente tranquillo. Questa modalità "Solo Prezzi di Apertura" è ben adatta per le strategie di testing, il cui procedimento riguarda solo l'apertura della barra e non utilizza gli ordini in sospeso, così come gli ordini StopLoss e TakeProfit. Per la classe di tali strategie, l'accuratezza necessaria del testing viene preservata.

Usiamo l'Expert Advisor Moving Average dal pacchetto standard come un esempio di EA che può essere testato in qualsiasi modalità. La logica di questo EA è costruita in modo tale che tutte le decisioni vengono prese all'apertura della barra e gli operazioni vengono eseguite immediatamente, senza l'uso di ordini in sospeso.

Esegue un testing dell’EA su EURUSD H1 su un intervallo dal 01.09.2010 al 31.12.2010 e confronta i grafici. La figura mostra il grafico saldo dal rapporto di testing per tutte e tre le modalità.


Fig. 4. Il grafico del testing dell'EA Moving Average.mq5 dal pacchetto standard non dipende dalla modalità di testing (clicca sull'immagine per ingrandirla)

Come si può vedere, i grafici su diverse modalità di testing sono esattamente gli stessi per l'EA Moving Average dal pacchetto standard.

Ci sono alcune limitazioni nella modalità "Solo Prezzi Open":

  • Non è possibile utilizzare modalità di esecuzione Random Delay.
  • Nell'Expert Advisor testato, non puoi accedere ai dati del intervallo inferiore a quello utilizzato per il testing/ottimizzazione. Ad esempio, se avvii il testing/ottimizzazione sul periodo H1, puoi accedere ai dati di H2, H3, H4 ecc. ma non di M30, M20, M10 ecc. Inoltre, gli intervalli più elevati accessibili devono essere multipli dell’intervallo di testing. Ad esempio, se si esegue il testing in M20, non è possibile accedere ai dati di M30, ma è possibile accedere ad H1. Queste limitazioni sono collegate all'impossibilità di ottenere dati di intervalli più bassi o non-multipli delle barre generate durante il testing/ottimizzazione.
  • Le limitazioni all'accesso ai dati di altri intervalli si applicano anche ad altri simboli i cui dati vengono utilizzati dall'Expert Advisor. In questo caso la limitazione per ciascun simbolo dipende dal primo intervallo e accessibile durante il testing/ottimizzazione. Supponiamo che, durante il testing su EURUSD H1, un Expert Advisor acceda ai dati di GBPUSD M20. In questo caso, l'Expert Advisor sarà in grado di utilizzare ulteriormente i dati di EURUSD H1, H2, ecc., nonché GBPUSD M20, H1, H2 ecc.

Nota: La modalità "Solo Prezzi di Apertura" ha il più veloce tempo di testing, ma non è adatto per tutte le strategie di trading. Selezionare la modalità di testing desiderata in base alle caratteristiche del sistema di trading. 

Per concludere la sezione sulle modalità di generazione dei tick, consideriamo un confronto visivo delle diverse modalità di generazione di tick per EURUSD, per due barre M15 su un intervallo da 11.01.2011 21:00:00 - 11.01.2011 21:30:00.

I tick sono stati salvati in file diversi utilizzando l'EA WriteTicksFromTester.mq5 e la fine di questi nomi di file è specificata nei parametri di input filenameEveryTick, filenameOHLC e filenameOpenPrice.

Fig. 5. Siamo in grado di specificare le date di partenza e di fine dei tick (le variabili start ed end) per l'Expert Advisor WriteTicksFromTester

Per ottenere tre file con tre sequenze di tick (per ciascuna delle seguenti modalità "Ogni Tick", "1 minuto OHLC" e "Solo Prezzi di Apertura"), l'EA è stato lanciato per tre volte nei modi corrispondenti, in singole run. Quindi, i dati provenienti da questi tre file sono stati visualizzati sul grafico con l'indicatore TicksFromTester.mq5. Il codice dell'indicatore è allegato a questo articolo.


Fig. 6. La sequenza dei tick nello Strategy Tester del terminale MetaTrader 5 in tre diverse modalità di testing.

Di default, tutte le operazioni sui file nel linguaggio MQL5 vengono realizzate all'interno del "file sandbox" e durante il testing l'EA ha accesso solo alla propria "file sandbox ". Affinché l'indicatore e l' EA possano lavorare con i file da una cartella durante il test, abbiamo usato il flag FILE_COMMON. Un esempio di codice dall'EA:

//--- open the file
   file=FileOpen(filename,FILE_WRITE|FILE_CSV|FILE_COMMON,";");
//--- check file handle
   if(file==INVALID_HANDLE)
     {
      PrintFormat("Error in opening of file %s for writing. Error code=%d",filename,GetLastError());
      return;
     }
   else
     {
      PrintFormat("The file will be created in %s folder",TerminalInfoString(TERMINAL_COMMONDATA_PATH));
     }

Per leggere i dati dell'indicatore, abbiamo usato anche il flag FILE_COMMON. Questo ci ha permesso di evitare di trasferire manualmente i file necessari da una cartella ad un'altra.

//--- open the file
   int file=FileOpen(fname,FILE_READ|FILE_CSV|FILE_COMMON,";");
//--- check file handle
   if(file==INVALID_HANDLE)
     {
      PrintFormat("Error in open of file %s for reading. Error code=%d",fname,GetLastError());
      return;
     }
   else
     {
      PrintFormat("File will be opened from %s",TerminalInfoString(TERMINAL_COMMONDATA_PATH));
     }


Simulazione dello spread

La differenza di prezzo tra i prezzi Bid ed Ask si chiama spread. Durante i test, lo spread non è modellato ma viene prelevato dai dati storici. Se lo spread è minore o uguale a zero nei dati cronologici, l'intervallo di diffusione per il tempo dei dati cronologici richiesti viene utilizzato dall'agente di testing.

Nello Strategy Tester, lo spread è sempre considerato fluttuante. Cioè il SymbolInfoInteger symbol,SYMBOL_SPREAD_FLOAT) e restituisce sempre true.

Inoltre, i dati dello storico contengono i valori dei tick ed i volumi di trading. Per lo stoccaggio ed il recupero dei dati si usa una speciale struttura MqlRates:

struct MqlRates
  {
   datetime time;         // opening bar time
   double   open;         // opening price Open
   double   high;         // the highest price High
   double   low;          // the lowest price Low
   double   close;        // the closing price Close
   long     tick_volume;  // the tick volume
   int      spread;       // spread
   long     real_volume;  // market volume 
  };


Le Variabili Globali del Client Terminal

Durante il test, vengono emulate anche le variabili globali del client terminal ma non sono associate alle variabili globali correnti del terminale che possono essere viste nel terminale utilizzando il pulsante F3. Ciò significa che tutte le operazioni con le variabili globali del terminale, durante i testing, hanno luogo al di fuori del client terminal (nell'agente di test).


Il Calcolo degli Indicatori durante il Test

In modalità in tempo reale, i valori dell'indicatore ​sono calcolati ad ogni tick Lo Strategy Testar ha adottato un modello economico per il calcolo degli indicatori - gli indicatori vengono ricalcolati solo immediatamente prima dell’esecuzione dell'EA. Ciò significa che il ricalcolo degli indicatori viene effettuato prima della chiamata delle funzioni OnTick(), OnTrade() e OnTimer().

Non importa se c'è o non c'è una chiamata per l'indicatore in un gestore di eventi specifico, tutti gli indicatori, dei quali sono stati creati gli handler dalle funzioni iCustom() o IndicatorCreate() verranno ricalcolati prima di richiamare il gestore di eventi.

Di conseguenza, quando si esegue il testing in modalità "Ogni Tick", il calcolo degli indicatori avviene prima della chiamata della funzione OnTick()

Se il timer è on nell'EA, utilizzando la funzione EventSetTimer(), allora gli indicatori verranno ricalcolati prima di ogni chiamata dell'handler OnTimer(). Pertanto, il tempo di testing può essere notevolmente aumentato mediante l'uso di indicatori, scritti in un modo non ottimale.


Caricamento della Cronologia durante il Testing

La cronologia di un simbolo da testare è sincronizzata e caricata dal terminale, dal server di trading prima di avviare il processo di testing. Durante la prima volta, il terminale carica tutta la cronologia a disposizione di un simbolo per non richiederla in un secondo momento. Inoltre, solo i nuovi dati vengono caricati.

Un agente di testing riceve la cronologia di un simbolo da testare dal client terminal subito dopo l'inizio del testing. Se i dati di altri strumenti vengono utilizzati nel processo di testing (ad esempio, è un Expert Advisor multi-valuta), gli agenti di testing richiedono la cronologia dal client terminal durante la prima chiamata a questi dati. Se i dati storici sono disponibili nel terminale, vengono immediatamente passati all'agente di test. Se i dati non sono disponibili, il terminale li richiede e scarica dal server, e poi li passa all'agente di test.

I dati di strumenti finanziari aggiuntivi sono anche necessari per il calcolo dei cross-rate per le operazioni di trading. Ad esempio, quando si esegue il testing di una strategia EURCHF con la valuta di deposito in USD, prima di elaborare la prima operazione di trading, l'agente di testing richiede i dati storici di EURUSD e USDCHF dal client terminal, anche se la strategia non contiene la chiamata diretta di uso di questi simboli.

Prima di testare una strategia multi-valuta, si consiglia di scaricare tutti i dati storici necessari nel client terminal. Ciò contribuirà ad evitare ritardi nel test/ottimizzazione associati al download dei dati richiesti. È possibile scaricare la cronologia, ad esempio, aprendo i grafici appropriati e scorrendo indietro verso l'inizio della cronologia. Un esempio di caricamento forzato della cronologia nel terminale è disponibile nella sezione Organizzare l'Accesso ai Dati dell' MQL5 Reference.

Il terminale carica la cronologia da un server di trading solo una volta, la prima volta l'agente richiede la cronologia di un simbolo testato dal terminale. La cronologia viene caricata in forma compressa per ridurre il traffico.
Gli agenti di test, a loro volta, ricevono la cronologia dal terminale in una forma compressa. Durante il testing successivo, il tester non carica la cronologia dal terminale, in quanto i dati richiesti sono disponibili dalla precedente esecuzione del tester.


Testing Multi-Valuta

Lo Strategy Tester ci permette di eseguire un testing di strategie, trading su più simboli. Questi EA sono convenzionalmente denominati Expert Advisors multi-valuta, poiché originariamente nelle piattaforme precedenti, i testing venivano eseguiti solo per un singolo simbolo. Nello Strategy Tester del terminale MetaTrader 5, possiamo modellare il trading per tutti i simboli disponibili.

Il tester carica la cronologia dei simboli utilizzati dal client terminal (non dal server di trading!) automaticamente durante la prima chiamata dei dati del simbolo.

L'agente di testing scarica solo la cronologia mancante, con un piccolo margine per fornire i dati necessari sullo storico, per il calcolo degli indicatori al momento di avvio del testing. Per gli intervalli di tempo D1 e minori, il volume minimo della cronologia scaricata è di un anno.

Pertanto, se si esegue un testing su un intervallo 1.11.2010-1.12.2010 (il testing per un intervallo di un mese) con un periodo di M15 (ciascuna barra è pari a 15 minuti), il terminale verrà richiesto per la cronologia dello strumento finanziario per l'intero anno 2010. Per l’intervallo settimanale, ci verrà richiesta una cronologia di 100 barre che è di circa due anni (un anno ha 52 settimane). Per il testing su un intervallo settimanale, l'agente chiederà la cronologia di 8 anni (12 mesi x 8 anni = 96 mesi).

Se non vi sono le barre necessarie, la data di inizio del testing verrà automaticamente spostatadal passato al presente per fornire la necessaria riserva di barre prima del testing.

Durante i test, viene emulato anche il "Market Watch" dal quale è possibile ottenere informazioni sui simboli.

Di default, all'inizio del test, c'è solo un simbolo nel "Market Watch" dello Strategy Tester - il simbolo su cui gira il test. Tutti i simboli necessari sono collegati al "Market Watch" dello Strategy Tester (non al terminale!) automaticamente quando vi si riferiscono.  

Prima di iniziare il testing di un Expert Advisor multi-valuta, è necessario selezionare i simboli necessari per il testing "Market Watch" del terminale e caricare i dati richiesti. Durante la prima chiamata di un simbolo "foreign", la sua cronologia verrà sincronizzata automaticamente tra l'agente di testing ed il client terminal. Un simbolo "foreign" è il simbolo diverso da quello su cui il testing è in esecuzione.

Il riferimento ai dati di un "altro" simbolo si verifica nei seguenti casi:

Al momento della prima chiamata ad un "altro" simbolo, il processo di testing viene interrotto e la cronologia viene scaricata per il simbolo/intervallo, dal terminale per l'agente di testing. Allo stesso tempo, viene eseguita la generazione della sequenza dei tick per questo simbolo.

Per ciascun simbolo, viene generata una sequenza individuale di tick in base alla modalità di generazione dei tick selezionata. È anche possibile richiedere la cronologia in modo esplicito per i simboli desiderati chiamando SymbolSelect() nell'handler OnInit() - il download della cronologia verrà effettuata immediatamente prima del testing dell'Expert Advisor.

Pertanto, eseguire il testing multi-valuta nel terminale client MetaTrader 5 non richiede alcuno sforzo aggiuntivo. È sufficiente aprire i grafici dei relativi simboli nel client terminal. La cronologia verrà caricata automaticamente dal server di trading per tutti i simboli necessari, a patto che contenga questi dati.


Simulazione del Tempo nello Strategy Tester

Durante il test, l'ora locale TimeLocal() è sempre uguale all'ora del server TimeTradeServer(). A sua volta, l'orario del server è sempre uguale all'orario corrispondente al tempo GMT - TimeGMT(). In tal modo, tutte queste funzioni mostrano lo stesso orario durante il testing.

La mancanza di una differenza tra l'orario GMT, l'orario locale e l'orario del server nello Strategy Tester viene fatta deliberatamente nel caso in cui non ci sia una connessione al server I risultati del test devono essere sempre gli stessi, indipendentemente dal fatto che vi sia un collegamento o no. Le informazioni sull'orario del server non vengono memorizzate localmente e vengono prese dal server.

 

La funzone OnTimer() nello Strategy Tester

MQL5 offre l'opportunità per l'handling degli eventi timer. La chiamata dell'handler OnTimer() avviene indipendentemente dalla modalità di testing.

Ciò significa che se un test è in esecuzione in modalità "Solo prezzi di apertura" per il periodo H4 e l' EA ha un timer impostato ad una chiamata al secondo, allora all'apertura di ogni barra H4, l'handler OnTick() sarà chiamato una sola volta e l'handler OnTimer() sarà chiamato 14400 volte (3.600 secondi * 4 ore). La quantità di cui il tempo di testing dell'EA sarà aumentata dipende dalla logica dell’EA.

Per verificare la dipendenza del tempo di testing dalla data frequenza del timer, è stato scritto un EA semplice senza operazioni di trading.

//--- input parameters
input int      timer=1;              // timer value, sec
input bool     timer_switch_on=true; // timer on
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- run the timer if  timer_switch_on==true
   if(timer_switch_on)
     {
      EventSetTimer(timer);
     }
//---
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
//--- stop the timer
   EventKillTimer();
  }
//+------------------------------------------------------------------+
//| Timer function                                                   |
//+------------------------------------------------------------------+
void OnTimer()
  {
//---
// take no actions, the body of the handler is empty
  }
//+------------------------------------------------------------------+

Le misurazioni del tempo del testing sono state effettuate a valori diversi ​del parametro timer (periodicità dell'evento Timer). Sui dati ottenuti, abbiamo tracciato un tempo di testing in funzione del periodo di Timer.

Fig. 7. Il tempo di testing in funzione del periodo di Timer

Si vede chiaramente che più piccolo è il parametro di timer, durante l'inizializzazione della funzione EventSetTimer(Timer), più piccolo è il periodo (Period) tra le chiamate dell'handler OnTimer() e più grande è il tempo T di testing, alle stesse condizioni.


La funzione Sleep() nello Strategy Tester

La funzione Sleep() consente all'EA o script di sospendere l'esecuzione del programma MQL5 per un po' quando si lavora sul grafico. Ciò può essere utile per la richiesta di dati che non sono pronti al momento della richiesta ed è necessario attendere che siano pronti. Un esempio dettagliato di utilizzo della funzione Sleep() si può trovare nella sezione Organizzazione dell’Accesso ai Dati.

Il processo di testing non viene rallentato dalle chiamate Sleep(). Quando chiami Sleep(), i tick generati vengono sono "giocati" entro un ritardo specificato che può provocare l'innesco di ordini in sospeso, stop, ecc. Dopo una chiamata Sleep(), il tempo simulato nello Strategy Tester aumenta di un intervallo, specificato nel parametro della funzione Sleep.

Se, a seguito della esecuzione della funzione Sleep(), l'orario corrente nello Strategy Tester ha superato il periodo di testing, allora si riceverà un errore di "Ciclo di Sleep infinito rilevato durante il testing". Se si riceve questo errore, i risultati del testing non vengono rifiutati, tutti i calcoli vengono eseguiti nel loro pieno volume (numero di operazioni, subsidenza, ecc) ed i risultati di questo testing vengono trasmessi al terminale.

La funzione Sleep() non funziona in OnDeinit(), dal momento che dopo che viene chiamata, il tempo di testing sarà garantito a superare il range dell' intervallo di testing.

Fig. 7. Lo schema di utilizzo della funzione Sleep() nello Strategy Tester del terminale MetaTrader 5

Fig. 8. Lo schema di utilizzo della funzione Sleep() nello Strategy Tester del terminale MetaTrader 5


Utilizzo dello Strategy Tester per i Problemi di Ottimizzazione nei Calcoli Matematici

Il tester nel terminale MetaTrader 5 può essere utilizzato non solo per testare strategie di trading, ma anche per i calcoli matematici. Per utilizzarlo, è necessario selezionare la modalità "Calcoli Matematici":

In questo caso, verranno chiamate solo tre funzioni: OnInit(), OnTester(), OnDeinit(). In modalità "Calcoli matematici" lo Strategy Tester non genera alcun tick e download della cronologia.

Lo Strategy Tester funziona in modalità "Calcoli matematici" anche se si specifica la data di inizio maggiore di quella di chiusura.

Quando si utilizza il tester per risolvere problemi matematici, il caricamento della cronologia e la generazione di tick non si verifica.

Un tipico problema matematico da risolvere nello Strategy Tester MetaTrader 5 - la ricerca di un estremo di una funzione con molte variabili.

Per risolverlo abbiamo è necessario:

  • il calcolo del valore della funzione deve trovarsi nella funzione OnTester() ;
  • I parametri della funzione devono essere definiti come variabili di input dell'Expert Advisor;

Compilare l'EA, aprire la finestra "Strategy Tester". Nel tab "Parametri di Input", selezionare le variabili di input richieste e definire l'insieme dei valori dei parametri specificando i valori di avvio, di arresto e di step per ognuna delle variabili della funzione.

Selezionare il tipo di ottimizzazione - "Algoritmo completo Lento" (ricerca completa dello spazio dei parametri) o "algoritmo Veloce a base genetica". Per una semplice ricerca dell’estremo della funzione, è meglio scegliere un'ottimizzazione veloce, ma se si desidera calcolare i valori ​per l'intero insieme di variabili, allora è meglio utilizzare l'ottimizzazione lenta.

Selezionare la modalità "Calcoli matematici" ed utilizzare il pulsante "Start" per eseguire la procedura di ottimizzazione. Notare che durante l'ottimizzazione lo Strategy Tester ricercherà i valori massimi della funzione OnTester. Per trovare un minimo locale, restituire l'inverso del valore della funzione calcolata dalla funzione OnTester:

return(1/function_value);

È necessario controllare che function_value non sia uguale a zero, altrimenti si può ottenere un errore critico di divisione per zero.

C'è un altro modo, è più conveniente e non altera i risultati dell'ottimizzazione; esso è stato suggerito dai lettori di questo articolo:

return(-function_value);

Questa opzione non richiede il controllo del function_value_ per essere uguale a zero e la superficie dei risultati di ottimizzazione in una rappresentazione 3D ha la stessa forma, ma è speculare all'originale.

Come esempio, forniamo la funzione sink():

Il codice dell’EA per trovare l'estremo di questa funzione è contenuto nell'OnTester():

//+------------------------------------------------------------------+
//|                                                         Sink.mq5 |
//|                        Copyright 2011, MetaQuotes Software Corp. |
//|                                              https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2011, MetaQuotes Software Corp."
#property link      "https://www.mql5.com"
#property version   "1.00"
//--- input parameters
input double   x=-3.0; // start=-3, step=0.05, stop=3
input double   y=-3.0; // start=-3, step=0.05, stop=3
//+------------------------------------------------------------------+
//| Tester function                                                  |
//+------------------------------------------------------------------+
double OnTester()
  {
//---
   double sink=MathSin(x*x+y*y);
//---
   return(sink);
  }
//+------------------------------------------------------------------+
Esegui un'ottimizzazione e visualizza i risultati dell'ottimizzazione sotto forma di grafico 2D.

Fig. 9. I risultati dell'ottimizzazione completa della funzione sink (x*x+y*y) come funzione grafico 2D

Migliore è il valore di una data coppia di parametri (x, y), più è saturato il colore. Come ci si aspettava dalla vista della forma della formula sink(), i suoi valori ​formano cerchi concentrici con un centro a (0,0). Si può vedere nel grafico-3D, che la funzione sink() non ha un estremo unico globale:

Grafico 3D della funzione Sink


La Sincronizzazione delle Barre nella modalità "Solo prezzi di apertura"

Il tester nel client terminal MetaTrader 5 ci consente di controllare il cosiddetto "EA multi-valuta". Un EA multi-valuta - è un EA che fa trading su due o più simboli.

Il testing di strategie, che sono trading su più simboli, impone alcuni requisiti tecnici complementari sul tester:

  • La generazione di tick per questi simboli;
  • Il calcolo dei valori degli indicatori ​per questi simboli;
  • Il calcolo dei requisiti di margine per questi simboli;
  • La sincronizzazione di sequenze tick generate per tutti i simboli di trading.

Lo StrategyTester genera e svolge una sequenza di tick per ogni strumento secondo la modalità di trading selezionata. Al tempo stesso, viene aperta una nuova barra per ogni simbolo, indipendentemente da come la barra viene aperta su un altro simbolo. Ciò significa che quando si testa un EA multi-valuta, può verificarsi una situazione (e spesso accade), quando per uno strumento una nuova barra è già aperta mentre per l'altro no. Così, durante il testing, tutto avviene proprio come nella realtà.

Questa simulazione autentica della cronologia nel tester non causa alcun problema, basta che vengono utilizzate le modalità di testing "Ogni tick" e "OHLC 1 minuto ". Per queste modalità, vengono generati sufficienti tick per un candlestick per poter attendere fino a che avviene la sincronizzazione di barre da diversi simboli. Ma come facciamo a testare strategie di un EA multi-valuta in modalità "Solo prezzi di Apertura", se la sincronizzazione delle barre degli strumenti di trading è obbligatoria? In questa modalità, l'EA viene chiamato solo su un tick che corrisponde al tempo di apertura delle barre.

Lo illustriamo attraverso un esempio: se stiamo testando un EA su EURUSD ed una nuova candlestick oraria è aperta su EURUSD, allora si può facilmente riconoscere questo fatto - nei testing in modalità "Solo Prezzi di apertura", l' evento NewTick corrisponde al momento dell'apertura della barra sul periodo di testing. Tuttavia, non vi è alcuna garanzia che il nuovo candlestick aperto sul simbolo USDJPY venga utilizzato nell’EA.

In circostanze normali, è sufficiente completare il lavoro della funzione OnTick() e verificare la comparsa di una nuova barra su USDJPY al prossimo tick. Tuttavia, durante il testing nella modalità "Solo prezzi di Apertura", non ci sarà nessun altro tick; così, può sembrare che questa modalità non sia adatta per il testing dell’EA multi-valuta. Ma non è così - non dimenticate che il tester in MetaTrader 5 si comporta proprio come farebbe nella vita reale. Puoi attendere che una nuova barra si apra su un altro dei simboli utilizzando la funzione del Sleep()!

Il codice dell’EA Synchronize_Bars_Use_Sleep.mq5 che mostra un esempio di sincronizzazione di barre in modalità "Solo Prezzi di Apertura":

//+------------------------------------------------------------------+
//|                                   Synchronize_Bars_Use_Sleep.mq5 |
//|                        Copyright 2011, MetaQuotes Software Corp. |
//|                                              https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2011, MetaQuotes Software Corp."
#property link      "https://www.mql5.com"
#property version   "1.00"
//--- input parameters
input string   other_symbol="USDJPY";
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- check symbol
   if(_Symbol==other_symbol)
     {
      PrintFormat("You have to specify the other symbol in input parameters or select other symbol in Strategy Tester!");
      //--- forced stop testing
      return(-1);
     }
//---
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- static variable, used for storage of last bar time
   static datetime last_bar_time=0;
//--- sync flag
   static bool synchonized=false;

//--- if static variable isn't initialized
   if(last_bar_time==0)
     {
      //--- it's first call, save bar time and exit
      last_bar_time=(datetime)SeriesInfoInteger(_Symbol,Period(),SERIES_LASTBAR_DATE);
      PrintFormat("The last_bar_time variable is initialized with value %s",TimeToString(last_bar_time));
     }

//--- get open time of the last bar of chart symbol
   datetime curr_time=(datetime)SeriesInfoInteger(Symbol(),Period(),SERIES_LASTBAR_DATE);
//--- if times aren't equal
   if(curr_time!=last_bar_time)
     {
      //--- save open bar time to the static variable
      last_bar_time=curr_time;
      //--- not synchronized
      synchonized=false;
      //--- print message
      PrintFormat("A new bar has appeared on symbol %s at %s",_Symbol,TimeToString(TimeCurrent()));
     }
//--- open time of the other symbol's bar
   datetime other_time;

//--- loop until the open time of other symbol become equal to curr_time
   while(!(curr_time==(other_time=(datetime)SeriesInfoInteger(other_symbol,Period(),SERIES_LASTBAR_DATE)) && !synchonized))
     {
      PrintFormat("Waiting 5 seconds..");
      //--- wait 5 seconds and call SeriesInfoInteger(other_symbol,Period(),SERIES_LASTBAR_DATE)
      Sleep(5000);
     }
//--- bars are synchronized
   synchonized=true;
   PrintFormat("Open bar time of the chart symbol %s: is %s",_Symbol,TimeToString(last_bar_time));
   PrintFormat("Open bar time of the symbol %s: is %s",other_symbol,TimeToString(other_time));
//--- TimeCurrent() is not useful, use TimeTradeServer()
   Print("The bars are synchronized at ",TimeToString(TimeTradeServer(),TIME_SECONDS));
  }
//+------------------------------------------------------------------+

Si noti l'ultima riga dell'EA che mostra l'orario corrente in cui è stato stabilito il fatto della sincronizzazione:

   Print("The bars synchronized at ",TimeToString(TimeTradeServer(),TIME_SECONDS));

Per visualizzare l'orario corrente, abbiamo usato la funzione TimeTradeServer() anziché TimeCurrent(). TimeCurrent() restituisce l'orario dell'ultimo tick che non cambia dopo l'utilizzo di Sleep(). Esegui l'EA in modalità "Solo Prezzi di Apertura" e vedrai un messaggio relativo alla sincronizzazione delle barre.


Usiamo la funzione TimeTradeServer() al posto di TimeCurrent(), se è necessario per ottenere l'ora corrente del server, e non il tempo di arrivo dell'ultimo tick.

C'è un altro modo per sincronizzare le barre - utilizzando un timer. Un esempio di tale EA è Synchronize_Bars_Use_OnTimer.mq5 che è allegato a questo articolo.


La funzione IndicatorRelease() nel Tester

Dopo aver completato un testing singolo, viene aperto automaticamente un grafico dello strumento che mostra le operazioni completate e gli indicatori utilizzati per l'EA. Ciò aiuta a controllare visivamente i punti di entrata ed uscita e a confrontarli con i valoridegli indicatori.  

Nota: gli indicatori, mostrati sul grafico, che si aprono automaticamente dopo il completamento del test, vengono calcolati nuovamente dopo il completamento del test. Anche se questi indicatori sono stati utilizzati nell'EA testato.

Tuttavia in alcuni casi, il programmatore può decidere di nascondere le informazioni su cui sono stati coinvolti gli indicatori negli algoritmi di trading. Ad esempio, il codice dell’EA è in affitto o viene venduto come un file eseguibile, senza che venga fornito il codice sorgente. A questo scopo, la funzione IndicatorRelease() è adatta.

Se il terminale imposta un template con il nome tester.tpl nella directory /profiles/templates del client terminal, allora sarà applicato al grafico aperto. In sua assenza, viene applicato il template predefinito. (default.tpl).

La funzione IndicatorRelease() è originariamente prevista per rilasciare la porzione di calcolo dell'indicatore se non è più necessaria. Ciò ti permette di salvare sia la memoria che le risorse della CPU, perché ogni tick richiede un calcolo dell'indicatore. Il suo secondo obiettivo - è quello di vietare la visualizzazione di un indicatore sul grafico di testing, dopo una test run singola.

Per proibire la visualizzazione dell'indicatore sul grafico dopo il testing, chiamare l’IndicatorRelease() con l'handle dell'indicatore nell'handler OnDeinit(). La funzione OnDeinit() viene sempre chiamata dopo il completamento e prima della visualizzazione del grafico di testing.

//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
//---
   bool hidden=IndicatorRelease(handle_ind);
   if(hidden) Print("IndicatorRelease() successfully completed");
   else Print("IndicatorRelease() returned false. Error code ",GetLastError());
  }
Per impedire che l'indicatore venga mostrato sul grafico, dopo il completamento di un singolo test, utilizzare la funzione IndicatorRelease() nell'handler OnDeinit().


Gestione degli eventi nel Tester

La presenza dell'handler OnTick() nell' EA non è obbligatoria per essere sottoposta a testing su dati storici nel tester MetaTrader 5. È sufficiente che l'EA contenga almeno uno dei seguenti gestori di funzioni:

  • OnTick() - Gestore eventi dell’arrivo di un nuovo tick;
  • OnTrade() - Gestore di eventi di trading;
  • OnTimer() - Gestore dell’evento dell'arrivo di un segnale dal timer;
  • OnChartEvent () - un gestore per gli eventi del client.

Durante il testing in un EA, siamo in grado di gestire gli eventi personalizzati utilizzando la funzione OnChartEvent() ma negli indicatori questa funzione non può essere chiamata nel tester. Anche se l'indicatore ha il gestore degli eventi OnChartEvent() e questo indicatore è utilizzato nell’EA testato, l'indicatore stesso non riceverà alcun evento personalizzato.

Durante il testing, un Indicatore può generare eventi personalizzati utilizzando la funzione EventChartCustom() e l'EA può elaborare questo evento nell'OnChartEvent().


Agenti di Testing

Il testing nel client terminal MetaTrader 5 vengono eseguiti utilizzando agenti di testing. Gli agenti locali vengono creati ed abilitati automaticamente. Il numero predefinito di agenti locali corrisponde al numero di core in un computer.

Ogni agente di testing ha la propria copia della variabili globali che non è correlata al client terminal. Il terminale stesso è il dispensatore che distribuisce le attività agli agenti locali e remoti. Dopo aver eseguito un’attività sul testing di un EA, con i parametri specificati, l'agente restituisce i risultati al terminale. Con un singolo test, viene utilizzato un solo agente.

L'agente memorizza la cronologia, ricevuta dal terminale, in cartelle separate, col nome dello strumento, in modo che la cronologia per EURUSD viene memorizzata in una cartella denominata EURUSD. Inoltre, la cronologia degli strumenti è separata dalle loro fonti. La struttura per memorizzare la cronologia appare come segue:

tester_catalog\Agent-IPaddress-Port\bases\name_source\history\symbol_name

Ad esempio, la cronologia per EURUSD dal server MetaQuotes-Demo può essere memorizzata nella cartella tester_catalog\Agent-127.0.0.1-3000\bases\MetaQuotes-Demo\EURUSD.

Un agente locale, dopo il completamento del testing, entra in una modalità di stand-by, in attesa di una nuova attività per altri 5 minuti, in modo da non perdere tempo per avviare per la chiamata successiva. Solo dopo che il periodo di attesa è finito, l'agente locale si spegne e si scarica dalla memoria della CPU.

In caso di un precoce completamento del testing, da parte dell'utente (il pulsante "Annulla"), nonché con la chiusura del client terminale, tutti gli agenti locali interrompono immediatamente il loro lavoro e vengono scaricati dalla memoria.


Lo Scambio di Dati tra il Terminale e l'Agente

Quando si esegue un test, il client terminal si prepara per inviare all'agente un certo numero di blocchi di parametri:
  • I parametri di input per il testing (modalità di simulazione, l'intervallo di testing, strumenti, criteri di ottimizzazione, ecc.)
  • L'elenco dei simboli selezionati nel "Market Watch"
  • La specifica del simbolo di testing (la dimensione del contratto, i margini consentiti dal mercato per l'impostazione di un StopLoss e Takeprofit, ecc)
  • L’Expert Advisor testato ed i valori ​dei suoi parametri di input
  • Informazioni sui file aggiuntivi (librerie, indicatori, file di dati - # property tester_ ...)

    tester_indicator

    string

    Nome di un indicatore personalizzato nel formato indicator_name.ex5". Gli indicatori che richiedono il testing vengono definiti automaticamente dalla chiamata della funzione iCustom(), se il parametro corrispondente è impostato attraverso la costante stringa. Per tutti gli altri casi (utilizzo della funzione IndicatorCreate() o uso di una stringa non costante nel parametro che imposta il nome dell' indicatore) questa proprietà è obbligatoria

    tester_file

    string

    Nome file per un tester con l'indicazione di estensione, tra virgolette (come una stringa costante). Il file specificato verrà passato al tester. I file di input da testare, se ci sono quelli necessari, devono sempre essere specificato..

    tester_library

    string

    Nome della libreria con l'estensione, tra virgolette. Una libreria può avere estensione dll o ex5. Le librerie che richiedono i testing vengono definite automaticamente. Tuttavia, se una delle librerie viene utilizzata da un indicatore personalizzato, questa proprietà è necessaria

Per ogni blocco di parametri, un'impronta digitale in forma di hash-MD5 viene creata e viene inviata all'agente. MD5-hash è univoca per ciascun set, il suo volume è molte volte più piccolo della quantità di informazioni sulla quale viene calcolato.

L'agente riceve un hash di blocchi e li confronta con quelli che ha già. Se l'impronta digitale del blocco dei parametri dato non è presente nell'agente o l'hash ricevuto è diverso da quello esistente, l'agente richiede questo blocco di parametri. Questo riduce il traffico tra il terminale e l'agente.

Dopo il testing, l'agente restituisce al terminale di tutti i risultati della run che sono indicati nel tab "Risultati del Test" e "Risultati dell’Ottimizzazione": il profitto ricevuto, il numero di operazioni, il coefficiente Sharpe, il risultato della funzione OnTester(), ecc

Durante l'ottimizzazione, il terminale spedisce i compiti di testing agli agenti in piccoli pacchetti, ogni pacchetto contenente diversi compiti (per ogni compito si intende ogni attività di testing singolo con una serie di parametri di input). Questo riduce il tempo di scambio tra il terminale e l'agente.

Gli agenti non registrano mai sull'hard disk i file EX5, ottenuti dal terminale (EA, indicatori, librerie, ecc) per motivi di sicurezza, di modo che un computer con un agente in esecuzione non può utilizzare i dati inviati. Tutti gli altri file, tra cui le DLL, sono registrati nella sandbox. Negli agenti remoti non puoi testare l’EA utilizzando le DLL.

I risultati dei testing vengono sommati dal terminale in una cache speciale dei risultati (i risultati della cache), per un accesso rapido ad essi quando sono necessari. Per ogni insieme di parametri, il terminale ricerca i risultati della cache già disponibili dalle run precedenti al fine di evitare repliche. Se il risultato con un insieme di parametri non viene trovato, all'agente viene dato il compito di eseguire il testing.

Tutto il traffico tra il terminale e l'agente è crittografato.


Uso della Cartella Condivisa di Tutti i Client Terminal

Tutti gli agenti di testing sono isolati gli uni dagli altri e dal client terminal: ogni agente ha una propria cartella in cui sono registrati i suoi log. Inoltre, tutte le operazioni di file durante il testing dell'agente si verificano nella cartella agent_name/MQL5/Files. Tuttavia, siamo in grado di realizzare l'interazione tra gli agenti locali ed il client terminal mediante una cartella condivisa per tutti i client terminal, se durante l'apertura del file si specifica il flag FILE_COMMON:

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- the shared folder for all of the client terminals
   common_folder=TerminalInfoString(TERMINAL_COMMONDATA_PATH);
//--- draw out the name of this folder
   PrintFormat("Open the file in the shared folder of the client terminals %s", common_folder);
//--- open a file in the shared folder (indicated by FILE_COMMON flag)
   handle=FileOpen(filename,FILE_WRITE|FILE_READ|FILE_COMMON);
   ... further actions
//---
   return(0);
  }


Utilizzo delle DLL

Per accelerare l'ottimizzazione possiamo utilizzare non solo locale, ma anche agenti remoti. In questo caso, ci sono alcune limitazioni per gli agenti remoti. Prima di tutto, gli agenti remoti non mostrano nei loro log i risultati dell'esecuzione della funzione Print(), messaggi sull’apertura e la chiusura delle posizioni. Una minima quantità di informazioni viene visualizzata nel log per evitare che gli EA scritti in modo scorretto possano danneggiare il computer su cui l'agente di rimozione è in funzione con i messaggi.

Una seconda limitazione - il divieto di utilizzo di DLL durante il testing degli EA. Le chiamate DLL sono assolutamente vietate su agenti remoti per motivi di sicurezza. Nell’ agente locale, le chiamate DLL negli EA testati sono ammesse solo con l'autorizzazione specifica "Consenti Importazione DLL".

Fig. 10. L'opzione "Consenti Importazione DLL" nei programmi MQL5

Nota:Quando si utilizza la ricezione dall’EA (script, indicatori) che richiedono il permesso di chiamate DLL, devi essere consapevole dei rischi che ti assumi quando consenti questa opzione nelle impostazioni del terminale. Indipendentemente da come sarà utilizzato l’EA - per il testing o per l'esecuzione su un grafico.


Conclusione

L'articolo tratta le basi, la cui conoscenza ti aiuterà a padroneggiare rapidamente il testing degli EA nel client terminal MetaTrader 5:

  • Tre modalità di generazione di tick;
  • Calcolo dei valori degli indicatori ​durante il testing;
  • Testing Multi-Valuta;
  • Simulazione del tempo durante il testing;
  • Il lavoro delle funzioni OnTimer(), OnSleep() e IndicatorRelease() nello Strategy Tester;
  • Il lavoro degli agenti di testing durante le chiamate DLL;
  • Usare la cartella condivisa per tutti i client terminal;
  • La sincronizzazione delle barre nella modalità "Solo prezzi di apertura";
  • Gestione degli eventi.

Il compito principale dello Strategy Tester del client terminal è quello di garantire l'accuratezza richiesta dei dati con il minimo sforzo da parte del programmatore di MQL5. Gli sviluppatori hanno fatto molto in modo che tu non abbia dovuto riscrivere il tuo codice solo per testare la tua strategia di trading su dati storici. È sufficiente conoscere le basi del testing ed un EA scritto correttamente funzionerà allo stesso modo nel tester e nella modalità online sul grafico.


Tradotto dal russo da MetaQuotes Ltd.
Articolo originale: https://www.mql5.com/ru/articles/239

MQL5 Wizard: Nuova Versione MQL5 Wizard: Nuova Versione
L'articolo contiene le descrizioni delle nuove funzionalità disponibili in MQL5 Wizard aggiornato. L'architettura modificata dei segnali consente di creare robot di trading basati sulla combinazione di vari modelli di mercato. L'esempio contenuto nell'articolo spiega la procedura di creazione interattiva di un Expert Advisor.
Eventi di Trade in MetaTrader 5 Eventi di Trade in MetaTrader 5
Un monitoraggio dello stato corrente di un account di trading implica il controllo delle posizioni e degli ordini aperti. Prima che un segnale di trading diventi un deal, deve essere inviato dal client terminal come richiesta al server di trading, dove verrà inserito nella coda degli ordini in attesa di essere elaborato. Accettando una richiesta dal server di trading, cancellandola mentre scade o conducendo un deal sulla sua base - tutte queste azioni vengono seguite da eventi di trading, e il server di trading informa il terminale su di essi.
Controlli Grafici Personalizzati. Parte 1: Creazione di un Controllo Semplice Controlli Grafici Personalizzati. Parte 1: Creazione di un Controllo Semplice
Questo articolo tratta i principi generali di sviluppo dei controlli grafici. Prepariamo strumenti per un lavoro rapido e conveniente con oggetti grafici, analizzeremo un esempio di creazione di un semplice controllo per l'inserimento di testo o dati numerici e le sue modalità di utilizzo.
Ordini, Posizioni e Deal in MetaTrader 5 Ordini, Posizioni e Deal in MetaTrader 5
La creazione di un solido robot di trading non può essere eseguita senza una comprensione dei meccanismi del sistema di trading MetaTrader 5. Il client terminal riceve le informazioni su posizioni, ordini e deal dal server di trading. Per gestire correttamente questi dati utilizzando l'MQL5, è necessario avere una buona comprensione dell'interazione tra il programma MQL5 e il client terminal.