Fractal_ADX_Cloud_v1

ÿþ//+------------------------------------------------------------------+

//|                                            Fractal_ADX_Cloud.mq5 |

//|                              Copyright © 2008, jppoton@yahoo.com |

//|                              http://fractalfinance.blogspot.com/ |

//+------------------------------------------------------------------+ 

#property copyright "Copyright © 2008, jppoton@yahoo.com"

#property link "http://fractalfinance.blogspot.com/"

#property description "$@0:B0;L=K9 ADX"

//---- =><5@ 25@A88 8=48:0B>@0

#property version   "1.01"

//---- >B@8A>2:0 8=48:0B>@0 2 >B45;L=>< >:=5

#property indicator_separate_window

//---- 4;O @0AGQB0 8 >B@8A>2:8 8=48:0B>@0 8A?>;L7>20=> A5<L 1CD5@>2

#property indicator_buffers 7

//---- 8A?>;L7>20=> 420 3@0D8G5A:8E ?>AB@>5=8O

#property indicator_plots   2

//+----------------------------------------------+

//|  0@0<5B@K >B@8A>2:8 1KGL3> 8=48:0B>@0       |

//+----------------------------------------------+

//---- >B@8A>2:0 8=48:0B>@0 1 2 2845 >1;0:0

#property indicator_type1   DRAW_FILLING

//---- 2 :0G5AB25 F25B0 8=48:0B>@0 8A?>;L7>20=K

#property indicator_color1  clrLime,clrRed

//---- >B>1@065=85 <5B:8 8=48:0B>@0

#property indicator_label1  "ADX Cloud"

//+----------------------------------------------+

//|  0@0<5B@K >B@8A>2:8 ADX 8=48:0B>@0          |

//+----------------------------------------------+

//---- >B@8A>2:0 8=48:0B>@0 2 2 2845 ;8=88

#property indicator_type2   DRAW_LINE

//---- 2 :0G5AB25 F25B0 ADX ;8=88 8=48:0B>@0 8A?>;L7>20= A8=89 F25B

#property indicator_color2  clrBlue

//---- ;8=8O 8=48:0B>@0 2 - =5?@5@K2=0O :@820O

#property indicator_style2  STYLE_SOLID

//---- B>;I8=0 ;8=88 8=48:0B>@0 2 @02=0 2

#property indicator_width2  2

//---- >B>1@065=85 <5B:8 8=48:0B>@0

#property indicator_label2  "ADX"

//+----------------------------------------------+

//| 0@0<5B@K >B>1@065=8O 3>@87>=B0;L=KE C@>2=59 |

//+----------------------------------------------+

#property indicator_level1 88.0

#property indicator_level2 50.0

#property indicator_level3 12.0

#property indicator_levelcolor clrGray

#property indicator_levelstyle STYLE_DASHDOTDOT

//+----------------------------------------------+

//|  >1JO2;5=85 ?5@5G8A;5=89                     |

//+----------------------------------------------+

enum ENUM_APPLIED_PRICE_ //"8? :>=AB0=BK

  {

   PRICE_CLOSE_ = 1,     //Close

   PRICE_OPEN_,          //Open

   PRICE_HIGH_,          //High

   PRICE_LOW_,           //Low

   PRICE_MEDIAN_,        //Median Price (HL/2)

   PRICE_TYPICAL_,       //Typical Price (HLC/3)

   PRICE_WEIGHTED_,      //Weighted Close (HLCC/4)

   PRICE_SIMPL_,         //Simpl Price (OC/2)

   PRICE_QUARTER_,       //Quarted Price (HLOC/4) 

   PRICE_TRENDFOLLOW0_,  //TrendFollow_1 Price 

   PRICE_TRENDFOLLOW1_,  //TrendFollow_2 Price

   PRICE_DEMARK_         //Demark Price 

  };

//+----------------------------------------------+

//|  %+  " + "                 |

//+----------------------------------------------+

input uint e_period=30; //3;C18=0  CA@54=5=8O                    

input uint normal_speed=30;

input ENUM_APPLIED_PRICE_ IPC=PRICE_CLOSE_;//F5=>20O :>=AB0=B0

input int Shift=0; // A4283 8=48:0B>@0 ?> 3>@87>=B0;8 2 10@0E

//+----------------------------------------------+

//---- >1JO2;5=85 48=0<8G5A:8E <0AA82>2, :>B>@K5 1C4CB 2 

// 40;L=59H5< 8A?>;L7>20=K 2 :0G5AB25 8=48:0B>@=KE 1CD5@>2

double ExtLineBuffer0[],ExtLineBuffer1[],ExtLineBuffer2[];

//---- >1JO2;5=85 48=0<8G5A:>3> <0AA820, :>B>@K9 1C45B 2 

// 40;L=59H5< 8A?>;L7>20= 2 :0G5AB25 1CD5@0 40==KE

double ExtLineBuffer3[],ExtPDBuffer[],ExtNDBuffer[],ExtTmpBuffer[];

double LOG_2;

//---- 1JO2;5=85 F5;KE ?5@5<5==KE =0G0;0 >BAGQB0 40==KE

int min_rates_total,g_period_minus_1;

//+------------------------------------------------------------------+   

//| XMA BBx3 indicator initialization function                       | 

//+------------------------------------------------------------------+ 

void OnInit()

  {

//---- =8F80;870F8O ?5@5<5==KE =0G0;0 >BAGQB0 40==KE

   min_rates_total=int(MathMax(e_period,normal_speed));

   g_period_minus_1=int(e_period-1);

   LOG_2=MathLog(2.0);



//---- ?@52@0I5=85 48=0<8G5A:>3> <0AA820 2 8=48:0B>@=K9 1CD5@

   SetIndexBuffer(0,ExtLineBuffer1,INDICATOR_DATA);

//---- >ACI5AB2;5=85 A42830 8=48:0B>@0 1 ?> 3>@87>=B0;8

   PlotIndexSetInteger(0,PLOT_SHIFT,Shift);

//---- >ACI5AB2;5=85 A42830 =0G0;0 >BAGQB0 >B@8A>2:8 8=48:0B>@0

   PlotIndexSetInteger(0,PLOT_DRAW_BEGIN,min_rates_total);

//---- CAB0=>2:0 7=0G5=89 8=48:0B>@0, :>B>@K5 =5 1C4CB 2848<K =0 3@0D8:5

   PlotIndexSetDouble(0,PLOT_EMPTY_VALUE,EMPTY_VALUE);

//---- 70?@5B =0 >B>1@065=85 7=0G5=89 8=48:0B>@0 2 ;52>< 25@E=5< C3;C >:=0 8=48:0B>@0

   PlotIndexSetInteger(0,PLOT_SHOW_DATA,false);



//---- ?@52@0I5=85 48=0<8G5A:>3> <0AA820 2 8=48:0B>@=K9 1CD5@

   SetIndexBuffer(1,ExtLineBuffer2,INDICATOR_DATA);





//---- ?@52@0I5=85 48=0<8G5A:>3> <0AA820 2 8=48:0B>@=K9 1CD5@

   SetIndexBuffer(2,ExtLineBuffer0,INDICATOR_DATA);

//---- >ACI5AB2;5=85 A42830 8=48:0B>@0 1 ?> 3>@87>=B0;8

   PlotIndexSetInteger(1,PLOT_SHIFT,Shift);

//---- >ACI5AB2;5=85 A42830 =0G0;0 >BAGQB0 >B@8A>2:8 8=48:0B>@0

   PlotIndexSetInteger(1,PLOT_DRAW_BEGIN,min_rates_total);

//---- CAB0=>2:0 7=0G5=89 8=48:0B>@0, :>B>@K5 =5 1C4CB 2848<K =0 3@0D8:5

   PlotIndexSetDouble(1,PLOT_EMPTY_VALUE,EMPTY_VALUE);

//---- 70?@5B =0 >B>1@065=85 7=0G5=89 8=48:0B>@0 2 ;52>< 25@E=5< C3;C >:=0 8=48:0B>@0

   PlotIndexSetInteger(1,PLOT_SHOW_DATA,false);



//---- ?@52@0I5=85 48=0<8G5A:8E <0AA82>2 2 1CD5@K 40==KE

   SetIndexBuffer(3,ExtLineBuffer3,INDICATOR_CALCULATIONS);

   SetIndexBuffer(4,ExtPDBuffer,INDICATOR_CALCULATIONS);

   SetIndexBuffer(5,ExtNDBuffer,INDICATOR_CALCULATIONS);

   SetIndexBuffer(6,ExtTmpBuffer,INDICATOR_CALCULATIONS);

//---- 8=8F80;870F88 ?5@5<5==>9 4;O :>@>B:>3> 8<5=8 8=48:0B>@0

   string shortname="";

   StringConcatenate(shortname,"Fractal_ADX(",e_period,", ",normal_speed,")");

//--- A>740=85 8<5=8 4;O >B>1@065=8O 2 >B45;L=>< ?>4>:=5 8 2> 2A?;K20NI59 ?>4A:07:5

   IndicatorSetString(INDICATOR_SHORTNAME,shortname);



//--- >?@545;5=85 B>G=>AB8 >B>1@065=8O 7=0G5=89 8=48:0B>@0

   IndicatorSetInteger(INDICATOR_DIGITS,2);

//---- 7025@H5=85 8=8F80;870F88

  }

//+------------------------------------------------------------------+ 

//| Custom iteration function                                        | 

//+------------------------------------------------------------------+ 

int OnCalculate(

                const int rates_total,    // :>;8G5AB2> 8AB>@88 2 10@0E =0 B5:CI5< B8:5

                const int prev_calculated,// :>;8G5AB2> 8AB>@88 2 10@0E =0 ?@54K4CI5< B8:5

                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[]

                )

  {

//---- ?@>25@:0 :>;8G5AB20 10@>2 =0 4>AB0B>G=>ABL 4;O @0AGQB0

   if(rates_total<min_rates_total) return(0);



//---- 1JO2;5=85 ?5@5<5==KE A ?;020NI59 B>G:>9  

   double;

//---- 1JO2;5=85 F5;KE ?5@5<5==KE 8 ?>;CG5=85 C65 ?>AG8B0==KE 10@>2

   int first,bar;



//---- @0AGQB AB0@B>2>3> =><5@0 first 4;O F8:;0 ?5@5AGQB0 10@>2

   if(prev_calculated>rates_total || prev_calculated<=0) // ?@>25@:0 =0 ?5@2K9 AB0@B @0AGQB0 8=48:0B>@0

      first=0; // AB0@B>2K9 =><5@ 4;O @0AGQB0 2A5E 10@>2

   else first=prev_calculated-1; // AB0@B>2K9 =><5@ 4;O @0AGQB0 =>2KE 10@>2



//---- 03@C7:0 40==KE 4;O @0AGQB0 8=48:0B>@0

   for(bar=first; bar<rates_total && !IsStopped(); bar++) ExtLineBuffer3[bar]=PriceSeries(IPC,bar,open,low,high,close);

//---- A=>2=>9 F8:; @0AGQB0 8=48:0B>@0

   if(prev_calculated>rates_total || prev_calculated<=0) first=min_rates_total; // AB0@B>2K9 =><5@ 4;O @0AGQB0 2A5E 10@>2

   FRACTAL_ADX(first,high,low,close,rates_total);

//----     

   return(rates_total);

  }

//+================================================================================================================+

//+=== FUNCTION : _computeLastNbBars                                                                            ===+

//+===                                                                                                          ===+

//+===                                                                                                          ===+

//+=== This callback is fired by metatrader for each tick                                                       ===+

//+===                                                                                                          ===+

//+=== In :                                                                                                     ===+

//+===    - lastBars : these "n" last bars must be repainted                                                    ===+

//+===                                                                                                          ===+

//+================================================================================================================+

//+------------------------------------------------------------------+

//| FUNCTION : FRACTAL_MA                                            |

//| Compute the Fractal Bands for input data                         |

//| In :                                                             |

//|    - lastBars : these "n" last bars are considered for           |

//|      calculating the fractal dimension                           |

//| For further theoretical explanations, see my blog:               |  

//|    http://fractalfinance.blogspot.com/                           |

//+------------------------------------------------------------------+

void FRACTAL_ADX(int lastBar,const double &High[],const double &Low[],const double &Close[],int Rates_Total)

  {

   double diff,priorDiff;

   double length;

   double priceMax,priceMin;

   double fdi,trail_dim,beta,hurst;

   int    speed;

//----

   for(int index=lastBar; index<Rates_Total; index++)

     {

      priceMax=_highest(e_period,index,ExtLineBuffer3);

      priceMin=_lowest(e_period,index,ExtLineBuffer3);

      length=NULL;

      priorDiff=NULL;

      //----

      for(int kkk=0; kkk<=g_period_minus_1; kkk++)

        {

         if(priceMax-priceMin>0.0)

           {

            diff=(ExtLineBuffer3[index-kkk]-priceMin)/(priceMax-priceMin);

            if(kkk>0)

              {

               length+=MathSqrt(MathPow(diff-priorDiff,2.0)+(1.0/MathPow(e_period,2.0)));

              }

            priorDiff=diff;

           }

        }

      if(length>0.0)

        {

         fdi=1.0+(MathLog(length)+LOG_2)/MathLog(2*g_period_minus_1);

        }

      else

        {

/*

         ** The FDI algorithm suggests in this case a zero value.

         ** I prefer to use the previous FDI value.

         */

         fdi=NULL;

        }

      hurst=2-fdi; // The Hurst exponent

      trail_dim=1/hurst; // This is the trail dimension, the inverse of the Hurst-Holder exponent 

      beta=trail_dim/2;

      speed=int(MathRound(normal_speed*beta));

      GetADX(speed,index,High,Low,Close,Rates_Total);

     }

  }

//+------------------------------------------------------------------+

// 2KG8A;5=85 >AF8;;OB>@0 ADX                                        |

//+------------------------------------------------------------------+ 

void GetADX(int period,int index,const double &High[],const double &Low[],const double &Close[],int Rates_Total)

  {

//----

   if(index<period) return;



//--- get some data

   double Hi=High[index];

   double prevHi=High[index-1];

   double Lo=Low[index];

   double prevLo=Low[index-1];

   double prevCl=Close[index-1];

//--- fill main positive and main negative buffers

   double dTmpP=Hi-prevHi;

   double dTmpN=prevLo-Lo;

   dTmpP=MathMax(0,dTmpP);

   dTmpN=MathMax(0,dTmpN);

   if(dTmpP>dTmpN) dTmpN=NULL;

   else

     {

      if(dTmpP<dTmpN) dTmpP=NULL;

      else

        {

         dTmpP=NULL;

         dTmpN=NULL;

        }

     }

//--- define TR

   double tr=MathMax(MathMax(MathAbs(Hi-Lo),MathAbs(Hi-prevCl)),MathAbs(Lo-prevCl));

   //---

      if(tr)

        {

         ExtPDBuffer[index]=100.0*dTmpP/tr;

         ExtNDBuffer[index]=100.0*dTmpN/tr;

        }

      else

        {

         ExtPDBuffer[index]=NULL;

         ExtNDBuffer[index]=NULL;

        }

      //--- fill smoothed positive and negative buffers

      ExtLineBuffer1[index]=GetEMA(period,index,ExtPDBuffer);

      ExtLineBuffer2[index]=GetEMA(period,index,ExtNDBuffer);

      //--- fill ADXTmp buffer

      double dTmp=ExtLineBuffer1[index]+ExtLineBuffer2[index];

      if(dTmp) dTmp=100.0*MathAbs((ExtLineBuffer1[index]-ExtLineBuffer2[index])/dTmp);

      else dTmp=0.0;

      ExtTmpBuffer[index]=dTmp;

      //--- fill smoothed ADX buffer

      ExtLineBuffer0[index]=GetEMA(period,index,ExtTmpBuffer);

//----

  }

//+------------------------------------------------------------------+

// 2KG8A;5=85 EMA                                                    |

//+------------------------------------------------------------------+ 

double GetEMA(int period,int index,double &inputData[])

  {

//----

   double EMA=inputData[index-period];

   double SmoothFactor=2.0/(1.0+period);

   for(int iii=period-1; iii>=0; iii--) EMA=inputData[MathMax(index-iii,0)]*SmoothFactor+EMA*(1.0-SmoothFactor);

//----

   return(EMA);

  }

//+------------------------------------------------------------------+

//| FUNCTION : _highest                                              |

//| Search for the highest value in an array data                    |

//| In :                                                             |

//|    - n : find the highest on these n data                        |

//|    - index : begin to search for from this index                 |

//|    - inputData : data array on which the searching for is done   |

//|                                                                  |

//| Return : the highest value                                       |                                             

//+------------------------------------------------------------------+

double _highest(int n,int index,const double &inputData[])

  {

   double highest=0.0;

//----

   for(int i=index-n+1; i<=index; i++)

     {

      if(inputData[i]>highest) highest=inputData[i];

     }

   return( highest );

  }

//+------------------------------------------------------------------+

//| FUNCTION : _lowest                                               |

//| Search for the lowest value in an array data                     |

//| In :                                                             |

//|    - n : find the hihest on these n data                         |

//|    - index : begin to search for from this index                 |

//|    - inputData : data array on which the searching for is done   |

//|                                                                  |

//| Return : the highest value                                       |

//+------------------------------------------------------------------+

double _lowest(int n,int index,const double &inputData[])

  {

   double lowest=9999999999.0;

//----

   for(int i=index-n+1; i<=index; i++)

     {

      if(inputData[i]<lowest) lowest=inputData[i];

     }

   return( lowest );

  }

//+------------------------------------------------------------------+   

//| >;CG5=85 7=0G5=8O F5=>2>9 B09<A5@88                             |

//+------------------------------------------------------------------+ 

double PriceSeries

(

 uint applied_price,// &5=>20O :>=AB0=B0

 uint   bar,// =45:A A42830 >B=>A8B5;L=> B5:CI53> 10@0 =0 C:070==>5 :>;8G5AB2> ?5@8>4>2 =0704 8;8 2?5@Q4).

 const double &Open[],

 const double &Low[],

 const double &High[],

 const double &Close[]

 )

//PriceSeries(applied_price, bar, open, low, high, close)

//+ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -+

  {

//----

   switch(applied_price)

     {

      //---- &5=>2K5 :>=AB0=BK 87 ?5@5G8A;5=8O ENUM_APPLIED_PRICE

      case  PRICE_CLOSE: return(Close[bar]);

      case  PRICE_OPEN: return(Open [bar]);

      case  PRICE_HIGH: return(High [bar]);

      case  PRICE_LOW: return(Low[bar]);

      case  PRICE_MEDIAN: return((High[bar]+Low[bar])/2.0);

      case  PRICE_TYPICAL: return((Close[bar]+High[bar]+Low[bar])/3.0);

      case  PRICE_WEIGHTED: return((2*Close[bar]+High[bar]+Low[bar])/4.0);



      //----                            

      case  8: return((Open[bar] + Close[bar])/2.0);

      case  9: return((Open[bar] + Close[bar] + High[bar] + Low[bar])/4.0);

      //----                                

      case 10:

        {

         if(Close[bar]>Open[bar])return(High[bar]);

         else

           {

            if(Close[bar]<Open[bar])

               return(Low[bar]);

            else return(Close[bar]);

           }

        }

      //----         

      case 11:

        {

         if(Close[bar]>Open[bar])return((High[bar]+Close[bar])/2.0);

         else

           {

            if(Close[bar]<Open[bar])

               return((Low[bar]+Close[bar])/2.0);

            else return(Close[bar]);

           }

         break;

        }

      //----         

      case 12:

        {

         double res=High[bar]+Low[bar]+Close[bar];

         if(Close[bar]<Open[bar]) res=(res+Low[bar])/2;

         if(Close[bar]>Open[bar]) res=(res+High[bar])/2;

         if(Close[bar]==Open[bar]) res=(res+Close[bar])/2;

         return(((res-Low[bar])+(res-High[bar]))/2);

        }

      //----

      default: return(Close[bar]);

     }

//----

//return(0);

  }

//+------------------------------------------------------------------+