Donchian Channel – Le 2 succulente varianti che ti apriranno mondi inesplorati

Donchian Channel EA

Per colpa di qualche trader molto bravo che seguo, mi è salita la scimmia di studiare i Donchian Channel.

Cosa sono i Donchian Channel? Bella domanda. Sono i canali del Signor Donchian.

E chi è il signor Donchian? Uno che ha fatto brutto sui mercati.

Bla bla bla… vai su Wiki e scopri la storia che c’è dietro –> LINK A WIKIPEDIA

Insomma, vogliamo provare a prendere un po’ di dindi grazie all’esperienza del signor Riccardo Donchiani? Allora ciancio alle bande! Apri l’editor e scrocchia le dita tipo Ken Shiro, i sette pullback di Hokuto ti aspettano.

Ah, mannaggia lo spread. Mi stavo dimenticando:

QUESTA STRATEGIA NON FA GUADAGNARE, SERVE SOLO PER IMPARARE A PROGRAMMARE. CLARO?
Se non è chiaro c’è il disclaimer in alto. Leggilo.

Teoria del Donchian Channel

In un regno lontano lontano, molto tempo fa, il signor Donchian teorizza un suo indicatore molto semplice, utilizzato per la sua personale strategia TREND FOLLOWING: il Donchian Channel.

Questo canale si chiama così perché è formato da tre linee che contengono tutti i prezzi segnati dalla nostra security.

Il canale è composto da:

  • Un canale superiore
  • Un canale inferiore
  • Un canale mediano

Come calcola questi tre valori il nostro Riccardo? Così:

Canale Superiore: Il massimo registrato negli ultimi n periodi
Canale Inferiore: Il minimo registrato negli ultimi n periodi
Canale Mediano: La media aritmetica tra il massimo ed il minimo

E io mi dissi:

” MIN***A! Un GENIO! “

Eh, sta di fatto che il buon Ricky s’è fatto un sacc de sord‘ fino a diventare pure vice presidente della Shearson Lehman Brothers. Mentre io scelgo ancora i prodotti SMART dell’Esselunga.

Quindi analizziamolollo.

La strategia suggerisce di comprare a ROTTURA (chiusura della candela) AL DI SOPRA del canale superiore, e di vendere, vice versa, a rottura del canale inferiore.

Ma, per non diventare scemi a tracciare dinamicamente delle trendline ogni santo giorno, scriviamoci il nostro indicatore e pace all’anima di Rick.

Scriviamo il nostro indicatore base

Apriamo la Meta Trader e il suo coloratissimo editor mql. Avviamo la procedura guidata:

Donchian Channel MT4
Avviamo lo wizard selezionando “Indicatore Personalizzato”
Donchian Channel MT4
Mi piace un sacco la Chianina, l’indicatore quindi si chiamerà DONCHIANINA
Donchian Channel EA
Lasciamo tutto invariato qui…
Donchian Channel EA
E pure qui, teniamo via le mani dalla frutta. Clicca su FINE. (hai letto che mi chiedono la modalità di DISEGNAMENTO?)

Yooo! Siamo entrati nel fantastico mondo dell’emmekuellekuattro!

Dovresti vedere il classico incipit con le funzioni OnInit e OnCalculate.

//+------------------------------------------------------------------+
//|                                                  Donchianina.mq4 |
//|                                                 D'ario Woollover |
//|                               https://www.automazionetrading.com |
//+------------------------------------------------------------------+
#property copyright "D'ario Woollover"
#property link      "https://www.automazionetrading.com"
#property version   "1.00"
#property strict
#property indicator_chart_window
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- indicator buffers mapping
   
//---
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int OnCalculate(const int rates_total,
                const int prev_calculated,
                const datetime &time[],
                const double &open[],
                const double &high[],
                const double &low[],
                const double &close[],
                const long &tick_volume[],
                const long &volume[],
                const int &spread[])
  {
//---
   
//--- return value of prev_calculated for next call
   return(rates_total);
  }
//+------------------------------------------------------------------+

Great!

Cominciamo con i buffer, come sai, il programma non capisce “traccia una linea che corrisponde ai massimi degli ultimi n periodi, per cui dovremo preparare dei BUFFER.

E con la voce di Federico Buffer, ti dico:

I buffer sono degli array che contengono serie di dati.
Roba noiosa.
Ma non per la Meta Trader!

Dichiariamo quindi 3 buffer (1 per ciascuna linea)

#property indicator_buffers 3
#property indicator_plots   3

I buffer sono 3 e verranno tutti quanti renderizzati a video, per questo anche indicator_plots è uguale a 3.

Per ciascun plot, diamo qualche ritocco grafico, indicando etichetta della linea, tipo di plot, colore, stile linea e dimensione:

//--- plot DochUP
#property indicator_label1  "DochUP"
#property indicator_type1   DRAW_LINE
#property indicator_color1  clrSteelBlue
#property indicator_style1  STYLE_SOLID
#property indicator_width1  2
//--- plot DochDW
#property indicator_label2  "DochDW"
#property indicator_type2   DRAW_LINE
#property indicator_color2  clrCrimson
#property indicator_style2  STYLE_SOLID
#property indicator_width2  2
//--- plot DochMID
#property indicator_label3  "DochMID"
#property indicator_type3   DRAW_LINE
#property indicator_color3  clrDarkViolet
#property indicator_style3  STYLE_SOLID
#property indicator_width3  2

Bene. Il preprocessore sa che dovrà tirare tre linee sul grafico. Ma in base a quali valori? Quelli dei nostri buffer!

Come dici? Esatto. Non li abbiamo ancora dichiarati.

Saranno degli Array di valori prezzo, quindi avranno la virgola, e perciò li dichiareremo come array di variabili double:

double         DochUPBuffer[];
double         DochDWBuffer[];
double         DochMIDBuffer[];

Oh, non ci crederai ma ci bastano poche righe e siamo già in onda.

Ultima cosa preparatoria, vogliamo personalizzare il numero di candele che la nostra Donchianina calcolerà. Lo mettiamo quindi come variabile INPUT, di tipo INTERO.

Scriviamo così:

input int LookBack=20; 

Primo step: nell’OnInit associamo ciascun buffer al suo plot. I Plot sono numerati da 0 a 2, quindi in questo caso sono 3.

Useremo la funzione di sistema SetIndexBuffer(), con i parametri corretti. Ora l’OnInit() suona così:

int OnInit()
  {
//--- indicator buffers mapping
   SetIndexBuffer(0,DochUPBuffer);
   SetIndexBuffer(1,DochDWBuffer);
   SetIndexBuffer(2,DochMIDBuffer);
   
//---
   return(INIT_SUCCEEDED);
  }

Bueeeeno.

Passiamo all’OnCalculate, la funzione che ci permette di reiterare i nostri conteggi per ciascuna barra o candela nel grafico.

In questa funzione dovremo far fare i calcoli davvero al signor Donchianina. Lo scrivo in italiano e poi lo traduciamo in mql4:

CANALE SUPERIORE: Prendi il valore più alto tra tutti gli High delle ultime n candele
CANALE INFERIORE: Prendi il valore più basso tra tutti i Low delle ultime n candele
CANALE MEDIANO: Canale superiore + Canale inferiore, il tutto diviso due.

Mql4 ci viene in soccorso con due funzioni: iHigh() e iLow(). Queste ci servono per prendere l’High e il Low di una data candela.

Ma come faccio ad individuare la candela con l’High più alto?

Sempre il reverendissimo Mql4 ci agevola la funzione

iHighest()

La quale ci permette di individuare l’index (il numero) della candela con il più alto valore rispetto alle altre candele di una serie campione.

Quindi, unificando iHigh (che mi restituisce un PREZZO) con iHighest(che mi restituisce l’indice della candela che mi serve) troverò ciò che cerco: il valore del canale superiore in un dato momento.

Pausa caffè.

SALVA IL FILE!

Andremo a riempire il nostro buffer, per ogni data candela di indice [i], con questo calcolo:

DochUPBuffer[i]=iHigh(_Symbol,PERIOD_CURRENT,iHighest(_Symbol,PERIOD_CURRENT,MODE_HIGH,LookBack,i));

Sono disonesto, sono due funzioni una dentro l’altra… ma fa nulla. Sono facili da capire. Ti allego link al Book, così è più semplice ancora:

FUNZIONE iHigh()

FUNZIONE iHighest()

Faremo dunque la stessa cosa per il low, usando questa volta le funzioni iLow() e… suspance… iLowest().

Te pensa. (i link però non te li metto… sono nella stessa pagina)

La funzione per il donchian inferiore sarà:

      DochDWBuffer[i]=iLow(_Symbol,PERIOD_CURRENT,iLowest(_Symbol,PERIOD_CURRENT,MODE_LOW,LookBack,i));

Quite easy.

Il mediano abbiamo detto che sarà la media aritmetica tra i due valori. Scriviamolo:

DochMIDBuffer[i]=(DochUPBuffer[i]+DochDWBuffer[i])/2;

Questi tre calcoli, li dovremo inserire in un for loop, che ciclerà ricorsivamente tutti i dati della serie storica. Per la serie:

Fallo fare alla macchina!

Il nostro OnCalculate() è scritto all’uopo. E rassomiglierà vagamente a questo codice:

int OnCalculate(const int rates_total,
                const int prev_calculated,
                const datetime &time[],
                const double &open[],
                const double &high[],
                const double &low[],
                const double &close[],
                const long &tick_volume[],
                const long &volume[],
                const int &spread[])
  {
//---
   int limit=0;
   int bars = rates_total - 1;
   if(prev_calculated > 0)
     {
      bars = rates_total - prev_calculated;
     }

   for(int i = bars; i >= 0; i--)
     {
      DochUPBuffer[i]=iHigh(_Symbol,PERIOD_CURRENT,iHighest(_Symbol,PERIOD_CURRENT,MODE_HIGH,LookBack,i));
      DochDWBuffer[i]=iLow(_Symbol,PERIOD_CURRENT,iLowest(_Symbol,PERIOD_CURRENT,MODE_LOW,LookBack,i));
      DochMIDBuffer[i]=(DochUPBuffer[i]+DochDWBuffer[i])/2;
     }
//--- return value of prev_calculated for next call
   return(rates_total);
  }

Finito! Il nostro Donchianina.mq4 è pronto per essere compilato (F7 da tastiera) e buttato su un grafico.

Eccolo in tutto il suo splendore:

Donchian Channel EA
Due cose si notano: i colori sono Gay Friendly e il prezzo sembra seguire ESATTAMENTE l’indi. No. è il contrario: è l’INDI che segue il prezzo, SEMPRE!

Cosìè questo misterioso indicatore? Si muove come un Donchian channel? Si nasconde come un Donchian Channel? Si nutre come un Donchian Channel?

Perchè è un DONCHIAN CHANNEL!!!

Secondo la strategia TREND FOLLOWING, noi dovremmo entrare a rottura del canale. Long o short che sia: le frecce verdi indicano possibili ingressi LONG, quelle rosse SHORT. L’originalità proprio:

Donchian Channel MT4
MA sono TANTISSME!!!! E sono solo su EURUSD H1 unouno!!!11!!!!11!!

Eh… mica è tutto oro quello che è oro.

Naturalmente, ha senso tradare il PRIMO breakout, non TUTTI I SUCCESSIVI. Quindi le operazioni possibili sono circa 6/7, riesci a vedere quali sono profittevoli e quali no?

Ecco. Se vuoi approfondire il discorso, sappi che quasi tutta la strategia “Turtle Trader” è basata sulle rotture di livelli molto simili. Ti lascio una briciolina da seguire. Clicca sulla copertina della briciolina:

Donchian Channel MT4

Tutto molto bello, maaaaaa…

E se provassimo ad aggiungerci qualche “trick”?

Così com’è potrebbe dare qualche problemino il nostro puro Donchianina. Proviamo a ragionare:
Se il livello da rompere fosse arricchito da una valore variabile, atto ad eliminare il “rumore di fondo” e così attenuare i falsi positivi?

Se volessi ragionare in termini di variazione percentuale di prezzo, vedendo quando in assoluto NON TRADARE? (che è già una buona indicazione, fidati)

Una volta per cosa! Partiamo dall’ATR.

La teoria che c’è dietro l’ATR-Correction

Come hai potuto leggere nell’articolo sul TVB, l’ATR dà un valore in punti ai movimenti medi del nostro strumento. Questo valore potremmo pensarlo come l’estensione media del massimo movimento tra High e Low , negli ultimi N periodi (di solito 14).

Non è esattamente così, ti lascio approfondire cosa sia l’ATR in modo autonomo, ma facciamocela andare bene.

Ponendo che metà del range lo faccia lo spostamento verso il basso e metà verso l’alto, mi sono detto: aggiungiamo metà dell’ATR al canale superiore e metà al canale inferiore.

Però è una cazzata. Nel senso che così facendo i segnali sono praticamente inesistenti: il prezzo si dovrebbe muovere di molto per poter rompere questi livelli.

Allora ho pensato: calcoliamo un “rumore” che sia per metà sopra e per metà sotto il nostro livello Donchian. Abbiamo 3 livelli, dividiamo l’ATR per 6!

E, come sempre accade in questi casi… la soluzione è unica: valore esterno di tipo INT e morta lì. 🙂

Donchian Channel + ATR | Costruiamo il codice

PRRRRRRROOOOOOOOOOcediamo!

Aggiungiamo un ENUM, creando una variabile personalizzata che “racchiude” una serie di opzioni, e la definiamo così:

enum DONCHIAN_MODE
  {
      Classic, // Donchian Channel Classico
      ATR_Correction // Correzione dei valori con l'ATR
  };

Questo ci permetterà di scegliere come renderizzare il nostro Donchian.

Aggiungiamo quindi una variabile INPUT, di tipo DONCHIAN_MODE, e il periodo dell’ATR, come variabile INT.
Aggiungiamo anche un valore esterno da usare come DIVISORE dell’ATR.
Le inseriamo prima della funzione OnInit():

input DONCHIAN_MODE tipo_donchian=Classic; 
input int ATR_Period=14;
input int ATR_Fraction=6;

Ora la nostra finestra input suona un po’ così (non è figherrima?):

Donchian Channel MT4

Passiamo ai calcoli. Per ogni barra, dovremo pescare il valore dell’ATR.

Ma Ehy! Voglio mantenere comunque il Donchian originale!

Aggiungiamo intorno ai calcoli del Donchian Channel una condizione IF.

Se il tipo_donchian è “Classic”, allora procediamo come da programma (pessima battuta, lo so).

Se invece è di tipo ATR-Correction, vorrò aggiungere al Donchian superiore la frazione dell’ATR, a quello inferiore sottrarla.

Aggiungiamo un IF statement per operare con la seconda opzione:

 if(tipo_donchian == ATR_Correction)
        {
         
        }

E aggiungiamo il calcolo dell’ATR (LINK AL BOOK MQL4), con già la divisione secondo il nostro parametro esterno ATR_Fraction.

Naturalmente, per evitare rogne, andremo a normalizzare il valore ottenuto con il numero di cifre decimali del simbolo su cui carichiamo l’Indicatore.

Questo si ottiene con la funzione NormalizeDouble() e dando come secondo parametro la variabile _Digits. Così:

double Correzione=NormalizeDouble(iATR(_Symbol,PERIOD_CURRENT,ATR_Period,i)/ATR_Fraction,_Digits);

E andiamo semplicemente a copiare ed incollare il codice del Donchian Channel normale, aggiungendo e sottraendo il valore “Correzione”. La funzione ora si presenta così:

      if(tipo_donchian == ATR_Correction)
        {
         double Correzione=NormalizeDouble(iATR(_Symbol,PERIOD_CURRENT,ATR_Period,i)/ATR_Fraction,_Digits);
         DochUPBuffer[i]=iHigh(_Symbol,PERIOD_CURRENT,iHighest(_Symbol,PERIOD_CURRENT,MODE_HIGH,LookBack,i))+Correzione;
         DochDWBuffer[i]=iLow(_Symbol,PERIOD_CURRENT,iLowest(_Symbol,PERIOD_CURRENT,MODE_LOW,LookBack,i))-Correzione;
         DochMIDBuffer[i]=(DochUPBuffer[i]+DochDWBuffer[i])/2;
        }

Salviamo il lavoro, e compiliamo con F7 da tastiera.

Ora il nostro Donchian Corretto Sambuca è pronto per evitarci qualche ingresso di troppo, ammorbidendo le linee manco fosse il Coccolino, in modo dinamico e legato all’Average True Range.

Ecco uno screen per mostrare la differenza:

Donchian Channel MT4

Puoi giocare con le impostazioni, fare un po’ di esperimenti. Vedere su quali Time Frame sono più performanti i valori di input.

Insomma, puoi fare quello che ti pare, basta che poi mi scrivi nei commenti come va. <3

Per permetterti ciò, ecco il codice completo fino a questo punto. 🙂

//+------------------------------------------------------------------+
//|                                                  Donchianina.mq4 |
//|                                                 D'ario Woollover |
//|                               https://www.automazionetrading.com |
//+------------------------------------------------------------------+
#property copyright "D'ario Woollover"
#property link      "https://www.automazionetrading.com"
#property version   "1.00"
#property strict
#property indicator_chart_window
#property indicator_buffers 3
#property indicator_plots   3
//--- plot DochUP
#property indicator_label1  "DochUP"
#property indicator_type1   DRAW_LINE
#property indicator_color1  clrSteelBlue
#property indicator_style1  STYLE_SOLID
#property indicator_width1  2
//--- plot DochDW
#property indicator_label2  "DochDW"
#property indicator_type2   DRAW_LINE
#property indicator_color2  clrCrimson
#property indicator_style2  STYLE_SOLID
#property indicator_width2  2
//--- plot DochMID
#property indicator_label3  "DochMID"
#property indicator_type3   DRAW_LINE
#property indicator_color3  clrDarkViolet
#property indicator_style3  STYLE_SOLID
#property indicator_width3  2
//--- indicator buffers
double         DochUPBuffer[];
double         DochDWBuffer[];
double         DochMIDBuffer[];

enum DONCHIAN_MODE
  {
   Classic, // Donchian Channel Classico
   ATR_Correction // Correzione dei valori con l'ATR
  };

input int LookBack=20;

input DONCHIAN_MODE tipo_donchian=Classic;
input int ATR_Period=14;
input int ATR_Fraction=6;

//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- indicator buffers mapping
   SetIndexBuffer(0,DochUPBuffer);
   SetIndexBuffer(1,DochDWBuffer);
   SetIndexBuffer(2,DochMIDBuffer);

//---
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int OnCalculate(const int rates_total,
                const int prev_calculated,
                const datetime &time[],
                const double &open[],
                const double &high[],
                const double &low[],
                const double &close[],
                const long &tick_volume[],
                const long &volume[],
                const int &spread[])
  {
//---
   int limit=0;
   int bars = rates_total - 1;
   if(prev_calculated > 0)
     {
      bars = rates_total - prev_calculated;
     }

   for(int i = bars; i >= 0; i--)
     {
      if(tipo_donchian == Classic)
        {
         DochUPBuffer[i]=iHigh(_Symbol,PERIOD_CURRENT,iHighest(_Symbol,PERIOD_CURRENT,MODE_HIGH,LookBack,i));
         DochDWBuffer[i]=iLow(_Symbol,PERIOD_CURRENT,iLowest(_Symbol,PERIOD_CURRENT,MODE_LOW,LookBack,i));
         DochMIDBuffer[i]=(DochUPBuffer[i]+DochDWBuffer[i])/2;
        }
      if(tipo_donchian == ATR_Correction)
        {
         double Correzione=NormalizeDouble(iATR(_Symbol,PERIOD_CURRENT,ATR_Period,i)/ATR_Fraction,_Digits);
         DochUPBuffer[i]=iHigh(_Symbol,PERIOD_CURRENT,iHighest(_Symbol,PERIOD_CURRENT,MODE_HIGH,LookBack,i))+Correzione;
         DochDWBuffer[i]=iLow(_Symbol,PERIOD_CURRENT,iLowest(_Symbol,PERIOD_CURRENT,MODE_LOW,LookBack,i))-Correzione;
         DochMIDBuffer[i]=(DochUPBuffer[i]+DochDWBuffer[i])/2;
        }
     }
//--- return value of prev_calculated for next call
   return(rates_total);
  }
//+------------------------------------------------------------------+

La teoria che c’è dietro gli scostamenti percentuali

Valutare gli spostamenti dei prezzi è sempre un lavoro difficile, specialmente nel magico mondo del retail trading.

Esistono DECINE se non CENTINAIA di MIGLIARDI di indicatori diversi, ciascuno che elabora il valore “prezzo” in modi bislacchi ed arzigogolati.

Uno dei modi per valutare le variazioni di prezzo è il vecchio, polveroso, banalotto calcolo percentuale.

Cioè capire di quanto si è mosso il prezzo in termini percentuali rispetto al precedente prezzo.

Questa analisi va abbastanza per la maggiore tra i “quant“, quelle persone che d’inverno quando fa freddo si mettono i “guant“.

No scherzo. Sono quei cervelloni che modellano il mercato grazie alla matematica, la Big Data Analysis, il Machine Learning, analisi Quantitativa (da qui la parola Quant) e tutte ‘ste robe da Power Nerd per guadagnare (o far guadagnare) un sacc’ de sord’.

Ormai il mondo è in mano ai programmatori.

Detto ciò, il signor Donchiani Riccardo mi apparve in sogno e mi suggerì di aggiungere altre due linee alla Donchianina, che rispondessero a delle variazioni percentuali rispetto ai valori superiore ed inferiore del canale.

Qui la cosa si complica, perché dovremo pure aggiungere due plot e fare modifiche al codice. Se ti senti ok, procediamo pure.

Donchian Channel + scostamenti percentuali | Costruiamo il codice

Quello a cui voglio arrivare è un grafico come questo, con due ulteriori tracce:

Donchian Channel MT4

Queste tracce rappresentano la variazione percentuale a partire dal Donchian Channel, ed in particolare sto studiando cosa mi possono suggerire.

Un’idea è che se il MAX-percentuale è INFERIORE al MIN+percentuale, significa che NON siamo in presenza di VOLA(tilità).

Questo perché il prezzo si sta muovendo pochissimo in relazione ai prezzi precedenti. AD esempio nel rettangolo rossiccio, possiamo vedere che il prezzo torna in una zona “normale” dopo che questi due valori sono tornati al loro posto (quello sopra, torna sopra, e quello sotto torna sotto):

Donchian Channel MT4

Questa è la teoria, o meglio è UNA teoria. Ti ho detto… questa è sperimentazione live, sta a te applicarla come e dove ti serve.

Passiamo al codice. Vado spedito perché abbiamo già visto quasi tutto nei passaggi precedenti.

Prima cosa: Aggiungo due plot e dichiaro che i miei buffer e i miei plot sono diventati 5, non più 3:

#property indicator_buffers 5
#property indicator_plots   5

E diamo un tocco di stile (sempre Gay Friendly, mi raccomando) alle linee aggiuntive:

//--- plot TopEdge
#property indicator_label4  "TopEdge"
#property indicator_type4   DRAW_LINE
#property indicator_color4  clrBlueViolet
#property indicator_style4  STYLE_DOT
#property indicator_width4  1
//--- plot BottomEdge
#property indicator_label5  "BottomEdge"
#property indicator_type5   DRAW_LINE
#property indicator_color5  clrSaddleBrown
#property indicator_style5  STYLE_DOT
#property indicator_width5  1

Dichiariamo i due buffer aggiuntivi, sempre di tipo double (sono prezzi, con la virgola!)

double         DochTopEdgeBuffer[];
double         DochBottomEdgeBuffer[];

E correggiamo il nostro ENUM, facendo in modo di aggiungere un’opzione:

enum DONCHIAN_MODE
  {
   Classic, // Donchian Channel Classico
   ATR_Correction, // Correzione dei valori con l'ATR
   Percentage //Market Edges
  };

Aggiungiamo anche l’input esterno per inserire la percentuale desiderata:

input double Percent=0.25;

Associo ogni buffer nuovo con il suo bel plot:

   SetIndexBuffer(3,DochTopEdgeBuffer);
   SetIndexBuffer(4,DochBottomEdgeBuffer);

Ed infine non ci resta che aggiungere la funzione di calcolo.
Calcoleremo lo scostamento percentuale, togliendo al canale superiore un tot % di sé stesso ed aggiungendo a quello inferiore lo stesso tot% di sé stesso.

Il tutto, naturally, dentro un IF statement che ci legge l’opzione in input che abbiamo scelto con il nostro ENUM:

      if(tipo_donchian == Percentage)
        {
         DochUPBuffer[i]=iHigh(_Symbol,PERIOD_CURRENT,iHighest(_Symbol,PERIOD_CURRENT,MODE_HIGH,LookBack,i));
         DochDWBuffer[i]=iLow(_Symbol,PERIOD_CURRENT,iLowest(_Symbol,PERIOD_CURRENT,MODE_LOW,LookBack,i));
         DochMIDBuffer[i]=(DochUPBuffer[i]+DochDWBuffer[i])/2;
         DochTopEdgeBuffer[i]=DochUPBuffer[i]-(DochUPBuffer[i]*Percent/100);
         DochBottomEdgeBuffer[i]=DochDWBuffer[i]+(DochDWBuffer[i]*Percent/100);
        }

Bella lì. Fine del cinema.

Pubblicità.

Questo è la traduzione su piattaforma di un’idea di potenziale trading che mi sono fatto. Non la sto tradando e non la sto tradendo, sia chiaro, è un altro esercizio come quello sulle griglie.

Serve per imparare qualche trick di programmazione ed avere dei tuoi strumenti per validare le TUE idee.

Il modo migliore per essere un loser è tradare gli INDICATORI, e non le IDEE.

Pensaci. Ciascun trader entra a mercato con l’IDEA che il suo trade sia vincente.

Finché avrai idee, avrai armi per sopravvivere.

Vabbè, ‘sta deriva filosofica ha ance rottoercà, quindi, screenshot finale, codice definitivo, stappiamo lo spumante e chiudiamo l’articolaccio!

Donchian Channel MT4

Ah, qualora usassi questo codice, Market Edges l’ho inventato io. Non fare l’infame. <3

Ecco il codicillo!

//+------------------------------------------------------------------+
//|                                                  Donchianina.mq4 |
//|                                                 D'ario Woollover |
//|                               https://www.automazionetrading.com |
//+------------------------------------------------------------------+
#property copyright "D'ario Woollover"
#property link      "https://www.automazionetrading.com"
#property version   "1.00"
#property strict
#property indicator_chart_window
#property indicator_buffers 5
#property indicator_plots   5
//--- plot DochUP
#property indicator_label1  "DochUP"
#property indicator_type1   DRAW_LINE
#property indicator_color1  clrSteelBlue
#property indicator_style1  STYLE_SOLID
#property indicator_width1  2
//--- plot DochDW
#property indicator_label2  "DochDW"
#property indicator_type2   DRAW_LINE
#property indicator_color2  clrCrimson
#property indicator_style2  STYLE_SOLID
#property indicator_width2  2
//--- plot DochMID
#property indicator_label3  "DochMID"
#property indicator_type3   DRAW_LINE
#property indicator_color3  clrYellowGreen
#property indicator_style3  STYLE_SOLID
#property indicator_width3  2
//--- plot TopEdge
#property indicator_label4  "TopEdge"
#property indicator_type4   DRAW_LINE
#property indicator_color4  clrBlueViolet
#property indicator_style4  STYLE_DOT
#property indicator_width4  1
//--- plot BottomEdge
#property indicator_label5  "BottomEdge"
#property indicator_type5   DRAW_LINE
#property indicator_color5  clrSaddleBrown
#property indicator_style5  STYLE_DOT
#property indicator_width5  1


//--- indicator buffers
double         DochUPBuffer[];
double         DochDWBuffer[];
double         DochMIDBuffer[];
double         DochTopEdgeBuffer[];
double         DochBottomEdgeBuffer[];

enum DONCHIAN_MODE
  {
   Classic, // Donchian Channel Classico
   ATR_Correction, // Correzione dei valori con l'ATR
   Percentage //Market Edges
  };

input int LookBack=20;

input DONCHIAN_MODE tipo_donchian=Classic;
input int ATR_Period=14;
input int ATR_Fraction=6;
input double Percent=0.25;

//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- indicator buffers mapping
   SetIndexBuffer(0,DochUPBuffer);
   SetIndexBuffer(1,DochDWBuffer);
   SetIndexBuffer(2,DochMIDBuffer);
   SetIndexBuffer(3,DochTopEdgeBuffer);
   SetIndexBuffer(4,DochBottomEdgeBuffer);

//---
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int OnCalculate(const int rates_total,
                const int prev_calculated,
                const datetime &time[],
                const double &open[],
                const double &high[],
                const double &low[],
                const double &close[],
                const long &tick_volume[],
                const long &volume[],
                const int &spread[])
  {
//---
   int limit=0;
   int bars = rates_total - 1;
   if(prev_calculated > 0)
     {
      bars = rates_total - prev_calculated;
     }

   for(int i = bars; i >= 0; i--)
     {
      if(tipo_donchian == Classic)
        {
         DochUPBuffer[i]=iHigh(_Symbol,PERIOD_CURRENT,iHighest(_Symbol,PERIOD_CURRENT,MODE_HIGH,LookBack,i));
         DochDWBuffer[i]=iLow(_Symbol,PERIOD_CURRENT,iLowest(_Symbol,PERIOD_CURRENT,MODE_LOW,LookBack,i));
         DochMIDBuffer[i]=(DochUPBuffer[i]+DochDWBuffer[i])/2;
        }
      if(tipo_donchian == ATR_Correction)
        {
         double Correzione=NormalizeDouble(iATR(_Symbol,PERIOD_CURRENT,ATR_Period,i)/ATR_Fraction,_Digits);
         DochUPBuffer[i]=iHigh(_Symbol,PERIOD_CURRENT,iHighest(_Symbol,PERIOD_CURRENT,MODE_HIGH,LookBack,i))+Correzione;
         DochDWBuffer[i]=iLow(_Symbol,PERIOD_CURRENT,iLowest(_Symbol,PERIOD_CURRENT,MODE_LOW,LookBack,i))-Correzione;
         DochMIDBuffer[i]=(DochUPBuffer[i]+DochDWBuffer[i])/2;
        }
      if(tipo_donchian == Percentage)
        {
         DochUPBuffer[i]=iHigh(_Symbol,PERIOD_CURRENT,iHighest(_Symbol,PERIOD_CURRENT,MODE_HIGH,LookBack,i));
         DochDWBuffer[i]=iLow(_Symbol,PERIOD_CURRENT,iLowest(_Symbol,PERIOD_CURRENT,MODE_LOW,LookBack,i));
         DochMIDBuffer[i]=(DochUPBuffer[i]+DochDWBuffer[i])/2;
         DochTopEdgeBuffer[i]=DochUPBuffer[i]-(DochUPBuffer[i]*Percent/100);
         DochBottomEdgeBuffer[i]=DochDWBuffer[i]+(DochDWBuffer[i]*Percent/100);
        }
     }
//--- return value of prev_calculated for next call
   return(rates_total);
  }
//+------------------------------------------------------------------+

Considerazioni Finali

Mi riservo il mese di gennaio per approfondire qualche Expert Advisor che tradi questi concetti, finora i risultati sono stati abbastanza deludenti, ma confido che saranno altrettanto deludenti anche in futuro.

Se l’articolo ti è piaciuto Condividilo e spara un like sulla pagina Facebook di Automazione Trading.

Questo di solito genera nell’autore un piccolo squeeze dell’amigdala, liberando serotonina, che, chimicamente parlando, è la pura felicità.

Te ne sono grato.

Condividi il post se ti è piaciuto

Articolo creato 11

Lascia un commento

Il tuo indirizzo email non sarà pubblicato. I campi obbligatori sono contrassegnati *

Articoli correlati

Inizia a scrivere il termine ricerca qua sopra e premi invio per iniziare la ricerca. Premi ESC per annullare.

Torna in alto
Insert math as
Block
Inline
Additional settings
Formula color
Text color
#333333
Type math using LaTeX
Preview
\({}\)
Nothing to preview
Insert
shares