Fibonacci ZigZag - indicador para MetaTrader 5

Necesitaremos :

• 1 gráfico en zigzag
• 2 buffers de datos para los máximos y los mínimos
• parámetros de entrada
• un conjunto continuo de variables del sistema que se reinician cada vez que el indicador recalcula

#property indicator_buffers 2
#property indicator_plots 1
input double retracement=23.6;//cantidad de retroceso
input double minSizeInAtrUnits=0.0;//tamaño de las ondas en unidades atr
input int rollingAtrPeriod=14;//periodo atr
input color Color=clrDodgerBlue;//color de onda
input int Width=3;//anchura de onda
input ENUM_LINE_STYLE Style=STYLE_SOLID;//estilo wave
//+------------------------------------------------------------------+




//| Función de inicialización del indicador personalizada |
//+------------------------------------------------------------------+
//--- up waves and the downwaves
  double upWaves[],dwWaves[];

de esta manera no tenemos un retroceso como onda inicial , pero , tenemos que empezar la secuencia de alguna manera.

Esto es lo que hacemos siempre y cuando no tengamos una onda :

   //--- si aún no tenemos un tipo de onda
     else{
       //--- si rompimos el máximo y no el mínimo
         if(high[i]>high_mem&&low[i]>=low_mem){
         double new_wave_size_in_atr_units=((high[i]-low_mem)/_Point)/rollingAtr;
         //--- si el nuevo tamaño de onda es válido
         if(new_wave_size_in_atr_units>=minSizeInAtrUnits){
           //--- iniciar una nueva onda ascendente 
             wave_type=1;
           //--- el precio inicial es el mem bajo 
             wave_start_price=low_mem;
             wave_start_distance=distance_from_low;
           //--- el precio final es el nuevo máximo
             wave_end_price=high[i];
             wave_end_distance=0;
           //--- dibuja la ola 
             dwWaves[i-wave_start_distance]=low_mem;
             upWaves[i]=high[i];
           //--- cambiar el alto
             high_mem=high[i];
             distance_from_high=0;
           //--- cambiar el bajo 
             low_mem=low[i];
             distance_from_low=0;
           }
           } 
       //--- si rompimos el mínimo y no el máximo
         else if(low[i]<low_mem&&high[i]<=high_mem){
         double new_wave_size_in_atr_units=((high_mem-low[i])/_Point)/rollingAtr;
         //--- si el nuevo tamaño de onda es válido
         if(new_wave_size_in_atr_units>=minSizeInAtrUnits){         
           //--- comienza una nueva onda descendente 
             wave_type=-1;
           //--- el precio inicial es la mem alta 
             wave_start_price=high_mem;
             wave_start_distance=distance_from_high;
           //--- el precio final es el nuevo mínimo
             wave_end_price=low[i];
             wave_end_distance=0;
           //--- dibuja la ola 
             upWaves[i-wave_start_distance]=high_mem;
             dwWaves[i]=low[i];
           //--- cambiar el alto
             high_mem=high[i];
             distance_from_high=0;
           //--- cambiar el bajo 
             low_mem=low[i];
             distance_from_low=0;
           }
           }
       //--- si rompemos ambos
         else if(low[i]<low_mem&&high[i]>high_mem){
           //--- cambiarlos
             high_mem=high[i];
             low_mem=low[i];
             distance_from_high=0;
             distance_from_low=0;
           }
       }

Genial. Ahora la pieza final.

• Si tenemos una onda alcista :

1. Si se hace un nuevo máximo, movemos el zigzag desde la posición del máximo anterior a la posición del nuevo máximo, lo que podemos hacer ya que mantenemos las distancias de las barras. También actualizamos el mínimo y la distancia desde el mínimo. Hacemos esto para que podamos coger el mínimo más bajo desde el máximo y comprobar si retrocede lo suficiente para empezar un nuevo mínimo.
2. si se hace un nuevo mínimo, o se establece un nuevo mínimo, calculamos la distancia desde el máximo hasta el mínimo y la dividimos por el tamaño de la onda. Así que si el tamaño de la onda es de 100 puntos y el retroceso es de 24 puntos obtenemos 24/100 0.24 , entonces x 100 24% . Si el tamaño de la nueva onda "sería" que retrocede a la anterior también es válido contra las unidades atr iniciamos una nueva onda descendente, establecemos los nuevos máximos y mínimos locales, establecemos las distancias de las barras.

       //--- si tenemos una onda alcista 
         if(wave_type==1){
           //--- si la onda se expande hacia arriba 
             if(high[i]>wave_end_price){
               //--- elimina el precio final anterior de su posición en el array (0.0=vacío)
                upWaves[i-wave_end_distance]=0.0;
               //--- colocarlo en la nueva posición
                upWaves[i]=high[i];
                wave_end_price=high[i];
                wave_end_distance=0;
               //--- cambiar el alto
                high_mem=high[i];
                distance_from_high=0;
               //--- cambiar el bajo 
                low_mem=low[i];
                distance_from_low=0;
               }
           //--- comprueba el retroceso
             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 el nuevo tamaño de onda es válido
               if(new_wave_size_in_atr_units>=minSizeInAtrUnits){
                 //--- si el retroceso es significativo , inicia una onda descendente
                   if(retraced>=retracement){
                    //--- comienza una nueva onda descendente 
                      wave_type=-1;
                    //--- el precio inicial es la mem alta 
                      wave_start_price=high[i-distance_from_high];
                      wave_start_distance=distance_from_high;
                    //--- el precio final es el nuevo mínimo
                      wave_end_price=low[i];
                      wave_end_distance=0;
                    //--- dibuja la ola 
                      upWaves[i-wave_start_distance]=high_mem;
                      dwWaves[i]=low[i];
                    //--- cambiar el alto
                      high_mem=high[i];
                      distance_from_high=0;
                    //--- cambiar el bajo 
                      low_mem=low[i];
                      distance_from_low=0;                     
                     }
                   }
                 }
               }
           }

Hacemos lo contrario cuando tenemos una onda bajista.

Y ya está, nuestro zig zag de retroceso está listo.

Aquí está el zigzag con 23.6% de retroceso y 0.0 min tamaño de las ondas en unidades atr

y aquí está el mismo zig zag con 3 min tamaño de las ondas en unidades atr