Impara come progettare un sistema di trading tramite Gator Oscillator
163
0
Introduzione
Tratteremo questo indicatore il più possibile attraverso i seguenti argomenti:
- Definizione di Gator Oscillator
- Strategia Gator Oscillator
- Schema del Gator Oscillator
- Sistema di trading con Gator Oscillator
- Conclusioni
Utilizzeremo il terminale di trading MetaTrader 5 per testare la strategia menzionata e costruiremo il nostro sistema di trading con il linguaggio di programmazione MetaQuotes (MQL5) che è integrato in MetaTrader 5. Se non sapete come scaricare e utilizzare MetaTrader 5 e l'IDE di MQL5, potete leggere questo argomento: Scrivere codice MQL5 in MetaEditor, dal mio precedente articolo per saperne di più.
Devo ricordare che è necessario testare ogni strategia menzionata prima di utilizzarla, per essere sicuri che sia utile e profittevole per voi, poiché non c'è nulla di adatto a tutte le persone e l'obiettivo principale qui è solo educativo, per imparare il concetto principale e la radice dietro l'indicatore e c'è anche un consiglio che devo segnalare qui ed è che dovete provare a scrivere i codici di questo articolo e altri da soli se volete migliorare le vostre abilità di programmazione.
Avvertenza: Tutte le informazioni sono fornite "così come sono" solo a scopo didattico e non sono preparate per scopi commerciali o di consulenza. Le informazioni non garantiscono alcun tipo di risultato. Se scegliete di utilizzare questi materiali su uno qualsiasi dei vostri conti di trading, lo farete a vostro rischio e pericolo e sarete gli unici responsabili.
Definizione di Gator Oscillator
In questa parte, identificheremo l'indicatore Gator Oscillator in modo più dettagliato per comprendere e riconoscere il concetto principale che lo sottende e utilizzarlo in modo corretto ed efficace. L'indicatore Gator Oscillator è stato creato da Bill Williams per aiutarci ad identificare se il mercato è in trend o in ranging, se c'è un trend quanto questo trend può continuare in termini di momentum, oltre a fornire la tempistica di entrata o uscita da un trade. Come tutti sappiamo, questi due elementi sono molto importanti nel trading. Il Gator Oscillator si basa sull'indicatore Alligator e per maggiori dettagli su questo indicatore potete leggere il mio precedente articolo Impara come progettare un sistema di trading con l’Alligator.
Il calcolo dell'indicatore Gator è lo stesso che vedremo, mostrando quanta convergenza e divergenza c’è delle linee di equilibrio dell'indicatore Alligator. Di seguito è riportato il calcolo dell'indicatore Gator:
- Primo passo: dobbiamo calcolare il prezzo medio:
Prezzo medio = (Massimo + Minimo) /2
- Secondo passo: dobbiamo calcolare le Mascelle dell'Alligator, i Denti dell'Alligator e le Labbra dell'Alligator:
Alligator Jaw (Mascelle) = SMMA (prezzo medio, 13,8)
Alligator Teeth (Denti) = SMMA (prezzo medio, 8, 5)
Alligator Lips (Labbra) = SMMA (prezzo medio, 5, 3)
- Dove:
Prezzo medio: il tipo di prezzo.
Massimo: il valore di prezzo più alto.
Minimo: il valore di prezzo più basso.
SMMA: la smoothed moving average è un tipo di media mobile, un modo per smussare i dati, il periodo e lo scostamento, se esiste. Se diciamo SMMA (Prezzo Medio, 13, 5), significa che la SMMA è la media mobile smussata derivata dal prezzo medio come tipo di dati, il periodo di smussamento è 13 e lo scostamento nel futuro sarà 5.
Alligator Jaws: la linea blu dell'indicatore Alligator.
Alligator Teeth: la linea rossa dell'indicatore Alligator.
Alligator Lips: la linea verde dell'indicatore Alligator.
Il calcolo precedente produce l'indicatore Gator Oscillator, ma non è necessario calcolarlo manualmente poiché è integrato in MetaTrader 5 e basterà sceglierlo tra gli altri indicatori tecnici disponibili e inserirlo nel grafico come segue.
All'apertura di MetaTrader 5, scegliere la scheda Inserisci --> Indicatori --> Bill Williams --> Gator Oscillator
Dopo aver selezionato Gator Oscillator, troveremo la finestra dei parametri del Gator come segue:
Nella figura precedente, abbiamo i parametri dell'indicatore Gator Oscillator per determinare le impostazioni desiderate dell'indicatore ed è uguale alla seguente:
- Per determinare il periodo delle mascelle (jaws).
- Per determinare lo scostamento orizzontale delle mascelle.
- Per determinare il periodo dei denti (teeth).
- Per determinare lo scostamento orizzontale dei denti.
- Determinare il periodo delle labbra (lips).
- Per determinare lo scostamento orizzontale delle labbra.
- Per determinare il metodo preferito della media.
- Per determinare il tipo di prezzo che verrà utilizzato nel calcolo del Gator.
- Per determinare il colore dei valori di Gator up.
- Per determinare il colore dei valori di Gator down.
- Per determinare lo spessore delle barre del Gator.
Dopo aver determinato tutti i parametri preferiti dell'indicatore Gator Oscillator, troveremo l'indicatore allegato al grafico nella parte inferiore, come di seguito riportato:
Come si può vedere nel grafico precedente, abbiamo l'indicatore con valori verso l’alto e il basso del Gator Oscillator, si può vedere chiaramente che abbiamo valori up sopra lo zero e valori down sotto lo zero. Abbiamo anche barre verdi e rosse in base alla relazione tra ogni barra e la precedente. Se la barra corrente è superiore alla precedente, vedremo che la corrente è verde e viceversa se la corrente è inferiore alla precedente troveremo che la corrente è rossa.
Strategia Gator Oscillator
In questo argomento condividerò con voi alcune semplici strategie che possono essere utilizzate dall'indicatore Gator Oscillator solo a scopo di apprendimento. È necessario testare qualsiasi strategia menzionata prima di utilizzarla su un conto reale per essere sicuri che sia utile per voi.
Sulla base di questa strategia, dobbiamo identificare lo stato del Gator in base alle barre dell'indicatore. Secondo ciò, avremo quattro stati Gator. Se entrambe le barre sono rosse, lo stato del Gator sarà una fase di riposo. Se entrambe le barre sono verdi, si tratta di una fase di alimentazione. Se entrambe le barre sono verdi dopo il rosso, si tratta della fase di risveglio. Se entrambe le barre sono rosse dopo il verde, si tratta di una fase di sazietà.
Quindi, semplicemente,
Entrambe le barre sono rosse ==> Fase di riposo
Entrambe le barre sono verdi ==> Fase di alimentazione
Entrambe le barre sono verdi dopo il rosso ==> Fase di risveglio
Entrambe le barre sono rosse dopo il verde ==> Fase di sazietà
Secondo questa strategia, dobbiamo ottenere segnali basati sull'indicatore Gator. Se il Gator è in fase di risveglio, dobbiamo ottenere un segnale per trovare una buona entrata. Se l'indicatore Gator si trova nella fase di alimentazione, dobbiamo ottenere un segnale di mantenimento della posizione attuale. Se l'indicatore Gator è nella fase di sazietà, dobbiamo trovare una buona uscita. Se lo status del Gator è un altro, non dobbiamo ottenere nulla.
Semplicemente,
L'indicatore Gator = Fase di risveglio ==> Trova una buona entrata.
L'indicatore Gator = Fase di alimentazione ==> Mantenere la posizione attuale.
L'indicatore Gator = Fase di sazietà ==> Trova una buona uscita.
Se lo stato dell'indicatore Gator = altro ==> Non fare nulla.
Secondo questa strategia, combineremo il segnale Gator con il segnale della media mobile. Se abbiamo doppie barre verdi e il prezzo di chiusura è superiore al valore della media mobile, si tratta di un buon segnale di acquisto. Se invece l'indicatore Gator ha doppie barre rosse e il prezzo di chiusura è inferiore al valore della media mobile, si tratta di una buona posizione di vendita. Oppure, se abbiamo altro, non dobbiamo fare nulla.
Semplicemente,
Doppia barra verde e prezzo di chiusura > della media mobile ==> Trova una buona posizione di acquisto.
Doppia barra rossa e prezzo di chiusura < del valore della media mobile ==> Trova una buona posizione di vendita.
Qualsiasi altra cosa ==> Non fare nulla
Schema del Gator Oscillator
In questa parte, creeremo degli schemi passo-passo per ogni strategia menzionata, per aiutarci a creare il nostro sistema di trading in modo efficace e semplice. Ritengo che questa fase sia molto importante ed essenziale per lo sviluppo di un sistema di trading, in quanto consente di risparmiare molto tempo, per fare le cose bene, anche se la creazione del sistema richiede tempo, permette di evitare di dimenticare qualsiasi passaggio importante e di ripetere le operazioni. Lavoreremo per capire cosa dobbiamo lasciare che il computer faccia per noi, organizzando le nostre idee in passi chiari.
Sulla base del concetto che è dietro questa strategia, abbiamo bisogno di un computer o di creare un expert advisor che possa essere utilizzato per controllare automaticamente alcuni valori dell'indicatore Gator ad ogni tick, ovvero l’up attuale, i due precedenti up a quello attuale, il down attuale e i due precedenti down a quello attuale. Dopo questo controllo, è necessario che l'expert determini la posizione di ciascun valore ed esegua i seguenti confronti: il primo consiste nel confrontare i valori del Gator up attuale e di quello precedente e determinare quale sia maggiore dell'altro. Il secondo consiste nel confrontare i valori del Gator down attuale e di quello precedente e determinare quale sia maggiore dell'altro. Il risultato di questo confronto sarà il nostro segnale desiderato per identificare lo stato del Gator.
Se il valore up attuale è inferiore a quello precedente e il valore down attuale è superiore a quello precedente, è necessario che l'expert o il sistema di trading restituisca un segnale di fase di riposo come commento sul grafico. In un altro caso, se il valore up attuale è maggiore di quello precedente e allo stesso tempo il valore down attuale è minore di quello precedente, è necessario che il sistema di trading restituisca un segnale di fase di alimentazione come commento sul grafico. Nel terzo caso, se il primo valore precedente up è minore del secondo precedente e il primo valore precedente down è maggiore del secondo precedente down e allo stesso tempo, il valore up attuale è maggiore del primo precedente e il valore down attuale è minore del primo precedente, è necessario che il sistema di trading restituisca un commento sul grafico con il segnale di fase di risveglio. Nel quarto e ultimo stato, se il primo valore precedente up è maggiore del secondo e il primo valore precedente down è minore del secondo precedente e allo stesso tempo, il valore attuale up è minore del primo precedente e il valore attuale down è maggiore del primo precedente, è necessario che il sistema di trading restituisca un commento sul grafico con un segnale di fase di sazietà.
Di seguito è riportato un semplice schema che illustra il funzionamento di questo sistema di trading:
Strategia due: Segnali Gator
In base all'idea principale di questa strategia di trading, dobbiamo creare un sistema di trading che possa essere utilizzato per restituire un segnale di buona tempistica di entrata, uscita o mantenimento della posizione attuale. A tal fine, è necessario che il sistema di trading controlli continuamente i valori attuali di up e dei due precedenti, oltre al down attuale e ai due precedenti, per ottenere un segnale basato sullo stato del Gator.
Il primo segnale che il sistema di trading deve restituire è “Trova una buona entrata” come commento sul grafico dopo aver controllato i valori di Gator e aver constatato che c'è stata una fase di risveglio perché il primo up precedente è minore del secondo precedente e il primo down precedente è maggiore del secondo e allo stesso tempo, il valore up attuale è maggiore del primo precedente e il valore down attuale è minore del primo precedente.
Il secondo segnale che dobbiamo ottenere dal sistema di trading è “Mantenere la posizione attuale” come commento sul grafico dopo aver controllato i valori del Gator e aver constatato che c'è stata una fase di alimentazione perché il valore up attuale è maggiore del primo precedente e il valore down attuale è minore del primo precedente.
Il terzo segnale che dobbiamo ottenere con questo sistema di trading è “Trova una buona uscita” come commento sul grafico dopo aver controllato i valori del Gator e aver scoperto che c'è stata una fase di sazietà perché il primo valore up precedente è maggiore del secondo precedente e il primo valore down precedente è maggiore del secondo precedente.
L'ultima cosa di cui abbiamo bisogno nel sistema di trading è di non fare nulla se non quello che abbiamo menzionato nei tre segnali precedenti. Di seguito è riportato lo schema di questo sistema di trading:
Strategia tre: Gator con MA
In base alla strategia di trading, dobbiamo individuare un buon momento per trovare posizioni di acquisto o di vendita in base all'indicatore Gator, al prezzo di chiusura e alla media mobile, come abbiamo appreso nella sezione dedicata alla strategia.
Il primo segnale che il sistema di trading deve restituire è “Trova una buona posizione di acquisto” quando si controllano i valori del Gator e si scopre che l'attuale up è maggiore del primo precedente e il primo up precedente è maggiore del secondo precedente e allo stesso tempo, l'attuale down è minore del primo precedente e il primo down precedente è minore del secondo precedente, ciò significa che ora abbiamo una doppia barra verde. Quindi, il prezzo di chiusura è superiore al valore della media mobile.
Il secondo segnale è quello di “Trovare una buona posizione di vendita” quando si controlla il Gator e si scopre che l’attuale up è più piccolo del primo precedente e il primo up precedente è più piccolo del secondo precedente e allo stesso tempo, il valore down attuale è maggiore del primo precedente e il primo down precedente è maggiore del secondo precedente, questo significa che abbiamo doppie barre rosse. Quindi, il prezzo di chiusura è inferiore alla media mobile.
La terza cosa è che il sistema di trading, non deve restituire nulla se c'è qualcos'altro. Di seguito è riportato lo schema di questo sistema di trading:
Sistema di trading con Gator Oscillator
Ora, siamo arrivati all'argomento più interessante di questo articolo; creare il nostro sistema di trading per ogni strategia menzionata. Questo sistema di trading può aiutarci a fare trading in modo efficace. Inizieremo a creare un semplice sistema di trading da utilizzare come base per le nostre strategie.
Il "Simple Gator Oscillator System" è stato creato per restituire un commento sul grafico con il valore attuale di up e di down dell'indicatore Gator. I passi seguenti servono a creare questo sistema di trading:
Creare array per upGator e downGator utilizzando una funzione double, che è uno dei tipi reali per restituire valori con frazioni.
double upGatorArray[]; double downGatorArray[];
Ordinare i dati in questi array utilizzando la funzione "ArraySetAsSeries". I suoi parametri:
ArraySetAsSeries(upGatorArray,true); ArraySetAsSeries(downGatorArray,true);
Creare una variabile integer per gatorDef e definire Gator Oscillator utilizzando la funzione "iGator", per restituire l'handle (gestore) dell'indicatore. I suoi parametri:
- symbol: per determinare il nome del simbolo, useremo _SYMBOL da applicare al simbolo corrente.
- period: per determinare il periodo, utilizzeremo _PERIOD da applicare al timeframe corrente.
- jaw_period: per determinare il periodo desiderato per il calcolo delle mascelle, utilizzeremo (13).
- jaw_shift: per determinare lo scostamento orizzontale delle mascelle, se necessario. Utilizzeremo (8).
- teeth_period: per determinare il periodo del calcolo dei denti. Utilizzeremo (8).
- teeth_shift: per determinare lo scostamento orizzontale dei denti, se necessario. Utilizzeremo (5).
- lips_period: per determinare il periodo di calcolo delle labbra. Utilizzeremo (5).
- lips_shift: per determinare lo scostamento orizzontale delle labbra, se necessario. Utilizzeremo (3).
- ma_method: per determinare il tipo di media mobile. Utilizzeremo (MODE_SMMA).
- applied_price: per determinare il tipo di prezzo applicato nel calcolo. Utilizzeremo (PRICE_MEDIAN).
int gatorDef=iGator(_Symbol,_Period,13,8,8,5,5,3,MODE_SMMA,PRICE_MEDIAN);
Definizione dei dati e memorizzazione dei risultati mediante la funzione "CopyBuffer" sia per upGatorArray che per downGatorArray. I suoi parametri:
- indicator_handle: per determinare l'handle dell'indicatore, utilizzeremo (gatorDef).
- buffer_num: per determinare il numero di buffer dell'indicatore, useremo (0 per upGator), (2 per downGator).
- start_pos: per determinare la posizione iniziale, determineremo (0).
- count: per determinare la quantità da copiare, utilizzeremo (3).
- buffer[]: per determinare l'array di destinazione da copiare, useremo (upGatorArray, downGatorArray).
CopyBuffer(gatorDef,0,0,3,upGatorArray); CopyBuffer(gatorDef,2,0,3,downGatorArray);
Ottenere i valori di upGator e downGator dopo aver creato le relative variabili double. Quindi, utilizzeremo la funzione NormalizeDouble per arrotondare.
- value: Utilizzeremo upGatorArray[0] per il valore corrente.
- digits: Utilizzeremo (6) per le cifre dopo la virgola.
double gatorUpValue=NormalizeDouble(upGatorArray[0],6); double gatorDownValue=NormalizeDouble(downGatorArray[0],6);
Utilizziamo la funzione Comment per visualizzare i valori di upGator e downGator correnti.
Comment("gatorUpValue = ",gatorUpValue,"\n", "gatorDownValue = ",gatorDownValue);
Di seguito è riportato il codice completo di questo sistema di trading:
//+------------------------------------------------------------------+ //| Simple Gator Oscillator System.mq5 | //| Copyright 2022, MetaQuotes Ltd. | //| https://www.mql5.com | //+------------------------------------------------------------------+ #property copyright "Copyright 2022, MetaQuotes Ltd." #property link "https://www.mql5.com" #property version "1.00" //+------------------------------------------------------------------+ void OnTick() { double upGatorArray[]; double downGatorArray[]; ArraySetAsSeries(upGatorArray,true); ArraySetAsSeries(downGatorArray,true); int gatorDef=iGator(_Symbol,_Period,13,8,8,5,5,3,MODE_SMMA,PRICE_MEDIAN); CopyBuffer(gatorDef,0,0,3,upGatorArray); CopyBuffer(gatorDef,2,0,3,downGatorArray); double gatorUpValue=NormalizeDouble(upGatorArray[0],6); double gatorDownValue=NormalizeDouble(downGatorArray[0],6); Comment("gatorUpValue = ",gatorUpValue,"\n", "gatorDownValue = ",gatorDownValue); } //+------------------------------------------------------------------+
Dopo aver scritto le righe di codice precedenti, lo compileremo, assicurandoci che non ci siano errori, quindi troveremo questo expert nella finestra del navigatore sotto la cartella Expert Advisors nel terminale di trading MetaTrader 5, come segue:
Trascinando e rilasciando l'expert sul grafico desiderato, troveremo la finestra di questo EA uguale alla seguente:
Dopo aver spuntato la voce Consenti Algo Trading e aver premuto OK, l'EA è allegato al grafico come segue:
Ora siamo pronti a ricevere i segnali di questo sistema di trading, come nell'esempio seguente:
Strategia uno: Gator Status Identifier
Sulla base di questa strategia, di seguito viene riportato il blocco completo di codice per la sua creazione:
//+------------------------------------------------------------------+ //| Gator Status Identifier.mq5 | //| Copyright 2022, MetaQuotes Ltd. | //| https://www.mql5.com | //+------------------------------------------------------------------+ #property copyright "Copyright 2022, MetaQuotes Ltd." #property link "https://www.mql5.com" #property version "1.00" //+------------------------------------------------------------------+ void OnTick() { double upGatorArray[]; double downGatorArray[]; ArraySetAsSeries(upGatorArray,true); ArraySetAsSeries(downGatorArray,true); int gatorDef=iGator(_Symbol,_Period,13,8,8,5,5,3,MODE_SMMA,PRICE_MEDIAN); CopyBuffer(gatorDef,0,0,5,upGatorArray); CopyBuffer(gatorDef,2,0,5,downGatorArray); double gatorUpValue=NormalizeDouble(upGatorArray[0],6); double gatorUpPreValue1=NormalizeDouble(upGatorArray[1],6); double gatorUpPreValue2=NormalizeDouble(upGatorArray[2],6); double gatorDownValue=NormalizeDouble(downGatorArray[0],6); double gatorDownPreValue1=NormalizeDouble(downGatorArray[1],6); double gatorDownPreValue2=NormalizeDouble(downGatorArray[2],6); if(gatorUpValue<gatorUpPreValue1&&gatorDownValue>gatorDownPreValue1) { Comment("Sleeping Phase"); } else if(gatorUpValue>gatorUpPreValue1&&gatorDownValue<gatorDownPreValue1) { Comment("Eating Phase"); } if(gatorUpPreValue1<gatorUpPreValue2&&gatorDownPreValue1>gatorDownPreValue2&& gatorUpValue>gatorUpPreValue1&&gatorDownValue<gatorDownPreValue1) { Comment("Awakening Phase"); } else if( gatorUpPreValue1>gatorUpPreValue2&&gatorDownPreValue1<gatorDownPreValue2&& gatorUpValue<gatorUpPreValue1&&gatorDownValue>gatorDownPreValue1) { Comment("Sated Phase"); } } //+------------------------------------------------------------------+
Differenze in questo codice:
Definizione e ottenimento degli ultimi tre valori di upGator
double gatorUpValue=NormalizeDouble(upGatorArray[0],6); double gatorUpPreValue1=NormalizeDouble(upGatorArray[1],6); double gatorUpPreValue2=NormalizeDouble(upGatorArray[2],6);
Definizione e ottenimento degli ultimi tre valori di downGator
double gatorDownValue=NormalizeDouble(downGatorArray[0],6); double gatorDownPreValue1=NormalizeDouble(downGatorArray[1],6); double gatorDownPreValue2=NormalizeDouble(downGatorArray[2],6);
Condizioni della strategia:
Nel caso della fase di riposo,
if(gatorUpValue<gatorUpPreValue1&&gatorDownValue>gatorDownPreValue1) { Comment("Sleeping Phase"); }
Nel caso della fase di alimentazione,
else if(gatorUpValue>gatorUpPreValue1&&gatorDownValue<gatorDownPreValue1) { Comment("Eating Phase"); }
Nel caso della fase di risveglio,
if(gatorUpPreValue1<gatorUpPreValue2&&gatorDownPreValue1>gatorDownPreValue2&& gatorUpValue>gatorUpPreValue1&&gatorDownValue<gatorDownPreValue1) { Comment("Awakening Phase"); }
Nel caso della fase di sazietà,
else if( gatorUpPreValue1>gatorUpPreValue2&&gatorDownPreValue1<gatorDownPreValue2&& gatorUpValue<gatorUpPreValue1&&gatorDownValue>gatorDownPreValue1) { Comment("Sated Phase"); }
Dopo aver compilato questo codice senza errori ed eseguito l'EA, scopriremo che è allegato al grafico come il seguente:
Come si può vedere nell'angolo in alto a destra del grafico precedente, il Gator Status Identifier EA è allegato al grafico.
I segnali basati su questa strategia sono gli stessi che si ottengono con i test seguenti:
Nel caso di un segnale di riposo:
Come possiamo vedere nel grafico precedente, nell'angolo in alto a sinistra, abbiamo un segnale della fase di riposo basato su questa strategia.
Nel caso della fase di alimentazione:
Sulla base del grafico precedente, nell'angolo in alto a sinistra possiamo notare che abbiamo un segnale di fase di alimentazione che dipende da questa strategia.
Nel caso della fase di risveglio:
Come possiamo vedere dal grafico precedente, abbiamo un segnale di fase di risveglio basato sulla strategia Gator Status Identifier.
Nel caso della fase di sazietà:
Come si può vedere nella figura precedente, abbiamo una fase di sazietà nell'angolo in alto a sinistra.
Di seguito è riportato il codice completo per creare un sistema di trading basato su questa strategia.
//+------------------------------------------------------------------+ //| Gator signals.mq5 | //| Copyright 2022, MetaQuotes Ltd. | //| https://www.mql5.com | //+------------------------------------------------------------------+ #property copyright "Copyright 2022, MetaQuotes Ltd." #property link "https://www.mql5.com" #property version "1.00" //+------------------------------------------------------------------+ void OnTick() { double upGatorArray[]; double downGatorArray[]; ArraySetAsSeries(upGatorArray,true); ArraySetAsSeries(downGatorArray,true); int gatorDef=iGator(_Symbol,_Period,13,8,8,5,5,3,MODE_SMMA,PRICE_MEDIAN); CopyBuffer(gatorDef,0,0,3,upGatorArray); CopyBuffer(gatorDef,2,0,3,downGatorArray); double gatorUpValue=NormalizeDouble(upGatorArray[0],6); double gatorUpPreValue1=NormalizeDouble(upGatorArray[1],6); double gatorUpPreValue2=NormalizeDouble(upGatorArray[2],6); double gatorDownValue=NormalizeDouble(downGatorArray[0],6); double gatorDownPreValue1=NormalizeDouble(downGatorArray[1],6); double gatorDownPreValue2=NormalizeDouble(downGatorArray[2],6); bool awakeningPhase = gatorUpPreValue1<gatorUpPreValue2&&gatorDownPreValue1>gatorDownPreValue2&& gatorUpValue>gatorUpPreValue1&&gatorDownValue<gatorDownPreValue1; bool eatingPhase = gatorUpValue>gatorUpPreValue1&&gatorDownValue<gatorDownPreValue1; bool satedPhase = gatorUpPreValue1>gatorUpPreValue2&&gatorDownPreValue1<gatorDownPreValue2&& gatorUpValue<gatorUpPreValue1&&gatorDownValue>gatorDownPreValue1; if(awakeningPhase) { Comment("Find a good entry"); } else if(eatingPhase) { Comment("Hold current position"); } else if(satedPhase) { Comment("Find a good exit"); } else Comment(""); } //+------------------------------------------------------------------+
Le differenze di questa strategia:
Creare una variabile bool per le tre fasi seguenti: awakeningPhase, eatingPhase e satedPhase;
bool awakeningPhase = gatorUpPreValue1<gatorUpPreValue2&&gatorDownPreValue1>gatorDownPreValue2&& gatorUpValue>gatorUpPreValue1&&gatorDownValue<gatorDownPreValue1; bool eatingPhase = gatorUpValue>gatorUpPreValue1&&gatorDownValue<gatorDownPreValue1; bool satedPhase = gatorUpPreValue1>gatorUpPreValue2&&gatorDownPreValue1<gatorDownPreValue2&& gatorUpValue<gatorUpPreValue1&&gatorDownValue>gatorDownPreValue1;
Condizioni della strategia:
Nel caso della Fase di risveglio
if(awakeningPhase) { Comment("Find a good entry"); }
Nel caso della Fase di alimentazione
else if(eatingPhase) { Comment("Hold current position"); }
Nel caso della Fase di sazietà
else if(satedPhase) { Comment("Find a good exit"); }
Altri
else Comment("");
Dopo la compilazione e l'esecuzione di questo codice, scopriremo che l'EA è allegato al grafico come segue:
Come si può vedere nell'angolo in alto a destra, l'EA dei segnali Gator è allegato al grafico.
Ora siamo pronti a ricevere i segnali di questa strategia e i seguenti sono esempi di test:
Nel caso della fase di risveglio;
Come possiamo vedere nel grafico precedente, abbiamo un segnale "Trova un buon ingresso" nell'angolo in alto a sinistra.
Nel caso della fase di alimentazione
Come si può vedere nella figura precedente, nell'angolo in alto a sinistra è presente il segnale "Mantieni posizione corrente".
Nel caso della Fase di sazietà
Come si può vedere nel grafico precedente, che è un esempio di test, abbiamo un segnale "Trova una buona uscita" nell'angolo in alto a sinistra.
Strategia tre: Strategia Gator con MA
Di seguito è riportato il codice completo per la creazione di un sistema di trading basato su questa strategia.
//+------------------------------------------------------------------+ //| Gator with MA strategy.mq5 | //| Copyright 2022, MetaQuotes Ltd. | //| https://www.mql5.com | //+------------------------------------------------------------------+ #property copyright "Copyright 2022, MetaQuotes Ltd." #property link "https://www.mql5.com" #property version "1.00" //+------------------------------------------------------------------+ void OnTick() { double upGatorArray[]; double downGatorArray[]; MqlRates pArray[]; double maArray[]; ArraySetAsSeries(upGatorArray,true); ArraySetAsSeries(downGatorArray,true); ArraySetAsSeries(maArray,true); int gatorDef=iGator(_Symbol,_Period,13,8,8,5,5,3,MODE_SMMA,PRICE_MEDIAN); int maDef=iMA(_Symbol,_Period,13,0,MODE_EMA,PRICE_CLOSE); int data=CopyRates(_Symbol,_Period,0,13,pArray); CopyBuffer(gatorDef,0,0,3,upGatorArray); CopyBuffer(gatorDef,2,0,3,downGatorArray); CopyBuffer(maDef,0,0,3,maArray); double gatorUpValue=NormalizeDouble(upGatorArray[0],6); double gatorUpPreValue1=NormalizeDouble(upGatorArray[1],6); double gatorUpPreValue2=NormalizeDouble(upGatorArray[2],6); double gatorDownValue=NormalizeDouble(downGatorArray[0],6); double gatorDownPreValue1=NormalizeDouble(downGatorArray[1],6); double gatorDownPreValue2=NormalizeDouble(downGatorArray[2],6); double maValue=NormalizeDouble(maArray[0],5); double closingPrice=pArray[0].close; bool douleGreen = gatorUpValue>gatorUpPreValue1&&gatorUpPreValue1>gatorUpPreValue2&& gatorDownValue<gatorDownPreValue1&&gatorDownPreValue1<gatorDownPreValue2; bool douleRed = gatorUpValue<gatorUpPreValue1&&gatorUpPreValue1<gatorUpPreValue2&& gatorDownValue>gatorDownPreValue1&&gatorDownPreValue1>gatorDownPreValue2; if(douleGreen&&closingPrice>maValue) { Comment("Find a good buy position"); } else if(douleRed&&closingPrice<maValue) { Comment("Find a good sell position"); } else Comment(""); } //+------------------------------------------------------------------+
Le differenze di questa strategia:
Creare altri due array per pArray e maArray; utilizzeremo la funzione "MqlRates" per pArray per memorizzare le informazioni sui prezzi e la funzione "double" per maArray;
MqlRates pArray[]; double maArray[];
Ordinamento dei dati in maArray mediante la funzione "ArraySetAsSeries";
ArraySetAsSeries(maArray,true);
Creare una variabile integer per maDef e definire la Media Mobile utilizzando la funzione "iMA" per restituire l'handle dell'indicatore e i suoi parametri:
- symbol: per determinare il nome del simbolo. Determineremo _SYMBOL da applicare al grafico corrente.
- period: per determinare il periodo, utilizzeremo _PERIOD da applicare al time frame corrente; è possibile anche impostare PERIOD_CURRENT per lo stesso.
- ma_period: per determinare il periodo della media, utilizzeremo (13).
- ma_shift: per determinare lo scostamento orizzontale, se necessario. Impostiamo (0) perché non abbiamo bisogno di spostare la MA.
- ma_method: per determinare il tipo di media mobile, imposteremo EMA (Exponential Moving Average).
- applied_price: per determinare il tipo di prezzo utilizzato nel calcolo, utilizzeremo il prezzo di chiusura.
int maDef=iMA(_Symbol,_Period,13,0,MODE_EMA,PRICE_CLOSE);
Ottenere i dati storici di MqlRates utilizzando la funzione "CopyRates":
- symbol_name: per determinare il nome del simbolo, useremo _Symbol da applicare al simbolo corrente.
- timeframe: per determinare il timeframe si utilizzerà _Period da applicare al timeframe corrente.
- start_pos: per determinare il punto o la posizione di partenza, useremo (0) per partire dalla posizione corrente.
- cont: per determinare il conteggio da copiare, utilizzeremo (13).
- rates_array[]: per determinare l'array di destinazione da copiare, useremo (pArray).
int data=CopyRates(_Symbol,_Period,0,13,pArray);
Definizione dei dati e memorizzazione dei risultati mediante la funzione "CopyBuffer" per maArray.
CopyBuffer(maDef,0,0,3,maArray);
Ottenere il valore della media mobile esponenziale corrente e normalizzarla.
double maValue=NormalizeDouble(maArray[0],5);
Ottenere il valore attuale del prezzo di chiusura.
double closingPrice=pArray[0].close;
Creazione di variabili bool per le doppie barre verdi e le doppie barre rosse dell'indicatore Gator Oscillator.
bool douleGreen = gatorUpValue>gatorUpPreValue1&&gatorUpPreValue1>gatorUpPreValue2&&
gatorDownValue<gatorDownPreValue1&&gatorDownPreValue1<gatorDownPreValue2;
bool douleRed = gatorUpValue<gatorUpPreValue1&&gatorUpPreValue1<gatorUpPreValue2&&
gatorDownValue>gatorDownPreValue1&&gatorDownPreValue1>gatorDownPreValue2; Condizioni della strategia:
In caso di acquisto;
if(douleGreen&&closingPrice>maValue) { Comment("Find a good buy position"); }
In caso di vendita;
else if(douleRed&&closingPrice<maValue) { Comment("Find a good sell position"); }
Altri;
else Comment("");
Dopo aver compilato ed eseguito questo codice da allegare al grafico desiderato, scopriremo che l'EA è allegato al grafico come segue:
Come possiamo vedere nell'angolo in alto a destra del grafico abbiamo l'EA Gator con MA allegato al grafico.
Ora siamo pronti a ricevere i segnali di questa strategia e i seguenti sono esempi di test;
In caso di acquisto;
Come possiamo vedere nella figura precedente, nell'angolo in alto a sinistra abbiamo un segnale (Trova una buona posizione di acquisto).
In caso di vendita;
Come possiamo vedere, abbiamo un segnale (Trova una buona posizione di vendita).
Ora abbiamo imparato come creare sistemi di trading basati su diverse strategie e questo approccio deve aprire gli occhi a diverse idee che possono essere applicate, questo è l'obiettivo principale di questo articolo e di questa serie.
Conclusioni
Ora, abbiamo affrontato tutti gli argomenti di questo articolo per imparare a progettare un sistema di trading con il Gator Oscillator, abbiamo imparato cos'è l'indicatore Gator Oscillator, come calcolarlo e come utilizzarlo attraverso tre semplici strategie di trading, che sono:
- Gator Status Identifier: questa strategia determina lo stato del Gator Oscillator (risveglio, riposo, alimentazione, sazietà) in base a diverse condizioni.
- Segnali Gator: per ottenere segnali sul momento in cui prendere una decisione adeguata (trovare un buon ingresso, mantenere la posizione attuale o trovare una buona uscita) in base alle diverse condizioni del Gator Oscillator.
- Strategia Gator con MA: per ottenere segnali sulla tempistica delle posizioni di acquisto o vendita in base al Gator Oscillator con l'indicatore media mobile.
Dopo aver appreso come creare uno schema passo-passo per aiutarci a creare un sistema di trading per ogni strategia menzionata in modo efficace e semplice. Poi abbiamo creato un sistema di trading per queste strategie da eseguire nella piattaforma di trading MetaTrader5 creando il loro codice sorgente nell'IDE MQL5.
Spero che questo articolo vi sia stato utile per contribuire ad ottenere risultati migliori dal vostro trading e spero anche che questo resoconto vi abbia aiutato a trovare un nuovo approccio che possa essere utilizzato nella vostra attività di trading o a ottenere maggiori approfondimenti sull'argomento di questo articolo o su qualsiasi altro argomento correlato e se questo accade e volete leggere altri articoli simili potete leggere gli altri articoli di questa serie su come imparare a progettare un sistema di trading basato sugli indicatori tecnici più popolari.
Tradotto dall’inglese da MetaQuotes Ltd.
Articolo originale: https://www.mql5.com/en/articles/11928
Impara come progettare un sistema di trading con MFI di Bill Williams
Come gestire le linee utilizzando MQL5
Sviluppare un Expert Advisor per il trading da zero (Parte 29): La piattaforma parlante
Modelli di regressione della libreria Scikit-learn e la loro esportazione in ONNX
- 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