Share
I mercati finanziari del mondo ti offrono un enorme potenziale di profitti e perdite. C'è sempre un potenziale di profitto nel mercato in quanto è possibile inserire scambi in entrambe le direzioni. Sia che la tua posizione sia rialzista o ribassista, la possibilità per il trader di fare soldi è sempre presente, così come la capacità di fare una perdita.
Troppo spesso, le emozioni, le trappole mentali psicologiche e la disciplina mentale ostacolano i profitti e sono le ragioni principali 95% (o Di Più) di tutti i nuovi operatori perdono tutto il loro capitale d'investimento nel primo mese.
L'utilizzo di un algoritmo di negoziazione di algoritmi Expert Advisor in Meta Trader scritto in linguaggio MQL4 è un modo per accedere al mercato tramite codice, eliminando le emozioni e lavorando con i numeri e la logica del programma.
Prendere le emozioni dall'equazione è una misura, ma questo non significa che i robot non possono perdere. In effetti, anche le grandi banche d'investimento hanno dovuto staccare la spina dai loro robot commerciali prima che la perdita diventasse fatale. Nel 2013, Goldman Sachs ha avuto gravi errori nei suoi algoritmi di trading che costano $ 100 milioni.
È necessario essere consapevoli, prima di continuare con questa guida e anche contemplando l'utilizzo del proprio contanti veri e sudati, che puoi perdere tutti il tuo deposito nel tuo conto di brokeraggio dal tuo codice (e forse nel peggiore dei casi più con alcuni broker se si applicano tariffe aggiuntive)
In ultima analisi, sei responsabile delle operazioni, anche se il codice del programma le sta posizionando per te. Mentre la perdita è una possibilità, puoi anche moltiplicare l'account e farlo crescere in modo esponenziale mentre dormi.
Se ti piace eseguire completamente su pilota automatico, questo potrebbe essere raggiunto senza alcuna interazione. Potresti letteralmente fare soldi passivamente mentre continui nella tua vita di tutti i giorni.
Questa strategia di trading totalmente a mani libere è non uno che promuovo - né è uno che io abbia mai usato e che abbia mai trovato redditizio. Monitorare un robot attivo e le negoziazioni in corso, insieme a tenere d'occhio il calendario economico e gli eventi, è molto diverso dal lasciarlo libero e sperare per il meglio. Le vittorie possono essere epiche, ma le perdite incustodite sono di gran lunga più grandiose.
Scarica MT4 dal loro sito Web e installalo sul tuo computer.
Una volta che MT4 è in esecuzione, avrai bisogno di un account con un broker che supporti MT4. Saranno quindi in grado di darti le tue credenziali di accesso MT4.
Tutti i broker offriranno un account demo e sarai incoraggiato a utilizzare sempre l'account demo per scrivere e testare il tuo software.
Una volta configurato MT4 sul desktop, possiamo continuare a creare il nostro robot di negoziazione dell'algoritmo Expert Advisor.
Ci sono molte lingue che sarebbero adatte per scrivere un algoritmo di trading robot da zero, ma le complicazioni che incontrerai sono in effetti con l'API per dirigere l'accesso al mercato che il tuo broker azionario fornirà - è così che ti permetterai effettivamente di posizionare gli ordini commerciali nei mercati finanziari.
I dati del mercato di elaborazione potrebbero essere raggiunti in una pletora di lingue e probabilmente in misura maggiore rispetto a MT4 MQL4 è in grado di eseguire test (i test retrospettivi sono un modo per testare il robot dell'algoritmo, di cui parleremo più avanti). Per ragioni di facilità di funzionalità e supporto generale per il software finanziario, consiglio vivamente di utilizzare MQL4 (MetaQuotes Language 4), la lingua madre di MetaTrader 4, per scrivere il tuo robot trading algoritmico.
MQL4 è simile nella sua forma a PHP, C, C ++ o VBScript. Di seguito è riportato un esempio di una funzione che verrà chiamata su ogni tick di dati di mercato:
void OnTick () if (Bars<100 || IsTradeAllowed()==false) return; if(CalculateCurrentOrders(Symbol())==0) CheckForOpen(); else CheckForClose();
Qui controlliamo se sono stati caricati abbastanza dati di mercato Barre < 100. MQL4 imposta variabili predefinite come Bar (che contiene il numero di barre caricate nel grafico).
Inoltre, controlliamo con un o || condizionale per IsTradeAllowed (). Questa è una funzione di controllo per verificare che il contesto di trading non sia attualmente occupato.
Elementi di MQL4 come queste variabili predefinite e funzioni di gestione del grafico come Symbol () rendono la scrittura della strategia una passeggiata nel parco, e per me è il motivo per cui è davvero preferibile codificare robot di algoritmo in MQL4 su altre lingue.
Vi consiglio di dare un'occhiata al Riferimento MQL4 ogni volta che avete il tempo di acquisire maggiore sicurezza nell'utilizzo di MQL4 per soddisfare ulteriormente le vostre esigenze.
Raccomando di utilizzare l'IDE MetaEditor integrato fornito con la piattaforma di trading MT4. Per accedere all'editor, è sufficiente fare clic con il pulsante destro del mouse su un consulente esperto esistente nel riquadro sinistro del navigatore e selezionare modificare dal menu.
Il MetaEditor di MT4 si aprirà e sarai in grado di creare un nuovo file. Questo offre l'evidenziazione della sintassi dell'utente e l'output di debug.
Importante: Dovrai compilare i tuoi file mq4 in consulenti esperti ex4 utilizzando MetaEditor se stai modificando un editor esterno. Quindi acquisire familiarità con MetaEditor è un must.
Per la nostra strategia, inizieremo a utilizzare una base di supporto e resistenza dal SMA (Smoothed MOving UNverage). La SMA può prevedere un segnale di entrata / uscita rialzista o ribassista. La media mobile arrotondata ci aiuta a ridurre il rumore dal mercato, offrendoci una visione più chiara della direzione dell'azione dei prezzi.
In una tendenza al rialzo o al ribasso, la SMA può comportarsi come supporto o resistenza, a seconda dell'orientamento. Quando il prezzo sale, SMA si comporta come un piano di supporto, e quando il prezzo è in calo, viceversa come resistenza / massimale.
Quando tracciamo due SMA di periodi diversi, uno di un periodo di 40 e uno di un periodo di 100, possiamo vedere come si incrociano e creare una base per l'ingresso. Come accennato in precedenza, quando SMA è inferiore al prezzo (inferiore al prezzo di chiusura), lo consideriamo una base per supporto, e quando SMA è superiore al prezzo (maggiore del prezzo di chiusura), consideriamo questa una linea di resistenza.
Quindi, nel codice, facciamo quanto segue prima di creare un metodo per controllare il cross-over degli input per determinare in seguito la nostra base per l'immissione:
// + ----------------------------------------------- ------------------- + // | Controllare la sovrapposizione degli input | // + ----------------------------------------------- ------------------- + int CheckForCross (double input1, double input2) static int previous_direction = 0; static int current_dirction = 0; // Up Direction = 1 if (input1> input2) current_direction = 1; // Down Direction = 2 if (input1 < input2) current_direction = 2; // Detect a direction change if(current_direction != previous_direction) previous_direction = current_dirction; return (previous_direction); else return (0);
Ora possiamo calcolare la nostra SMA utilizzando il metodo di indicatore tecnico iMA fornito da MQL4 e gestirlo tramite il nostro CheckForCross funzione per vedere se c'è stata una croce in questo modo:
shortSma = iMA (NULL, 0, PeriodOne, 0, MODE_SMMA, PRICE_CLOSE, 0); longSma = iMA (NULL, 0, PeriodTwo, 0, MODE_SMMA, PRICE_CLOSE, 0); // Controlla se c'è stato un cross su questo tick dai due SMA int isCrossed = CheckForCross (shortSma, longSma);
Qui stiamo usando il MODE_SMMA per restituirci il Smoothed MOving UNverage dal io sono un metodo indicatore tecnico per il nostro metodo di livellamento scelto.
Se si desidera utilizzare un altro metodo di livellamento, ci sono diverse scelte come Semplice, Esponenziale e Ponderata lineare.
Come con tutto il supporto e la resistenza, la metodologia di trading standard funziona qui: comprare supporto e vendere resistenza!
Quindi, per il nostro algoritmo, faremo proprio questo. Quando c'è una croce in entrambe le direzioni, applicheremo la direzione appropriata del commercio e entreremo nel mercato.
Accentsconagua
f (isCrossed == 1) ticket = OrderSend (Symbol (), OP_BUY, LotsOptimized (), Ask, 3,0,0, "Double SMA Crossover", MAGICNUM, 0, Blue); if (ticket> 0) if (OrderSelect (ticket, SELECT_BY_TICKET, MODE_TRADES)) Stampa ("BUY Order Opened:", OrderOpenPrice ()); else Stampa ("Errore nell'apertura dell'ordine BUY:", GetLastError ()); ritorno (0); if (isCrossed == 2) ticket = OrderSend (Symbol (), OP_SELL, LotsOptimized (), Ask, 3,0,0, "Double SMA Crossover", MAGICNUM, 0, Blue); if (ticket> 0) if (OrderSelect (ticket, SELECT_BY_TICKET, MODE_TRADES)) Stampa ("Ordine di vendita aperto:", OrderOpenPrice ()); else Stampa ("Errore nell'apertura dell'ordine di vendita:", GetLastError ()); ritorno (0); Qui controlliamo il ritorno di CheckForCross funzione definita prima, dopo averla caricata con i nostri due SMA definiti dal io sono un indicatore tecnico.
Noi usiamo OrderSend, che è fornito da MQL4, per aprire il trade. Come best practice, il risultato è memorizzato nel file biglietto variabile e successivamente controllato per un valore di ritorno positivo in modo da gestire eventuali errori che potrebbero essere stati segnalati dal lato del broker.
Come la base per l'ingresso (tranne nel caso inverso), quando la SMA crea una croce della morte, possiamo usare questo segnale per la chiusura del nostro commercio, se tutte le operazioni sono aperte. La logica per questo sarebbe scritta così:
// Ottieni gli ordini totali correnti totali = OrdersTotal (); // Gestisci gli ordini aperti per i criteri di uscita per (cnt = 0; cnt < total; cnt++) OrderSelect(cnt, SELECT_BY_POS, MODE_TRADES); if(OrderType() <= OP_SELL && OrderSymbol() == Symbol()) // Look for long positions if(OrderType()==OP_BUY) // Check for Exit criteria on buy - change of direction if(isCrossed == 2) OrderClose(OrderTicket(), OrderLots(), Bid, 3, Violet); // Close the position return(0); else //Look for short positions - inverse of prior conditions // Check for Exit criteria on sell - change of direction if(isCrossed == 1) OrderClose(OrderTicket(), OrderLots(), Ask, 3, Violet); // Close the position return(0);
Qui entriamo a per loop per iterare su tutti gli ordini aperti, anche se al momento scambiamo solo uno scambio alla volta, questo ci permette di espanderci in futuro e avere più operazioni aperte se sentiamo di averne bisogno.
Questo rende anche più facile l'uso del metodo OrderSelect, dato che possiamo usare il cnt variabile dal nostro per ciclo continuo.
Una volta dentro l'iterazione, osserviamo semplicemente l'OrderType corrente (controllando per a Acquistare OP_BUY o Vendere OP_SELL ordine) e quindi applicare la logica condizionale dal ritorno del nostro CheckForCross metodo.
In questo momento il nostro algoritmo è semplice con una base per l'ingresso e l'uscita di mestieri, ma ancora abbastanza pericolosamente stupido quando si tratta di gestione dei fondi. Per mantenere il rischio sotto controllo, metteremo solo un quinto del patrimonio negoziabile su ogni trade, quindi ora è necessario includerlo nel nostro algoritmo.
lotto = NormalizeDouble ((AccountFreeMargin () / 5) /1000.0,1); se (lotto<0.1) lot=0.1; return(lot);
Ciò significa che se hai $ 10.000 nel conto, scambiamo solo con un quinto alla volta ($ 2.000), quindi lo script inserirà uno scambio solo con un lotto di dimensioni più piccole di 0.1 o 0.2, ad esempio, basato su questo quinta di calcolo.
Usiamo AccountFreeMargin e NormalizeDouble per generare questa dimensione del lotto, e se è calcolato al di sotto della dimensione minima del lotto di 0.1, lo imposteremo a 0.1.
Man mano che l'account cresce (o si restringe!), L'esposizione verrà impostata solo a un quinto del patrimonio netto dell'account. Ciò significa che la sovraesposizione di un importo fisso (ad esempio, la negoziazione di un lotto fisso specifico su un qualsiasi account di dimensioni) non può avvenire teoricamente, quindi il rischio di una richiesta di margini da un eccesso di trading viene rimosso o notevolmente ridotto.
La chiamata a margine è un rischio molto reale se il mercato si muove contro di te drasticamente prima di tornare a causa di un picco / fluttuazione mentre non sei in giro per depositare più fondi.
In parole povere, verrà calcolata la dimensione del lotto del commercio dinamicamente dal nostro script per soddisfare le dimensioni del capitale. Quindi il potenziale per profitti sempre più grandi è molto reale.
Nota: Una caratteristica interessante potrebbe essere quella di fornire un parametro per limitare il pool negoziabile. Ad esempio, se desideri scambiare solo con $ 1.000 del tuo account, indipendentemente dal margine disponibile, puoi impostare il negoziabile disponibile a soli $ 1.000 anziché l'intera dimensione dell'account.
Personalmente uso sempre funzioni come questa quando vado a vivere con nuovi script per ridurre la mia esposizione al rischio, fino a quando sono davvero sicuro che la sceneggiatura funzioni in modo abbastanza solido da consentire più fondi.
A livello di codice, ciò richiede un parametro e una leggera modifica all'esempio di codice sopra riportato per verificare la presenza di tale variabile anziché del AccountFreeMargin () valore.
Inoltre, tenteremo di eseguire alcune situazioni di pareggio, il che significa che se il mercato è cambiato contro di noi per creare una perdita sostanziale dall'apertura, cerchiamo di uscire con una perdita minima e almeno in pareggio per mantenere il nostro capitale.
Ciò può essere ottenuto monitorando la perdita del nostro commercio e la relazione con il prezzo aperto. Se la direzione cambia e il nostro commercio viene lasciato fuori dai soldi, possiamo tentare di chiudere il commercio il più vicino possibile al prezzo di entrata:
bool BreakEven (int MN) int Ticket; for (int i = OrdersTotal () - 1; i> = 0; i--) OrderSelect (i, SELECT_BY_POS, MODE_TRADES); if (OrderSymbol () == Symbol () && OrderMagicNumber () == MN) Ticket = OrderModify (OrderTicket (), OrderOpenPrice (), OrderOpenPrice (), OrderTakeProfit (), 0, Green); if (Ticket < 0) Print("Error in Break Even : ", GetLastError()); break; return(Ticket); Quanto sopra utilizza OrderModify per tentare di impostare lo stop loss al prezzo di apertura dell'ordine. Questo è un metodo semplice ma semplice per garantire che usciamo quando il prezzo ritorna al nostro prezzo di entrata. Questo viene applicato solo quando l'utile non realizzato corrente è in perdita.
Un margine per il pareggio potrebbe essere aggiunto semplicemente aggiungendo al OrderOpenPrice metodo in questo modo:
Ticket = OrderModify (OrderTicket (), OrderOpenPrice (), OrderOpenPrice () + 10, OrderTakeProfit (), 0, Green);
Per questo esempio, consentiamo una differenza di 10 punti nel nostro ingresso alla chiusura tramite stop limit.
Nota: La direzione commerciale deve essere controllata per questo metodo, come se debba essere aggiunto o sottratto dal prezzo di entrata a seconda che si tratti di una posizione di acquisto o di vendita.
Un altro modo per garantire che i nostri guadagni non vengano persi consiste nell'utilizzare un trailing stop, che verrà discusso in dettaglio in un'altra guida.
Ecco l'elenco completo per il nostro consulente esperto. Disponiamo di diversi parametri a nostra disposizione, come il livello di profitto take, lo stop loss e i periodi SMA.
Sentiti libero di giocare con i parametri per vedere cosa funziona meglio per la tua situazione di trading e mettere a punto il tuo algoritmo.
Ricorda: le performance passate non sono in alcun modo indicative del futuro.
// + ----------------------------------------------- ------------------- + // | Double Sma.mq4 | // | Copyright 2017, Tom Whitbread. | // | http://www.gript.co.uk | // + ----------------------------------------------- ------------------- + #property copyright "2017, Tom Whitbread." #property link "http://www.gript.co.uk" #property description "Smoothed Moving Average expert advisor" #define MAGICNUM 20131111 // Definisci i nostri parametri input double Lots = 0.1; input int PeriodOne = 40; // Il periodo per il primo input SMA int PeriodTwo = 100; // Il periodo per il secondo input SMA int TakeProfit = 40; // Il take profit level (0 disable) input int StopLoss = 0; // Lo stop loss predefinito (0 disabilita) // + ------------------------------------- ----------------------------- + // | funzioni di inizializzazione di esperti | // + ----------------------------------------------- ------------------- + int init () return (0); int deinit () return (0); // + ---------------------------------------------- -------------------- + // | Verificare l'incrocio di SMA | // + ----------------------------------------------- ------------------- + int CheckForCross (double input1, double input2) static int previous_direction = 0; static int current_direction = 0; // Up Direction = 1 if (input1> input2) current_direction = 1; // Down Direction = 2 if (input1 < input2) current_direction = 2; // Detect a direction change if(current_direction != previous_direction) previous_direction = current_direction; return (previous_direction); else return (0); //+------------------------------------------------------------------+ //| Calculate optimal lot size | //+------------------------------------------------------------------+ double LotsOptimized() double lot = Lots; // Calculate Lot size as a fifth of available free equity. lot = NormalizeDouble((AccountFreeMargin()/5)/1000.0,1); if(lot<0.1) lot=0.1; //Ensure the minimal amount is 0.1 lots return(lot); //+------------------------------------------------------------------+ //+ Break Even | //+------------------------------------------------------------------+ bool BreakEven(int MN) int Ticket; for(int i = OrdersTotal() - 1; i >= 0; i--) OrderSelect (i, SELECT_BY_POS, MODE_TRADES); if (OrderSymbol () == Symbol () && OrderMagicNumber () == MN) Ticket = OrderModify (OrderTicket (), OrderOpenPrice (), OrderOpenPrice (), OrderTakeProfit (), 0, Green); if (Ticket < 0) Print("Error in Break Even : ", GetLastError()); break; return(Ticket); //+------------------------------------------------------------------+ //+ Run the algorithm | //+------------------------------------------------------------------+ int start() int cnt, ticket, total; double shortSma, longSma, ShortSL, ShortTP, LongSL, LongTP; // Parameter Sanity checking if(PeriodTwo < PeriodOne) Print("Please check settings, Period Two is lesser then the first period"); return(0); if(Bars < PeriodTwo) Print("Please check settings, less then the second period bars available for the long SMA"); return(0); // Calculate the SMAs from the iMA indicator in MODE_SMMA using the close price shortSma = iMA(NULL, 0, PeriodOne, 0, MODE_SMMA, PRICE_CLOSE, 0); longSma = iMA(NULL, 0, PeriodTwo, 0, MODE_SMMA, PRICE_CLOSE, 0); // Check if there has been a cross on this tick from the two SMAs int isCrossed = CheckForCross(shortSma, longSma); // Get the current total orders total = OrdersTotal(); // Calculate Stop Loss and Take profit if(StopLoss > 0) ShortSL = Bid + (StopLoss * Point); LongSL = Ask- (StopLoss * Point); if (TakeProfit> 0) ShortTP = Bid- (TakeProfit * Point); LongTP = Ask + (TakeProfit * Point); // Apri solo uno scambio alla volta ... se (totale < 1) // Buy - Long position if(isCrossed == 1) ticket = OrderSend(Symbol(), OP_BUY, LotsOptimized(),Ask,5, LongSL, LongTP, "Double SMA Crossover",MAGICNUM,0,Blue); if(ticket > 0) if (OrderSelect (ticket, SELECT_BY_TICKET, MODE_TRADES)) Stampa ("ACQUISTA ordine aperto:", OrderOpenPrice (), "SL:", LongSL, "TP:", LongTP); else Stampa ("Errore nell'apertura dell'ordine BUY:", GetLastError ()); ritorno (0); // Vendi - Posizione corta se (isCrossed == 2) ticket = OrderSend (Symbol (), OP_SELL, LotsOptimized (), Bid, 5, ShortSL, ShortTP, "Double SMA Crossover", MAGICNUM, 0, Red); if (ticket> 0) if (OrderSelect (ticket, SELECT_BY_TICKET, MODE_TRADES)) Stampa ("Ordine di vendita aperto:", OrderOpenPrice (), "SL:", ShortSL, "TP:", ShortTP); else Stampa ("Errore nell'apertura dell'ordine di vendita:", GetLastError ()); ritorno (0); // Gestisci gli ordini aperti per i criteri di uscita per (cnt = 0; cnt < total; cnt++) OrderSelect(cnt, SELECT_BY_POS, MODE_TRADES); if(OrderType() <= OP_SELL && OrderSymbol() == Symbol()) // Look for long positions if(OrderType() == OP_BUY) // Check for Exit criteria on buy - change of direction if(isCrossed == 2) OrderClose(OrderTicket(), OrderLots(), Bid, 3, Violet); // Close the position return(0); else //Look for short positions - inverse of prior conditions // Check for Exit criteria on sell - change of direction if(isCrossed == 1) OrderClose(OrderTicket(), OrderLots(), Ask, 3, Violet); // Close the position return(0); // If we are in a loss - Try to BreakEven Print("Current Unrealized Profit on Order: ", OrderProfit()); if(OrderProfit() < 0) BreakEven(MAGICNUM); return(0); 
Possiamo testare con facilità i giorni, i mesi o anche gli anni precedenti di dati di mercato per uno strumento finanziario nell'ambiente MT4 (Meta Trader 4). Tuttavia, i commercianti sono incoraggiati a non fidarsi dei test retrospettivi solo, ma usarlo come guida per orientare la propria strategia di trading e vedere quanto sia efficace un'idea.
I test retrospettivi consentono ai trader di verificare se il loro pensiero tiene acqua, per così dire, prima di impegnarsi di più e andare avanti, scrivendo più del loro algoritmo in codice.
Se hai utilizzato un editor di testo esterno per scrivere il tuo consulente, dovrai caricare il tuo consulente esperto nella piattaforma di trading MT4 per compilarlo e controllare gli errori. Basta aggiungere il file .mq4 all'installazione di MetaTrader nella directory Expert, ad es. / MetaTrader4 / MQL4 / Esperti.
L'Expert Advisor sarà quindi disponibile all'interno del tuo software MT4 dal menu Navigator sul lato sinistro sotto la sezione esperti.
Nota: Assicurati di testare su un account demo. Un conto reale sarà scambiato con denaro reale, e anche se i profitti saranno reali, anche le perdite.
Se hai testato una strategia sull'ultimo anno di cavo (GBP / USD) e hai trovato che il rapporto di profitto era superiore a 1 (il che significa che hai guadagnato denaro), allora potresti essere in una buona cosa.
Se questo si risolverà nel mondo reale è tutta un'altra questione, ed è il motivo per cui i test futuri sono ugualmente importanti, così come lo è il test del punteggio Z. Questo è un argomento molto più avanzato per l'apprendimento automatico del tuo algoritmo, che non sarà discusso qui, ma nelle guide più avanzate in seguito.
Usa la scorciatoia Controllo-R per aprire il tester di strategia o selezionarlo dal vista menu. Il riquadro del tester si aprirà nella parte inferiore della finestra.
Da qui, puoi selezionare l'algoritmo da eseguire nel primo menu a discesa, quindi scegli il nome file dell'advisor Expert che hai creato qui. Successivamente, puoi scegliere il simbolo (strumento finanziario). Proverò a testare il simbolo forex GBPUSD della coppia Sterlina Inglese / Dollaro USA.
Possiamo anche selezionare la risoluzione del periodo di tempo in cui eseguire (periodo di 15 minuti, periodo di 1 ora, periodo di 1 giorno e così via). Userò l'impostazione di 30 minuti.
Infine, abbiamo un'opzione per la modellazione Ogni segno di spunta, Punti di controllo, o Prezzi aperti solo. Mentre scrivi la tua sceneggiatura, puoi optare per Prezzi aperti solo, poiché eseguirà rapidamente il test, anche se i risultati non lo farà valga la pena di investire denaro reale su ancora!
Per questo, quando si sta cercando un vero test prima di andare avanti, si consiglia di continuare Ogni segno di spunta. Questo richiederà molto più tempo per l'elaborazione! (Puoi lasciarlo in esecuzione su MT4 VPN online o, naturalmente, durante la notte sul tuo computer locale, se lo desideri).
Impostiamo un paio di parametri (PeriodOne e PeriodTwo) Per il nostro consulente esperto in modo che i periodi di tempo delle due medie mobili possano essere modificati.
È possibile accedervi tramite il tester di strategia facendo clic su Proprietà esperte pulsante e visualizzazione del ingresso linguetta.
Qui è possibile fornire un valore numerico per ogni parametro: i valori predefiniti sono PeriodOne = 40 e PeriodTwo = 100.
Dopo aver testato i dati storici, puoi iniziare a testare con il mercato dal vivo, come hai già visto se le tue idee hanno superato la tempesta dal test retrospettivo e (si spera) aver trovato una certa fiducia in quella che ritieni essere una strategia vincente!
Nel mercato dal vivo, potresti scoprire che la tua strategia cade sul suo volto a causa di elementi che non hai preso in considerazione nei tuoi precedenti test retrospettivi. Ricorda il il mercato ha sempre ragione. Il tuo codice non è mai più intelligente del mercato e non esiste una cosa come essere fortunati nel trading.
Un test in avanti è davvero il test dell'acido per vedere se la strategia sarà proficua per voi per mettere soldi veri su di esso.
Il test in avanti viene solitamente eseguito meglio su una VPN dedicata per MT4 EA (Expert Advisors), che viene spesso fornita gratuitamente dalla maggior parte dei broker FX. Lo script verrà eseguito 24/5 mentre il mercato è aperto e sarai in grado di monitorare le transazioni dal vivo accedendo all'account da un terminale in quanto verrà eseguito sul tuo dispositivo mobile tramite l'app MT4 o computer desktop tramite il Software MT4.
Quello che può essere un vero killer per i nostri script è l'alta volatilità del mercato, che può verificarsi da molti fattori esterni.
Ad esempio, qualsiasi arresto anomalo o arresto anomalo, guerra, elezione, rialzo dei tassi di interesse, rendimenti obbligazionari o report economici significativi come l'IPC, il PIL o le modifiche al sistema fiscale causeranno grandi cambiamenti in tutta l'economia globale e nei suoi numerosi mercati finanziari . Quindi, anche indirettamente, il tuo commercio di una coppia di valute o di una sicurezza può essere influenzato da eventi di un altro paese, che potresti non aver previsto in un primo momento.
Più di recente, Brexit e in seguito l'indagine dell'FBI di Hillary Clinton durante la corsa alle elezioni negli Stati Uniti sono stati esempi di alta volatilità sul mercato per chiunque fosse interessato a dare un'occhiata più da vicino.
Prendiamo il caso di Brexit. Il pubblico britannico sembrava credere nella maggioranza che un voto sulla Brexit sarebbe altamente improbabile. Non ero così ottimista e ho tirato fuori tutti i miei chili, risparmiando molta della mia equity nel Regno Unito a causa del crollo del tasso di cambio.
Per quanto riguarda gli altri, ho paura di dire che non sono stati così fortunati. La copertura di un voto di soggiorno - come avevano affermato alcuni dei maggiori consulenti delle banche - avrebbe naturalmente provocato l'inversione e una perdita di circa il 15% per coloro che erano investiti nella sterlina, in attesa che si riprendesse.
Situazioni come questa sono l'ideale per spegnere il tuo robot di trading e negoziare solo al di fuori della volatilità del mercato. La codifica per questo tipo di risultati sarà molto difficile automaticamente per gli indicatori di anticipo o di ritardo e sarà meglio scambiata dopo l'evento o manualmente. Le possibilità di segnali falsi o contraddittori sono sempre più elevate durante i grandi eventi e un approccio manuale fondamentale piuttosto che tecnico può essere più proficuo.
Non c'è niente di sbagliato nel mettere in pausa il tuo robot perché ti stai aspettando una crisi. Potrebbe farti risparmiare una perdita, mentre d'altra parte potrebbe farti perdere un'enorme vittoria. Nella mia esperienza, le probabilità di vincita sono molto più ridotte, a causa dell'incertezza e della probabilità di una chiamata al margine o di uno stop loss prima che il trade possa progredire a causa di picchi estremi.
Abbiamo stabilito alcune delle basi per scrivere un algoritmo di trading e introdotto molte nuove idee. Passando attraverso il codice, spero che ora puoi vedere il funzionamento interno di un algoritmo in MQL4 e vedere come viene usato un indicatore tecnico come la media mobile per generare un segnale di ingresso e uscita.
In termini di gestione del denaro, abbiamo esaminato la possibilità di includere condizioni di pareggio e dimensionamento dinamico del lotto per utilizzare un quinto del patrimonio netto disponibile. Sentiti libero di modificare queste parti del codice per i tuoi desideri di rischio. Abbiamo esaminato il tester della strategia di back-testing di MT4 e abbiamo aperto le porte al potenziale dei test futuri e persino dei test Z-score in futuro, che sono tutti vitali prima di andare in diretta.
Con una messa a punto e una ricerca più approfondite, è possibile avere un'esperienza molto proficua nei mercati un giorno a breve. Ora che hai un buon consulente esperto di base come script di base, puoi iniziare a scrivere le tue strategie nel linguaggio MQL4 e testare se funzionano davvero bene come ritieni che dovrebbero, o come potrebbero esserlo alcuni libri di trading e mentori riferirsi a!
Andando avanti, vorrete sicuramente testare il vostro algoritmo prima di impegnarvi con denaro reale. Una volta che ti senti abbastanza sicuro di avere una sceneggiatura di buona esecuzione, potresti anche voler unirti a una comunità per portare le tue idee più avanti e aiutare a fare brainstorming, o mettere da parte altri algoritmi per vedere il loro funzionamento e come potresti incorporarli nella tua strategia.
Condividere consulenti esperti con altri trader è un ottimo modo per collaborare e vedere come gli altri stanno scrivendo il loro algoritmo per la pletora di indicatori tecnici là fuori com
