Fibonacci ZigZag - indicatore per MetaTrader 5

Avremo bisogno di :

• 1 grafico a zig-zag
• 2 buffer di dati per i massimi e i minimi
• parametri di input
• un insieme continuo di variabili di sistema che si azzerano ogni volta che l'indicatore viene ricalcolato.

#property indicator_buffers 2
#property indicator_plots 1
input double retracement=23.6;//importo del ritracciamento
input double minSizeInAtrUnits=0.0;/min dimensione delle onde in unità atr
input int rollingAtrPeriod=14;//periodo di rotazione dell'atr
input color Color=clrDodgerBlue;//colore dell'onda
input int Width=3;//larghezza dell'onda
input ENUM_LINE_STYLE Style=STYLE_SOLID;//stile onda
//+------------------------------------------------------------------+




//| Funzione di inizializzazione dell'indicatore personalizzata |
//+------------------------------------------------------------------+
//--- onde ascendenti e onde discendenti
  double upWaves[],dwWaves[];

in questo modo non abbiamo un ritracciamento come onda iniziale, ma dobbiamo iniziare la sequenza in qualche modo.

Questo è ciò che facciamo finché non abbiamo un'onda:

   //--- se non abbiamo ancora un tipo di onda
     else{
       //--- se abbiamo rotto il massimo e non il minimo
         if(high[i]>high_mem&&low[i]>=low_mem){
         double new_wave_size_in_atr_units=((high[i]-low_mem)/_Point)/rollingAtr;
         //--- se la nuova dimensione dell'onda è valida
         if(new_wave_size_in_atr_units>=minSizeInAtrUnits){
           //--- avviare una nuova onda ascendente 
             wave_type=1;
           //--- il prezzo iniziale è il mem basso 
             wave_start_price=low_mem;
             wave_start_distance=distance_from_low;
           //--- il prezzo finale è il nuovo massimo
             wave_end_price=high[i];
             wave_end_distance=0;
           //--- disegnare l'onda 
             dwWaves[i-wave_start_distance]=low_mem;
             upWaves[i]=high[i];
           //--- cambiare il valore alto
             high_mem=high[i];
             distance_from_high=0;
           //--- cambiare il basso 
             low_mem=low[i];
             distance_from_low=0;
           }
           } 
       //--- se abbiamo rotto il minimo e non il massimo
         else if(low[i]<low_mem&&high[i]<=high_mem){
         double new_wave_size_in_atr_units=((high_mem-low[i])/_Point)/rollingAtr;
         //--- se la nuova dimensione dell'onda è valida
         if(new_wave_size_in_atr_units>=minSizeInAtrUnits){         
           //--- inizia una nuova onda discendente 
             wave_type=-1;
           //--- il prezzo iniziale è il mem alto 
             wave_start_price=high_mem;
             wave_start_distance=distance_from_high;
           //--- il prezzo finale è il nuovo minimo
             wave_end_price=low[i];
             wave_end_distance=0;
           //--- disegnare l'onda 
             upWaves[i-wave_start_distance]=high_mem;
             dwWaves[i]=low[i];
           //--- cambiare il valore alto
             high_mem=high[i];
             distance_from_high=0;
           //--- cambiare il basso 
             low_mem=low[i];
             distance_from_low=0;
           }
           }
       //--- se abbiamo rotto entrambi
         else if(low[i]<low_mem&&high[i]>high_mem){
           //--- cambiarli
             high_mem=high[i];
             low_mem=low[i];
             distance_from_high=0;
             distance_from_low=0;
           }
       }

Ottimo. Ora il pezzo finale.

• Se abbiamo un'onda ascendente:

1. se si verifica un nuovo massimo, spostiamo lo zigzag dalla posizione del massimo precedente a quella del nuovo massimo, cosa che possiamo fare dal momento che conserviamo le distanze tra le barre. Aggiorniamo anche il minimo e la distanza dal minimo. Lo facciamo in modo da poter cogliere il minimo più basso dal picco e controllare se ritraccia abbastanza per iniziare un nuovo minimo
2. se viene fatto un nuovo minimo, o se viene impostato un nuovo minimo, calcoliamo la distanza dal picco al minimo e la dividiamo per la dimensione dell'onda. Quindi, se la dimensione dell'onda è di 100 punti e il ritracciamento è di 24 punti, otteniamo 24/100 0,24, quindi x 100 24%. Se la dimensione della nuova "futura" onda che ritraccia la precedente è valida anche rispetto alle unità atr, iniziamo una nuova onda discendente, impostiamo i nuovi massimi e minimi locali, impostiamo le distanze delle barre.

       //--- se abbiamo un'onda positiva 
         if(wave_type==1){
           //--- se l'onda si espande verso l'alto 
             if(high[i]>wave_end_price){
               //--- rimuovere il prezzo finale precedente dalla sua posizione nell'array (0.0=vuoto)
                upWaves[i-wave_end_distance]=0.0;
               //--- posizionarlo nella nuova posizione
                upWaves[i]=high[i];
                wave_end_price=high[i];
                wave_end_distance=0;
               //--- cambiare il valore alto
                high_mem=high[i];
                distance_from_high=0;
               //--- cambiare il basso 
                low_mem=low[i];
                distance_from_low=0;
               }
           //--- controllare il ritracciamento
             if(low[i]<low_mem||distance_from_low==0){
               low_mem=low[i];
               distance_from_low=0;
               double size_of_wave=(wave_end_price-wave_start_price)/_Point;
               double size_of_retracement=(wave_end_price-low_mem)/_Point;
               if(size_of_wave>0.0){
                 double retraced=(size_of_retracement/size_of_wave)*100.0;
                 double new_wave_size_in_atr_units=((wave_end_price-low_mem)/_Point)/rollingAtr;
               //--- se la nuova dimensione dell'onda è valida
               if(new_wave_size_in_atr_units>=minSizeInAtrUnits){
                 //--- se il ritracciamento è significativo, inizia un'onda discendente
                   if(retraced>=retracement){
                    //--- inizia una nuova onda discendente 
                      wave_type=-1;
                    //--- il prezzo iniziale è il mem alto 
                      wave_start_price=high[i-distance_from_high];
                      wave_start_distance=distance_from_high;
                    //--- il prezzo finale è il nuovo minimo
                      wave_end_price=low[i];
                      wave_end_distance=0;
                    //--- disegnare l'onda 
                      upWaves[i-wave_start_distance]=high_mem;
                      dwWaves[i]=low[i];
                    //--- cambiare il valore alto
                      high_mem=high[i];
                      distance_from_high=0;
                    //--- cambiare il basso 
                      low_mem=low[i];
                      distance_from_low=0;                     
                     }
                   }
                 }
               }
           }

Facciamo il contrario quando abbiamo un'onda discendente.

E abbiamo finito, il nostro zig zag di ritracciamento è pronto.

Ecco lo zig zag con un ritracciamento del 23,6% e una dimensione minima delle onde di 0,0 in unità atr

ed ecco lo stesso zig zag con onde di dimensione 3 min in unità atr