Fibonacci ZigZag - indicateur pour MetaTrader 5

Nous aurons besoin de :

• 1 graphique en zigzag
• 2 tampons de données pour les hauts et les bas
• des paramètres d'entrée
• un ensemble continu de variables système qui se réinitialisent à chaque fois que l'indicateur recalcule.

#property indicator_buffers 2
#property indicator_plots 1
input double retracement=23.6;//Montant du retracement
input double minSizeInAtrUnits=0.0;//Taille minimale des vagues en unités d'atr
input int rollingAtrPeriod=14;//Période de l'ATR
input color Color=clrDodgerBlue;//couleur de l'onde
input int Width=3;//Largeur d'onde
input ENUM_LINE_STYLE Style=STYLE_SOLID;//style vague
//+------------------------------------------------------------------+




//| Fonction d'initialisation de l'indicateur personnalisé
//+------------------------------------------------------------------+
//--- les vagues montantes et les vagues descendantes
  double upWaves[],dwWaves[];

De cette façon, nous n'avons pas de retracement comme vague initiale, mais nous devons commencer la séquence d'une manière ou d'une autre.

C'est ce que nous faisons tant que nous n'avons pas de vague :

   //--- si nous n'avons pas encore de type de vague
     else{
       //--- si nous avons cassé le plus haut et pas le plus bas
         if(high[i]>high_mem&&low[i]>=low_mem){
         double new_wave_size_in_atr_units=((high[i]-low_mem)/_Point)/rollingAtr;
         //--- si la nouvelle taille de la vague est valide
         if(new_wave_size_in_atr_units>=minSizeInAtrUnits){
           //--- commencer une nouvelle vague ascendante 
             wave_type=1;
           //--- le prix de départ est le prix le plus bas 
             wave_start_price=low_mem;
             wave_start_distance=distance_from_low;
           //--- le prix final est le nouveau maximum
             wave_end_price=high[i];
             wave_end_distance=0;
           //--- dessiner la vague 
             dwWaves[i-wave_start_distance]=low_mem;
             upWaves[i]=high[i];
           //--- changer le niveau élevé
             high_mem=high[i];
             distance_from_high=0;
           //--- changer le bas 
             low_mem=low[i];
             distance_from_low=0;
           }
           } 
       //--- si nous avons cassé le plus bas et non le plus haut
         else if(low[i]<low_mem&&high[i]<=high_mem){
         double new_wave_size_in_atr_units=((high_mem-low[i])/_Point)/rollingAtr;
         //--- si la nouvelle taille de la vague est valide
         if(new_wave_size_in_atr_units>=minSizeInAtrUnits){         
           //--- commencer une nouvelle vague de baisse 
             wave_type=-1;
           //--- le prix de départ est le prix le plus élevé 
             wave_start_price=high_mem;
             wave_start_distance=distance_from_high;
           //--- le prix final est le nouveau prix le plus bas
             wave_end_price=low[i];
             wave_end_distance=0;
           //--- dessiner la vague 
             upWaves[i-wave_start_distance]=high_mem;
             dwWaves[i]=low[i];
           //--- changer le niveau élevé
             high_mem=high[i];
             distance_from_high=0;
           //--- changer le bas 
             low_mem=low[i];
             distance_from_low=0;
           }
           }
       //--- si nous avons cassé les deux
         else if(low[i]<low_mem&&high[i]>high_mem){
           //--- les modifier
             high_mem=high[i];
             low_mem=low[i];
             distance_from_high=0;
             distance_from_low=0;
           }
       }

Très bien. Maintenant, la dernière étape.

• Si nous avons une vague haussière :

1. si un nouveau sommet est atteint, déplacez le zigzag de la position du sommet précédent à la position du nouveau sommet, ce que nous pouvons faire puisque nous conservons les distances entre les barres. Nous mettons également à jour le creux et la distance par rapport au creux. Nous faisons cela afin de pouvoir attraper le creux le plus bas depuis le sommet et vérifier s'il retrace suffisamment pour commencer un nouveau creux.
2. si un nouveau plus bas est atteint, ou si un nouveau plus bas est fixé, nous calculons la distance entre le pic et le plus bas et la divisons par la taille de la vague. Ainsi, si la taille de la vague est de 100 points et que le retracement est de 24 points, nous obtenons 24/100 0,24, puis x 100 24%. Si la taille de la nouvelle vague qui retrace la précédente est également valide par rapport aux unités de l'ATR, nous commençons une nouvelle vague descendante, nous fixons les nouveaux hauts et bas locaux, nous fixons les distances entre les barres.

       //--- si nous avons une vague ascendante 
         if(wave_type==1){
           //--- si l'onde s'étend vers le haut 
             if(high[i]>wave_end_price){
               //--- supprimer le prix final précédent de sa position dans le tableau (0.0=vide)
                upWaves[i-wave_end_distance]=0.0;
               //--- le placer sur la nouvelle position
                upWaves[i]=high[i];
                wave_end_price=high[i];
                wave_end_distance=0;
               //--- changer le niveau élevé
                high_mem=high[i];
                distance_from_high=0;
               //--- changer le bas 
                low_mem=low[i];
                distance_from_low=0;
               }
           //--- vérifier le retracement
             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;
               //--- si la nouvelle taille de la vague est valide
               if(new_wave_size_in_atr_units>=minSizeInAtrUnits){
                 //--- si le retracement est significatif, commencer une vague de baisse
                   if(retraced>=retracement){
                    //--- commencer une nouvelle vague de baisse 
                      wave_type=-1;
                    //--- le prix de départ est le prix le plus élevé 
                      wave_start_price=high[i-distance_from_high];
                      wave_start_distance=distance_from_high;
                    //--- le prix final est le nouveau prix le plus bas
                      wave_end_price=low[i];
                      wave_end_distance=0;
                    //--- dessiner la vague 
                      upWaves[i-wave_start_distance]=high_mem;
                      dwWaves[i]=low[i];
                    //--- changer le niveau élevé
                      high_mem=high[i];
                      distance_from_high=0;
                    //--- changer le bas 
                      low_mem=low[i];
                      distance_from_low=0;                     
                     }
                   }
                 }
               }
           }

Nous faisons l'inverse lorsque nous avons une vague descendante.

Et nous avons terminé, notre zig zag de retracement est prêt.

Voici le zigzag avec un retracement de 23,6% et une taille de vague de 0,0 min en unités d'atr.

et voici le même zig zag avec des vagues de taille 3 min en unités atr