Gli indicatori dei trend micro, medie e principali
269
0
Introduzione
Nella prefazione al suo libro "Pattern, Price & Time: Using Gann Theory in Trading Systems" James Hyerczyk ha scritto:
"La mia esperienza nel settore dei futures mi ha mostrato che troppo spesso i trader si agganciano allo schema, al prezzo o al tempo nelle loro analisi. Tendono a pesare la loro analisi in un modo senza un equilibrio equo. Gli errori più comuni sono i sistemi costruiti intorno al tempo in entrata e al prezzo in uscita, o al prezzo in entrata e al tempo in uscita. Inoltre, i trader che utilizzano il pattern spesso entrano o escono a prezzi bassi o con tempistiche scadenti. Queste osservazioni hanno dimostrato ulteriormente quanto sia necessaria una combinazione di tutti e tre i metodi per il successo sul mercato. È su questa premessa che ho basato il mio libro".
Si può non essere d'accordo con questa affermazione. Proviamo a capire come utilizzare nella pratica alcuni di questi metodi. Lo scopo di questo articolo è quello di indagare la possibilità di automazione del trading e dell'analisi sulla base di alcune delle idee descritte nel libro sotto forma di indicatori ed EA. Pertanto, per comprendere meglio il materiale, si consiglia di leggere il libro (o almeno la prima parte, il modello) prima di leggere questo articolo.
1.1 Il micro trend
Nella Figura 1 è mostrato il grafico di un trend minore. Consideriamo brevemente le regole per costruire un trend minore:
- durante un movimento in salita (quando il massimo della barra successiva è maggiore del massimo della barra precedente e il minimo della barra successiva è maggiore del minimo della barra precedente), colleghiamo il massimo successivo della barra con il precedente e otteniamo la linea del trend in rialzo;
- durante un movimento discendente (quando il minimo della barra successiva è inferiore al minimo della barra precedente e il massimo della barra successiva è inferiore al massimo della barra precedente) colleghiamo il minimo successivo della barra con la precedente e otteniamo una linea della tendenza al ribasso;
- se, durante un movimento verso l'alto, il massimo di un'altra barra non ha superato il massimo della barra precedente e, quindi, il minimo della barra successiva è inferiore a quello della barra precedente, allora la direzione del movimento è stata cambiata verso il basso;
- se, durante un movimento discendente, il minimo della barra successiva non è inferiore al minimo della barra precedente e, allo stesso tempo, il massimo della barra successiva è superiore al massimo della barra precedente, allora la direzione cambia verso l'alto;
- Se, per qualsiasi movimento, il minimo della barra successiva è maggiore del minimo della barra precedente e, allo stesso tempo, il massimo della barra successiva è inferiore al massimo della precedente, allora questa barra viene chiamata all'interno (vedi Fig.1) e non partecipa alla costruzione del grafico;
- Se durante un qualsiasi movimento il massimo della barra successiva è maggiore del massimo della barra precedente e, allo stesso tempo, il minimo della barra successiva è inferiore al minimo della barra precedente, allora questa barra viene chiamata fuori ( vedi Fig. 1). A seconda della direzione della barra (verso l'alto o verso il basso), costruiamo il segmento corrispondente del grafico.
Figura 1. Trend minori
Quando la direzione del movimento del grafico viene modificata, si formano i cosiddetti picchi e bottom minori. I bottom minori nella Figura 1 sono contrassegnati dall'etichetta del prezzo a sinistra in rosso e i picchi minori sono contrassegnati dall'etichetta del prezzo a destra in verde.
Se, durante il movimento ascendente, la direzione è cambiata verso il basso, ma non ha raggiunto l'ultimo bottom, allora abbiamo un movimento correttivo. In caso contrario, c'è stato un cambio di direzione. Questo vale anche per il movimento discendente.
Pertanto, il prezzo si sposta tra i bottom e i picchi. Tali movimenti sono chiamati oscillazioni. Allo stesso tempo, possono essere generati dei movimenti correttivi.
Ecco in sintesi le regole per costruire la linea dell'indicatore del micro trend. Nella prima parte del libro c’è una descrizione più dettagliata. Il grafico di questo indicatore ricorda il grafico del noto indicatore ZigZag. Ma, a differenza di essa, non viene ridisegnata dopo la chiusura di un'altra barra e non ha parametri sintonizzabili esterni che influiscano sulla costruzione della linea.
1.2. L'indicatore GannMicroTrend
Sviluppiamo un indicatore che visualizzi il grafico del micro trend. L'aspetto dovrebbe essere lo stesso della Figura 1. Aggiungiamo anche l'output alla visualizzazione dell'ultima posizione dei picchi e dei bottom rispetto al tempo. Questo indicatore si trova nel file GannMicroTrend.mq5 allegato a questo articolo.
Per visualizzare queste informazioni, utilizza la libreria descritta nell'articolo Crea il tuo Market Watch utilizzando le classi della libreria standard. Per farlo, aggiungi la direttiva #include all'inizio del testo del nostro indicatore:
#include <TextDisplay.mqh> Supponiamo che il file precedente si trovi nella cartella \MQL5\Include.
L'indicatore deve memorizzare i parametri del trend attuale e i parametri degli ultimi picchi e bottom nelle variabili globali. Inoltre, dovrebbe esserci la possibilità di specificare la profondità del calcolo per il dato numero di barre nella cronologia.
Per farlo, aggiungi i parametri esterni specificati:
input int MaxBars = 1000; input bool IsSaveTrendParams = true; //--------------------------------------------------------------------- input bool ShowInfo = true; input int UpDownInfoShift = 1; input int LeftRightInfoShift = 1; input color TitlesColor = LightCyan; input color TopFieldsColor = Green; input color LowFieldsColor = Brown; //--------------------------------------------------------------------- input color UpTrendColor = LightGreen; input color DnTrendColor = LightPink; input int LineWidth = 4; //--------------------------------------------------------------------- input color UpStopLossColor = Green; input color DnStopLossColor = Brown; input int StopLossWidth = 1;
Lo scopo di questi parametri è mostrato nella tabella seguente:
| Il nome del parametro | Lo scopo del parametro |
|---|---|
| Il numero massimo di barre nella cronologia per cui viene disegnato l'indicatore. Se è 0, vengono contate e disegnate tutte le barre disponibili nella cronologia. |
| Se vero, i parametri per l'andamento corrente e i parametri degli ultimi picchi e bottom vengono memorizzati nelle variabili globali. |
| Se vero, la finestra del grafico mostra le coordinate degli ultimi picchi e bottom. |
| Uno spostamento verticale dall'alto verso il basso del luogo di output delle informazioni. |
| Uno spostamento orizzontale da sinistra a destra del luogo di output delle informazioni. |
| Il colore delle intestazioni durante l'output delle informazioni. |
| Il colore del testo durante l'output dei parametri dell'ultimo picco. |
| Il colore del testo durante l'output degli ultimi bottom. |
| Il colore del disegno della linea del movimento verso l'alto. |
| Il colore del disegno della linea del movimento verso il basso. |
| La larghezza delle linee di tendenza. |
| Il colore dell'etichetta del prezzo a destra, che indica i picchi. |
| Il colore dell'etichetta del prezzo a sinistra, che indica i bottom. |
| La dimensione dell'etichetta del prezzo, che indica i picchi e i bottom. |
Costruiremo la linea di tendenza utilizzando gli oggetti grafici di tipo CChartObjectTrend dall'insieme delle classi standard. I picchi secondari saranno contrassegnati dall'etichetta del prezzo di sinistra dagli oggetti di tipo CChartObjectArrowLeftPrice, mentre i minimi secondari dagli oggetti di tipo CChartObjectArrowRightPrice. Tutti questi oggetti sono contenuti nelle classi della libreria standard fornite con il terminale MetaTrader 5.
Poiché in futuro potrebbe essere necessaria la manipolazione delle linee di tendenza, nonché dei picchi/bottom, le memorizzeremo in un elenco di oggetti di tipo CList, anche provenienti da un insieme di classi standard. Per farlo, aggiungi all'inizio dell'indicatore le direttive di inclusione dei file di intestazione:
#include <Arrays\List.mqh> #include <ChartObjects\ChartObjectsLines.mqh> #include <ChartObjects\ChartObjectsArrows.mqh>
Quindi, aggiungi gli elenchi di oggetti:
CList* trend_list_Ptr = NULL; // list of the trend lines CList* up_list_Ptr = NULL; // list of the peaks CList* dn_list_Ptr = NULL; // list of the bottoms
Ora abbiamo tutti gli elementi necessari per la costruzione dell'indicatore.
La funzione OnInit dell'indicatore è la seguente:
int OnInit() { trend_list_Ptr = new CList(); if(CheckPointer(trend_list_Ptr) != POINTER_DYNAMIC) { Print("Error of creating the object CList #1"); return(-1); } up_list_Ptr = new CList(); if(CheckPointer(up_list_Ptr) != POINTER_DYNAMIC) { Print("Error of creating the obkect CList #2"); return(-1); } dn_list_Ptr = new CList(); if(CheckPointer(dn_list_Ptr) != POINTER_DYNAMIC) { Print("Error of creating the object CList #3"); return(-1); } if(InitGraphObjects() != 0) { Print("Error of creating the object TableDisplay"); return(-1); } return(0); }
Qui vengono creati i puntatori agli elenchi di oggetti, quindi viene verificata la riuscita della creazione. Se il puntatore non è valido, viene ricevuto un messaggio di errore e con questo il lavoro dell'indicatore è completato. Il luogo in cui si è verificato l'errore, può essere identificato dal numero con il carattere #. Successivamente, viene inizializzata la tabella per la visualizzazione dei parametri per gli ultimi picchi e bottom. Ciò avviene nel codice della funzione InitGraphObjects.
La parte principale del nostro indicatore è il gestore di eventi sulla necessità di eseguire calcoli. Questa è la funzione OnCalculate. Consideriamola pezzo per pezzo. La prima parte è relativa al controllo per la necessità di ricalcolare l'intera porzione visualizzata dell'indicatore. Tale necessità sorge, ad esempio, quando l'indicatore viene avviato per la prima volta sul grafico, quando si esegue il download di una cronologia aggiornata sul grafico, quando si è verificata una modifica nell'intervallo di tempo. In tutti questi casi, il valore dell'argomento prev_calculated è uguale a zero.
Ciò viene verificato come segue:
int index, start = prev_calculated - 1; if(prev_calculated == 0) { if(CheckPointer(trend_list_Ptr) != POINTER_INVALID) { trend_list_Ptr.Clear(); } if(CheckPointer(up_list_Ptr) != POINTER_INVALID) { up_list_Ptr.Clear(); } if(CheckPointer(dn_list_Ptr) != POINTER_INVALID) { dn_list_Ptr.Clear(); } // Determine the bar number of the beginning of calculations: if(MaxBars > 0 && rates_total > MaxBars) { start = rates_total - MaxBars; } else { start = 0; } time_prev = 0; trend_prev = 0; }
Se c'è la necessità di ricalcolare l'intero indicatore, allora cancelleremo l'elenco delle linee di tendenza e gli elenchi dei picchi/minottomimi. Inoltre, anche questi oggetti grafici verranno eliminati dal grafico. Quindi, determiniamo il numero della barra da cui dobbiamo iniziare il calcolo dell'indicatore: la variabile iniziale. Se il valore della variabile esterna MaxBars è maggiore di zero e minore del numero di barre sul grafico rate_total, allora la barra di partenza per il calcolo sarà uguale a:
start = rates_total - MaxBars;
Ricordiamo che l'indicizzazione delle barre di una time-series parte da zero (la barra recente).
Se il valore della variabile esterna MaxBars è uguale a zero (il che significa che dobbiamo calcolare l'indicatore su tutte le barre del grafico) o maggiore del numero di barre sul grafico, allora dobbiamo ricalcolare tutte i valori dell'indicatore per tutte le barre del grafico, ovvero inizio uguale a zero.
Poi, un ciclo di calcolo della linea di tendenza e delle posizioni dei picchi/bottom secondari. L'analisi dei valori di prezzo massimo e minimo delle barre, secondo le regole di cui sopra, è abbastanza semplice e non necessita di ulteriori spiegazioni (vedi testo sorgente nel file GannMicroTrend.mq5).
Per disegnare le sezioni di una linea di tendenza, utilizziamo la seguente funzione semplice:
//--------------------------------------------------------------------- // Drawing of a section //--------------------------------------------------------------------- void CreateCut(datetime _dt1, double _prc1, datetime _dt2, double _prc2, color _clr, int _wd) { string name = GetUniqName(prefix + " "); CChartObjectTrend* trend_obj = new CChartObjectTrend(); if(CheckPointer(trend_obj) != POINTER_INVALID) { trend_obj.Create(0, name, 0, _dt1, _prc1, _dt2, _prc2); trend_obj.Color(_clr); trend_obj.Width(_wd); trend_list_Ptr.Add(trend_obj); } }
Qui utilizziamo la funzione per ottenere un nome univoco all'interno del grafico, GetUniqName, descritto in dettaglio nell'articolo Crea il tuo Market Watch utilizzando le classi della libreria standard. In caso di costruzione di successo dell'oggetto grafico della linea di tendenza, vengono specificati i suoi parametri (colore e larghezza della linea) e questo oggetto viene aggiunto all'elenco delle linee chiamando il metodo CList: Add.
Per tracciare la posizione dei picchi/bottom secondari, utilizziamo rispettivamente le funzioni CreateUpStopLoss/CreateDnStopLoss. Sono simili alla funzione CreateCut e aggiungono gli oggetti creati ai loro elenchi.
Al termine del calcolo vengono visualizzati i parametri degli ultimi bottom e picchi. Qui usiamo gli elenchi creati nel passaggio precedente. Otteniamo questi elenchi già ordinati a seconda del tempo in base al loro incremento e, chiamando il metodo CList:: GetLastNode, otteniamo l'ultimo oggetto per un picco o un bottom.
Il risultato del lavoro dell'indicatore descritto è presentato nella figura seguente:
Figura 2. L'indicatore di un trend minore
2.1. Il Middle Trend
Il grafico del trend medio riflette l'andamento del mercato, delineato da due barre (movimenti a due barre). Il grafico del trend medio è mostrato nella Figura 2. Consideriamo brevemente le regole per costruire il grafico dei trend medi:
- durante un movimento ascendente (quando il massimo della barra successiva è maggiore del massimo del precedente movimento a due barre e anche il minimo della barra successiva è maggiore del minimo del precedente movimento a due barre), combiniamo il massimo successivo della barra con il massimo precedente del movimento a due barre e otteniamo una linea di movimento ascendente del trend intermedio;
- durante un movimento discendente (quando il minimo della barra successiva è inferiore al minimo del movimento precedente a due barre e anche il massimo della barra successiva è inferiore al minimo del movimento precedente a due barre), combiniamo il minimo successivo della barra con il minimo precedente del movimento a due barre e otteniamo una linea di movimento discendente del trend intermedio;
- se, durante un movimento ascendente, il massimo della barra successiva non supera il massimo del precedente movimento a due barre e, allo stesso tempo, il minimo della barra successiva è inferiore al minimo del precedente movimento a due battute e la direzione del movimento cambia poi verso il basso;
- se, durante un movimento ascendente, il massimo della barra successiva non supera il massimo del precedente movimento a due barre e, allo stesso tempo, il minimo della barra successiva è inferiore al minimo del precedente movimento a due battute e la direzione del movimento cambia poi verso il basso;
- se, durante un qualsiasi movimento, il minimo della barra successiva è maggiore del minimo del precedente movimento a due barre e, allo stesso tempo, il massimo della barra successiva è inferiore al massimo del precedente movimento a due barre, questa barra viene chiamata all'interno (vedi Figura 2) e non partecipa alla costruzione del grafico;
- se, durante un qualsiasi movimento, il massimo della barra successiva è maggiore del massimo della barra precedente e, allo stesso tempo, il minimo della barra successiva è inferiore al minimo della barra precedente, questa battuta viene chiamata all’esterno (vedi Figura 2). A seconda della direzione della barra (verso l'alto o verso il basso), costruiamo il segmento corrispondente del grafico.
Figura 3. Il trend intermedio
L'unico indicatore dell'inversione del trend intermedio al rialzo è l'intersezione del livello del picco intermedio. Allo stesso modo, l'unico indicatore dell'inversione al ribasso è il crossover del livello medio-basso.
Se il trend intermedio è al rialzo e il mercato fa un'oscillazione media al ribasso, ma non annulla il minimo precedente dell'oscillazione media, si tratta di una correzione. E se il trend intermedio è al ribasso e il mercato fa andare lo swing intermedio verso l'alto, ma non annulla il precedente picco dello swing intermedio, anche questa è una correzione.
2.2. L’indicatore GannMiddleTrend
Sviluppiamo un indicatore che mostrerà il grafico del trend intermedio. L'aspetto deve essere lo stesso di quello nella Figura 2. Inoltre, sullo schermo devono essere visualizzate le posizioni degli ultimi picchi e bottom. Questo indicatore si trova nel file allegato a questo articolo, GannMiddleTrend.mq5.
In questo indicatore, per la resa degli elementi del grafico, utilizzeremo l'indicatore buffer e il tipo di disegno DRAW_COLOR_SECTION. Ne avremo bisogno più avanti per lo sviluppo dell'EA. Per accedere ai dati di questo indicatore dall'EA, utilizziamo il buffer dell'indicatore.
I parametri di visualizzazione dell'indicatore sullo schermo sono specificati dalle seguenti direttive:
#property indicator_buffers 2 #property indicator_plots 1 #property indicator_type1 DRAW_COLOR_SECTION #property indicator_color1 LightGreen, LightPink #property indicator_width1 4
Qui specifichiamo in sequenza:
- il numero di buffer dell’indicatore (ce ne sono solo due: il buffer di dati e il buffer dell'indice di colore);
- il numero di grafici visualizzati sullo schermo;
- il tipo di rendering del grafico dell'indicatore (lo renderizzeremo utilizzando le sezioni colorate);
- i colori che possono essere specificati nel buffer dell'indice di colore;
- la larghezza della linea del grafico dell'indicatore;
Nella funzione di inizializzazione OnInit associamo l'allocato per i buffer dell'indicatore e specifichiamo gli altri parametri dell'indicatore.
A fare ciò è il seguente frammento di codice:
SetIndexBuffer(0, DataBuffer, INDICATOR_DATA); SetIndexBuffer(1, ColorBuffer, INDICATOR_COLOR_INDEX); IndicatorSetInteger(INDICATOR_DIGITS, Digits( )); IndicatorSetString(INDICATOR_SHORTNAME, "GannMiddleTrend"); PlotIndexSetString(0, PLOT_LABEL, "GannMiddleTrend"); PlotIndexSetDouble(0, PLOT_EMPTY_VALUE, 0.0);
Qui specifichiamo in sequenza:
- un buffer usato nell'indicatore come buffer di dati (per il rendering sullo schermo);
- un buffer per specificare il colore delle sezioni del grafico dell'indicatore;
- il numero di punti decimali durante la visualizzazione dei valori dell'indicatore sullo schermo;
- il nome breve dell'indicatore durante la sua visualizzazione sullo schermo;
- il nome della serie grafica (buffer dati) visualizzato sullo schermo;
- il valore corrispondente al valore nullo sullo schermo (senza rendering);
L'indicatore è simile nella struttura e nei parametri esterni all'indicatore del micro trend GannMicroTrend. La differenza è che utilizza un'assegnazione diretta di valori nel buffer dell'indicatore e nel buffer dei colori, invece di utilizzare oggetti grafici. Pertanto, non ci soffermeremo sui dettagli dell'attuazione.
Il risultato del lavoro dell'indicatore è mostrato nella figura seguente:
Figura 4. L'indicatore del trend intermedio
Come si vede, coincide con quello disegnato a mano nella Figura 3.
3.1. Il trend principale
Il grafico del trend principale riflette l'andamento del mercato delineato da tre barre (movimenti a tre barre). L'aspetto del grafico del trend principale è mostrato nella Figura 5. Consideriamo in breve le regole per la costruzione del trend principale:
- durante un movimento ascendente (quando il massimo della barra successiva è maggiore del massimo del movimento a tre barre precedente e anche il minimo della barra successiva è maggiore del minimo del movimento a tre barre precedente), combiniamo il massimo successivo della barra con il massimo precedente del movimento a tre barre e otteniamo una linea di movimento al rialzo del trend principale;
- durante un movimento discendente (quando il minimo della barra successiva è inferiore al minimo del movimento a tre barre precedente e anche il massimo della barra successiva è inferiore al minimo del movimento a tre barre precedente), combiniamo il minimo della barra successiva con il minimo precedente del movimento a tre barre e otteniamo una linea di movimento al ribasso del trend principale;
- se, durante un movimento verso l'alto, il massimo della barra successiva non supera il massimo del movimento a tre barre precedente e, allo stesso tempo, il minimo della barra successiva è inferiore al minimo del movimento a tre barre precedente e la direzione cambia poi verso il basso;
- se, durante un movimento verso l'alto, il massimo della barra successiva non supera il massimo del movimento a tre barre precedente e, allo stesso tempo, il minimo della barra successiva è inferiore al minimo del movimento a tre barre precedente e la direzione cambia poi verso il basso;
- se, per qualsiasi movimento, il minimo della barra successiva è maggiore del movimento precedente a tre barre e, allo stesso tempo, il massimo della barra successiva è inferiore al massimo del movimento precedente a tre barre, allora questa barra è chiamato all’interno (vedi Figura 5) e non partecipa alla costruzione del grafico;
- se, durante un qualsiasi movimento, il massimo della barra successiva è maggiore del massimo della barra precedente e, allo stesso tempo, il minimo della barra successiva è inferiore al minimo della barra precedente, questa battuta viene chiamata all’esterno vedi figura 5). A seconda della direzione della barra (verso l'alto o verso il basso), costruiamo il segmento corrispondente del grafico.
Figura 5. Il trend principale
L'unico indicatore dell'inversione del trend principale al rialzo è il crossover del livello del picco principale. Allo stesso modo, l'unico indicatore dell'inversione al ribasso è l'incrocio del livello del bottom principale.
Se il trend principale è al rialzo e il mercato forma uno swing verso il basso, ma non annulla lo swing bottom precedente, si tratta di una correzione. E se il trend principale è rivolto verso il basso e il mercato forma uno swing verso l’alto, ma non annulla lo swing di picco precedente, anche questa è una correzione.
3.2. L’indicatore GannMainTrend
Sviluppiamo un indicatore che mostrerà il grafico del trend principale. L'aspetto deve essere lo stesso della Figura 5. Inoltre, sullo schermo devono essere visualizzate le posizioni degli ultimi picchi e bottom. Questo indicatore si trova nel file allegato a questo articolo, GannMainTrend.mq5.
L'indicatore è identico per struttura e parametri esterni all'indicatore di tendenza centrale GannMiddleTrend, pertanto non ci soffermeremo sui dettagli dell'implementazione. Il risultato del lavoro dell'indicatore è mostrato nella figura seguente:
Figura 6. L'indicatore del trend principale
4. Fare trading usando lo Swing chart
Abbiamo dunque uno strumento per analizzare il mercato in termini di Modello: gli indicatori dei trend micro, medi e principali. Ora proviamo a sviluppare un sistema di trading semplice, basato sulle oscillazioni dei prezzi.
Nel suo libro, James Hyerczyk propone la seguente strategia:
- Identifica le sezioni con movimenti a lungo termine verso il basso (verso l'alto);
- Dopo la formazione di un mercato stagnante che si muove in direzione orizzontale, piazza un ordine di acquisto sopra il picco (sotto il bottom per vendere) dell'ultimo swing;
- Lo stop protettivo è posto appena sotto il bottom (appena sopra il picco) dell'ultimo swing;
- Dopo aver aperto la posizione, lo stop viene spostato dopo il prezzo, sotto i bottom generati (picchi) dei nuovi swing;
Illustriamolo in un disegno:
Figura 7. Swing Trading
A livelli di prezzo estremamente alti, si consiglia di considerare la possibilità di andare short e, a livelli di prezzo estremamente bassi, la possibilità di andare long. La Figura 7 illustra il grafico del trend intermedio. Identificheremo le sezioni con movimenti a lungo termine dal grafico del trend principale. Identificheremo le sezioni del mercato "stagnante" dal grafico del trend intermedio. La posizione sarà monitorata dal grafico del trend intermedio.
Ecco come appare la stessa sezione sul grafico del trend principale:
Figura 8. La sezione sul grafico del trend principale
Un movimento al ribasso a lungo termine (swing) è tra il picco principale 1,36913 e il bottom principale 1,18758. Questo movimento richiede 1815,5 punti a quattro cifre. Segue poi la sezione del mercato “stagnante”, con un andamento quasi orizzontale da 1.24664 a 1.21495 (vedi Figura 7). Questo movimento richiede 316,9 punti. Successivamente, il prezzo supera il livello del picco intermedio dell'ultimo swing sul grafico di tendenza intermedio e sale.
Impostiamo lo stop iniziale appena sotto il bottom intermedio e l'ultimo swing 1.21495 e monitoriamo la posizione sul grafico del trend intermedio. Come risultato di questo scambio, otterremo un profitto di circa 1,31186 - 1,23966 = 722,0 punti.
5. La classe dei segnali di trading da utilizzare nella procedura guidata MQL5
Prima di progettare il codice per l'implementazione del nostro sistema di trading, immaginiamo schematicamente l'intero corso del trading. Considera la seguente illustrazione:
Figura 9. Trading di posizioni long
L'aggiustamento della posizione BUY consiste in quanto segue:
- Definiamo, tramite il grafico del trend principale, un movimento ribassista a lungo termine (sezione AB nella Figura 9). La durata e l'ampiezza del movimento sono specificate dai parametri dT e dP, rispettivamente. I valori di questi parametri devono essere determinati sulla base dello studio della cronologia di questo strumento.
- Dopo la formazione del bottom principale sul grafico dell'andamento principale (punto B nella Figura 9), attendiamo la formazione dei punti C e D sul grafico del trend intermedio. Questi punti, insieme al punto B, formano gli swing BC e CD intermedi. Se la durata e l'entità di questi swing non superano i valori specificati, supporremo allora che abbiano formato un trend orizzontale (o un mercato "stagnante").
- Attendiamo il raggiungimento del livello del picco intermedio C (o del picco intermedio più recente, che si forma dopo C). Dopo la breccia, posizioniamo lo stop appena sotto il bottom intermedio nel punto D (o il bottom intermedio più recente, che si forma dopo C).
- Monitoriamo la posizione mentre il movimento verso l'alto continua, spostando lo stop sotto il bottom intermedio formato (appena sotto i punti F e L).
- A seconda della modalità di gestione del capitale, possiamo aggiungere al volume della posizione, nei punti di rottura, dei picchi intermedi formati (punti G e M).
Quindi, per costruire un Expert Advisor, abbiamo bisogno dei seguenti componenti: un modulo per generare segnali di acquisto/vendita; un modulo del trailing stop della posizione aperta e, eventualmente, un modulo responsabile della posizione "piramidale" (money-management).
Per la stesura di questa sezione sono stati utilizzati i seguenti articoli: Il Wizard MQL5: Come creare un modulo di segnali di trading, Wizard MQL5: Come creare un modulo di trailing delle posizioni aperte, Il Wizard MQL5: Come creare un modulo di gestione del rischio e del denaro.
Lo sviluppo del modulo, responsabile della generazione dei segnali di trading, consiste in quanto segue:
- Aggiungi una direttiva per il preprocessore per includere il file mqh standard, il quale contiene tutte le classi di base per la generazione di un Expert Advisor. Ciò avviene come riportato di seguito:
#include <Expert\ExpertSignal.mqh>Inserisci questa direttiva all'inizio del nostro modulo di generazione di un segnale di trading.- L'aggiunta di stringhe speciali, sotto forma di commenti, che indicano all'editor MetaEditor che questo file deve essere utilizzato durante la generazione dell'EA:
// wizard description start //+------------------------------------------------------------------+ //| Description of the class | //| Title=Signal based on swings on charts | //| of the middle and main trends according to Gann (iCustom) | //| Type=Signal | //| Name=TGannBreakSignal | //| Class=TGannBreakSignal | //| Page= | //| Parameter=MinMainSwingContinuance,int,5 | //| Parameter=MinMainSwingSize,double,300.0 | //| Parameter=MinMiddleSwingContinuance,int,3 | //| Parameter=MaxMiddleSwingSize,double,200.0 | //| Parameter=OpenPriceSpace,double,5.0 | //| Parameter=StopLossSpace,double,5.0 | //+------------------------------------------------------------------+ // wizard description end
Qui vediamo il parametro Title, il quale specifica il nome del modulo che compare nell'elenco MetaEditor durante la generazione dell'EA (vedi descrizione sotto). Un parametro importante, Type, stabilisce che il modulo dato è un modulo di generazione del segnale. Inoltre, sono presenti i parametri esterni e i loro valori predefiniti.
Tutte queste righe vengono aggiunte subito dopo la direttiva di inclusione del file standard ExpertSignal.mqh.
- La descrizione della classe del discendente della classe base, descritta nel file ExpertSignal.mqh. Questa classe deve implementare alcune funzionalità che mancano nella classe base CExpertSignal. La descrizione della nostra classe ha la seguente visualizzazione (qui alcune parti non essenziali non vengono mostrate):
class TGannBreakSignal : public CExpertSignal { private: int min_main_swing_continuance; // minimum swing duration time of the main tren double min_main_swing_size_points; // minimum swing amplitude on the chart of the main trend int min_middle_swing_continuance; // minimum swing duration time on the chart of the middle trend double max_middle_swing_size_points; // maximum swing amplitude of the chart of the middle trend double open_price_space; // distance between the open price and peak/bottom double stop_loss_space; // distance between the stop loss price and peak/bottom datetime main_swing_lf_datetime; // time of left point of a swing on the chart of the main trend double main_swing_lf_price; // price of left point of a swing on the chart of the main trend datetime main_swing_rt_datetime; // time of right point of a swing on the chart of the main trend double main_swing_rt_price; // price of right point of a swing on the chart of the main trend int main_swing_continuance; // swing duration time on the chart of the main trend double main_swing_size_points; // swing amplitude (in points) on the chart of the main trend datetime middle_swing_lf_datetime; // time of left point of a swing on the chart of the middle trend double middle_swing_lf_price; // price of left point of a swing on the chart of the middle trend datetime middle_swing_rt_datetime; // time of right point of a swing on the chart of the middle trend double middle_swing_rt_price; // price of right point of a swing on the chart of the middle trend int middle_swing_continuance; // swing duration time on the chart of the middle trend double middle_swing_size_points; // swing amplitude (in points) on the chart of the middle trend int handle_main_swing; int handle_middle_swing; double main_swing_buff[]; double middle_swing_buff[]; datetime time_buff[]; double price_buff[]; public: TGannBreakSignal(); // constuctor ~TGannBreakSignal(); // destructor // Settings: void MinMainSwingContinuance(int _cont); void MinMainSwingSize(double _size); void MinMiddleSwingContinuance(int _cont); void MaxMiddleSwingSize(double _size); void OpenPriceSpace(double _space); void StopLossSpace(double _space); int GetMainSwingContinuance(); // gets swing duration time on the chart of the main trend double GetMainSwingSizePoints(); // gets swing amplitude (in 4-digit points) on the chart of the main trend int GetMiddleSwingContinuance(); // gets swing duration time on the chart of the middle trend double GetMiddleSwingSizePoints(); // gets swing amplitude (in 4-digit points) on the chart of the middle trend // overloaded methods of the CExpertSignal class: virtual bool ValidationSettings(); virtual bool CheckOpenLong(double &price,double &sl,double &tp,datetime &expiration); virtual bool CheckOpenShort(double &price,double &sl,double &tp,datetime &expiration); virtual bool InitIndicators(CIndicators *indicators); // Additional methods: protected: // Sets swing parameters of the main trend void SetMainSwingParameters(datetime _lf_dt,double _lf_price,datetime _rt_dt,double _rt_price); // Sets swing parameters of the middle trend void SetMiddleSwingParameters(datetime _lf_dt,double _lf_price,datetime _rt_dt,double _rt_price); // Gets swing parameters of the main trend int GetMainSwing(); // Gets swing parameters of the middle trend int GetMiddleSwing( ); };
Dai commenti è chiaro lo scopo dei dati membri. Considera alcuni dei metodi della classe.
Prima di tutto dobbiamo ridefinire i metodi della classe base. Il primo metodo viene utilizzato per verificare la correttezza dei parametri esterni specificati dell'EA:
//--------------------------------------------------------------------- // Validation of settings //--------------------------------------------------------------------- bool TGannBreakSignal::ValidationSettings() { if(this.min_main_swing_continuance<=0) { Print("Wrong Parameter: min_main_swing_continuance = ", this.min_main_swing_continuance); return(false); } if(this.min_main_swing_size_points<=0.0) { Print("Wrong Parameter: min_main_swing_size_points = ", DoubleToString(this.min_main_swing_size_points,1)); return(false); } if(this.min_middle_swing_continuance<=0) { Print("Wrong Parameter: min_middle_swing_continuance = ", this.min_middle_swing_continuance); return(false); } if(this.max_middle_swing_size_points<=0.0) { Print("Wrong Parameter: max_middle_swing_size_points = ", DoubleToString(this.max_middle_swing_size_points,1)); return(false); } return(true); }
Qui effettuiamo un semplice controllo della correttezza dei parametri esterni. È chiaro che l'ampiezza dello swing (in punti) e la sua durata in barre non possono essere inferiori o uguali a zero. In caso di parametri esterni specificati in modo errato, il metodo restituisce false.
Successivamente, consideriamo i metodi per generare i segnali per l'apertura di posizioni.
La verifica della necessità di aprire una posizione long viene effettuata dal seguente metodo, ereditato dalla classe base:
//--------------------------------------------------------------------- // Checks conditions to open long position //--------------------------------------------------------------------- bool TGannBreakSignal::CheckOpenLong(double &_price,double &_sl, double &_tp,datetime &_expiration) { if(this.GetMainSwing()==-1) { return(false); } if(this.GetMiddleSwing()==-1) { return(false); } // If the main swing upward, exit if(this.main_swing_rt_price>=this.main_swing_lf_price) { return(false); } // If the middle weak swing isn't formed, exit: if(this.middle_swing_rt_price>=this.middle_swing_lf_price) { return(false); } // Check swing parameters on the main trend chart if(this.main_swing_continuance<this.min_main_swing_continuance || this.main_swing_size_points<this.min_main_swing_size_points) { return(false); } // Check swing parameters on the middle trend chart if(this.middle_swing_continuance<this.min_middle_swing_continuance || this.middle_swing_size_points>this.max_middle_swing_size_points) { return(false); } double unit=this.PriceLevelUnit(); // If the price has crossed the peak of the weak middle swing, set signal to open long position: double delta=this.m_symbol.Bid() -(this.middle_swing_lf_price+this.open_price_space*unit); if((delta>=0.0) && (delta<(10.0*unit))) { _price=0.0; _sl = this.m_symbol.NormalizePrice(this.middle_swing_rt_price - stop_loss_space*unit); _tp = 0.0; return(true); } return(false); }
Innanzitutto, vengono chiamati due metodi per ottenere i parametri degli ultimi swing per i grafici dei trend principali e intermedie: TGannBreakSignal::GetMainSwing e TGannBreakSignal::GetMiddleSwing. Se questi metodi hanno avuto successo, possiamo analizzare i parametri degli swing.
Poiché stiamo verificando la presenza del segnale per l'apertura di una posizione long, gli swing devono essere al ribasso. Confrontiamo le posizioni dei punti A e B (vedi Fig.9): se il punto B ha un prezzo inferiore al punto A, allora lo swing del prezzo era al ribasso.
Successivamente, controlliamo la presenza dei punti C e D (vedi Figura 9). Inoltre, il punto D deve avere un prezzo inferiore al punto C. Se questa condizione è soddisfatta, controlliamo i parametri degli swing dei trend principali e intermedi. Vengono controllate la durata e l'ampiezza del movimento.
Se tutti i controlli precedenti hanno avuto esito positivo, viene eseguito l'ultimo controllo, indipendentemente dal fatto che il prezzo abbia superato o meno il picco dello swing intermedio. In tal caso, compila il valore di stop e restituisci il risultato true.
La verifica per la necessità di aprire una posizione short si effettua chiamando il metodo TGannBreakSignal:: CheckOpenShort, che esegue i controlli simili al metodo TGannBreakSignal:: CheckOpenLong, ma in un'immagine speculare nell'asse dei prezzi.
Abbiamo quindi rivisto la struttura e i metodi di base del modulo, responsabile della generazione dei segnali di trading. Il modulo descritto è allegato a questo articolo nel file GannTrendSignal.mqh.
Il secondo modulo di cui avremo bisogno è il modulo del trailing stop di una posizione aperta. Anche questo modulo è sviluppato sulla base delle classi standard e si compone di quanto segue:
- L'aggiunta della direttiva del preprocessore per includere il file mqh standard, il quale contiene le classi di base per la generazione del codice per il trailing della posizione.
Ciò avviene come riportato di seguito:
#include <Expert\ExpertTrailing.mqh> Inserisci questa direttiva all'inizio del modulo di trailing della posizione.
- L'aggiunta di stringhe speciali, sotto forma di commenti, indicano all'editor MetaEditor che questo file deve essere utilizzato per generare la posizione finale nell'EA:
// wizard description start //+------------------------------------------------------------------+ //| Description of the class | //| Title=Trailing on peaks/bottoms on the chart of the middle trend | //| Type=Trailing | //| Name=MiddleTrend | //| Class=MiddleTrendTrailing | //| Page= | //| Parameter=StopLossSpace,double,5.0 | //+------------------------------------------------------------------+ // wizard description end //+------------------------------------------------------------------+
Qui il parametro Type è impostato come uguale al valore "Trailing": ciò indica che questo modulo deve essere utilizzato per supportare la posizione (trailing). Inoltre, sono presenti i parametri esterni e i loro valori predefiniti.
Tutte queste righe vengono aggiunte subito dopo la direttiva di inclusione del file standard ExpertTrailing.mqh.
- La descrizione della classe, un discendente della classe base, descritta nel file ExpertTrailing.mqh. Questa classe deve implementare alcune funzionalità mancanti nella classe base CExpertTrailing. La descrizione della nostra classe ha la seguente visualizzazione (qui alcune parti non essenziali non vengono mostrate):
class MiddleTrendTrailing : public CExpertTrailing { private: datetime middle_swing_lf_datetime; // time of left point of a swing on the chart of the main trend double middle_swing_lf_price; // price of left point of a swing on the chart of the main trend datetime middle_swing_rt_datetime; // time of right point of a swing on the chart of the main trend double middle_swing_rt_price; // price of right point of a swing on the chart of the main trend double stop_loss_space; // the distance between peak/bottom and stop loss price int handle_middle_swing; double middle_swing_buff[]; datetime time_buff[]; double price_buff[]; public: MiddleTrendTrailing(); // constructor ~MiddleTrendTrailing(); // destructor private: int GetMiddleSwing(); // get parameters of the middle swing public: // Settings: void StopLossSpace(double _space); // Overloaded methods of CExpertTrailing class: virtual bool ValidationSettings(); virtual bool InitIndicators(CIndicators *indicators); virtual bool CheckTrailingStopLong(CPositionInfo *position,double &sl,double &tp); virtual bool CheckTrailingStopShort(CPositionInfo *position,double &sl,double &tp); };
I metodi di base, ridefiniti nella nostra classe MiddleTrendTrailing:: CheckTrailingStopLong e MiddleTrendTrailing:: CheckTrailingStopShort. Questi due metodi verificano le condizioni per la modifica dello stop-loss per una posizione long e una posizione short, rispettivamente.
Considera il metodo MiddleTrendTrailing:: CheckTrailingStopLong in modo più dettagliato:
//--------------------------------------------------------------------- // Checks conditions of trailing stop for long position //--------------------------------------------------------------------- bool MiddleTrendTrailing::CheckTrailingStopLong(CPositionInfo *_position,double &_sl,double &_tp) { if(_position==NULL) { return(false); } if(this.GetMiddleSwing()==-1) { return(false); } double sl_req_price = this.m_symbol.NormalizePrice(MathMin(middle_swing_lf_price,middle_swing_rt_price) - this.stop_loss_space * this.m_adjusted_point ); if(_position.StopLoss() >= sl_req_price ) { return(false); } _tp = EMPTY_VALUE; _sl = sl_req_price; return(true); }
Per prima cosa chiamiamo il metodo per ottenere i parametri dell'ultimo swing per il grafico del trend intermedio, TGannBreakSignal:: GetMiddleSwing. Se questo metodo ha successo (ha restituito un valore zero), è possibile analizzare i parametri degli swing.
Adesso calcoliamo il livello di prezzo per posizionare lo stop-loss sulla base dei parametri di swing ottenuti. Se il livello calcolato dello stop-loss è inferiore a quello attuale (per la posizione long), allora compiliamo il parametro del metodo _sl per il nuovo valore sl_req_price e restituiamo true. Altrimenti, restituiamo false: questo suggerisce che il livello dello stop loss non richiede modifiche.
Il metodo di verifica della necessità di modificare lo stop-loss per le posizioni short è costruito alla stessa maniera.
Abbiamo quindi rivisto la struttura e le modalità di base del modulo responsabile del trailing di una posizione aperta (trailing). Il modulo descritto è allegato a questo articolo nel file GannTrailing.mqh.
La generazione dell'EA sulla base dei segnali di trading
La generazione dell'EA da un modello, utilizzando il "Masters MQL5", è un’attività abbastanza semplice. Consiste in una sequenza di passaggi:
- Fase 1
Utilizzando i comandi del menu principale di MetaEditor File/Nuovo, richiamiamo il master della generazione EA. Lo schermo mostra una finestra di dialogo come questa:
Figura 10. Creazione di un Expert Advisor pronta con la procedura guidata di MQL5
Seleziona il "radio button" con la scritta "EA (generate)" e clicca sul pulsante "Next" per passare alla fase successiva della generazione dell'EA.
- Fase 2
In questo passaggio, specifichiamo i parametri generali dell'EA: il nome, il "magic number", ecc. Viene visualizzata la seguente finestra di dialogo:
Figura 11. Proprietà generali dell’Expert Advisor
Specifica il valore del parametro EveryTick in true. Abbiamo bisogno del lavoro dell'EA per ogni tick e il "magic number" può rimanere invariato. Clicca sul pulsante "Avanti" e procedi alla fase successiva della generazione.
- Fase 3
In questa fase, specifica i parametri dei segnali per l'EA. Innanzitutto, selezioniamo il particolare tipo di segnale dall'elenco:
Figura 12. La selezione del modulo dei segnali di trading
Seleziona il nome del nostro segnale, scritto in precedenza, e sullo schermo apparirà la finestra di dialogo del seguente tipo:
Figura 13. Parametri di input del modulo del segnale di trading
Qui possiamo correggere i valori di default necessari dei parametri. Ancora una volta, premi il pulsante "Next" e procedi alla fase successiva.
- Fase 4
In questo passaggio seleziona il tipo di trailing per supportare la posizione aperta. Possiamo selezionarne uno dall'elenco, ma selezioneremo il metodo del trailing-stop precedentemente sviluppato:
Figura 14. Seleziona il tipo di trailing di posizione
Otteniamo la seguente finestra di dialogo:
Figura 15. Specificare i parametri del trailing
Qui possiamo regolare i valori predefiniti per i parametri esterni specificati. Premere il pulsante "Next" e procedi alla fase successiva.
- Fase 5
Figura 16. Specificare i parametri di gestione del denaro
Qui possiamo selezionare i parametri per la gestione del capitale (il metodo di calcolo del lotto di lavoro). Lascialo così com'è: fai trading con un volume di trading fisso. Premi il pulsante "Done" per ottenere un EA già generato con un nome specificato, un algoritmo di apertura della posizione, il trailing e le regole di gestione del capitale.
Testa l'EA generato per assicurarti che funzioni:
Figura 17. Testa l'Expert Advisor creato
Possiamo vedere che i trend, i quali sono state correttamente identificati, sono stati presi completamente (nella misura consentita da questo metodo). Inoltre, abbiamo utilizzato i parametri predefiniti, specificati da considerazioni generali.
Conclusione
Abbiamo effettivamente considerato solo la prima parte della teoria di Gann e la sua applicazione nei sistemi di trading e nell'analisi di mercato: il modello. Sembra che i migliori risultati della sua applicazione si possano ottenere in quei periodi di tempo in cui la divisione del grafico in barre corrisponde alla naturale organizzazione del trading.
Per i mercati azionari si tratta di operazioni di trading che utilizzano intervalli giornalieri, settimanali e mensili. Per il mercato valutario si tratta di trading, utilizzando intervalli di sessione. Per i mercati di commodity si tratta di trading che utilizza non solo intervalli giornalieri, settimanali e mensili, ma anche fluttuazioni stagionali del mercato.
Post Conclusione
Ho deciso di fare una piccola ricerca in più, non direttamente attinente all'argomento, ma riguardante l'idea di Gann. Più precisamente, la domanda: Il prezzo, durante il suo movimento, segna i cosiddetti livelli "tondi"? Cioè i livelli di prezzo che terminano con le cifre 50 e 100 per le eurovalute e le azioni (per lo yen giapponese, un livello di prezzo "tondo" è un livello che termina con l cifra 40).
Per questo, costruiamo un diagramma di distribuzione dei picchi/bottom sulle ultime cifre dopo la virgola. Per le quotazioni a cinque cifre ci sono le ultime tre cifre dopo la virgola (l'ultima cifra, ovvero decimi di punto). Useremo il grafico del trend intermedio per le barre giornaliere.
Su un asse circolare riportiamo le ultime cifre del prezzo, da zero a cinquanta (arrotondate ai decimi di punto), mentre sull'asse verticale riportiamo il numero di picchi/bottom che si sono formati a questi livelli. Facciamolo separatamente per i picchi, i bottom e la cifra totale.
Ecco cosa otteniamo per alcune delle principali coppie di valute nell'intervallo dall'anno 2000 al 2011 e un intervallo di tempo giornaliero:
Come possiamo interpretare questi risultati? Prima di tutto, ci sono delle distorsioni nei diagrammi. Ovvero, non tutti i valori di prezzo hanno la stessa probabilità di formare picchi/bottom. In secondo luogo, questi valori non coincidono esattamente con i valori "tondi",che è ciò che avevamo sostanzialmente previsto. È difficile dire se ciò possa essere utilizzato o meno per il trading. Ci occorre una ricerca più precisa. I risultati forse più interessanti, dal punto di vista pratico, si possono ottenere nel mercato azionario.
Almeno, questo è un altro strumento per l'analisi della cronologia e non è il peggiore nel suo genere.
Tradotto dal russo da MetaQuotes Ltd.
Articolo originale: https://www.mql5.com/ru/articles/219
Wizard MQL5: Come creare un modulo di trailing delle posizioni aperte
Creare Expert Advisor multipli sulla base dei modelli di trading
Il Wizard MQL5: Come creare un modulo di gestione del rischio e del denaro
Disegnare i canali - Vista interna ed esterna
- 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