Fractal_Moving_Average

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

//|                                       Fractal_Moving_Average.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 C28=3 A 2>7<>6=>ABLN <5=OBL 0;3>@8B< CA@54=5=8O"

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

#property version   "1.00"

//---- >B@8A>2:0 8=48:0B>@0 2 3;02=>< >:=5

#property indicator_chart_window 

//---- :>;8G5AB2> 8=48:0B>@=KE 1CD5@>2 2

#property indicator_buffers 2 

//---- 8A?>;L7>20=> 2A53> >4=> 3@0D8G5A:>5 ?>AB@>5=85

#property indicator_plots   1

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

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

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

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

#property indicator_type1   DRAW_LINE

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

#property indicator_color1 clrDeepPink

//---- ;8=8O 8=48:0B>@0 - A?;>H=0O

#property indicator_style1  STYLE_SOLID

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

#property indicator_width1  2

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

#property indicator_label1  "Fractal_Moving_Average"

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

//|  >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_MA_METHOD MA_Method=MODE_LWMA; //<5B>4 CA@54=5=8O

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

input int PriceShift=0; // c4283 8=48:0B>@0 ?> 25@B8:0;8 2 ?C=:B0E

input color  Middle_color=clrDeepPink;

input uint FontSize=2; // @07<5@ F5=>2KE <5B>:

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

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

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

double ExtLineBuffer0[];

//---- >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 ExtLineBuffer1[];

//---- 1JO2;5=85 ?5@5<5==>9 7=0G5=8O 25@B8:0;L=>3> A42830 <C28=30

double dPriceShift;

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;

//---- 1JO2;5=85 AB@8=3>2 4;O B5:AB>2KE <5B>:

string upper_name,middle_name,lower_name;

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

//| Fractal_Moving_Average 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);

//---- =8F80;870F8O A42830 ?> 25@B8:0;8

   dPriceShift=_Point*PriceShift;



//---- =8F80;870F8O AB@8=3>2

   middle_name="Fractal_MA middle text lable";



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

   SetIndexBuffer(0,ExtLineBuffer0,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);



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

   SetIndexBuffer(1,ExtLineBuffer1,INDICATOR_CALCULATIONS);

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

   string shortname="";

   StringConcatenate(shortname,"ractal_Moving_Average(",

             e_period,", ",normal_speed,", ",EnumToString(MA_Method),", ",EnumToString(IPC),")");

//--- 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,_Digits+1);

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

  }

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

//| Custom indicator deinitialization function                       |

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

void OnDeinit(const int reason)

  {

//----

   ObjectDelete(0,middle_name);

//----

   ChartRedraw(0);

  }

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

//| 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++) ExtLineBuffer1[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_MA(first,rates_total);

//---- #AB0=>2:0 F5=>2KE <5B>:

   int bar0=rates_total-1;

   SetRightPrice(0,middle_name,0,time[bar0],ExtLineBuffer0[bar0],Middle_color,FontSize);

//----     

   ChartRedraw(0);

   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_MA(int lastBar,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,ExtLineBuffer1);

      priceMin=_lowest(e_period,index,ExtLineBuffer1);

      length=NULL;

      priorDiff=NULL;

      //----

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

        {

         if(priceMax-priceMin>0.0)

           {

            diff=(ExtLineBuffer1[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));



      switch(MA_Method)

        {

         case MODE_EMA :  ExtLineBuffer0[index]=GetEMA(speed,index,ExtLineBuffer1);  break;

         case MODE_LWMA : ExtLineBuffer0[index]=GetLWMA(speed,index,ExtLineBuffer1); break;

         case MODE_SMA :  ExtLineBuffer0[index]=GetSMA(speed,index,ExtLineBuffer1);  break;

         case MODE_SMMA : ExtLineBuffer0[index]=GetSMMA(speed,index,ExtLineBuffer1); break;

        }



      ExtLineBuffer0[index]+=dPriceShift;

     }

  }

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

// 2KG8A;5=85 SMA                                                    |

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

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

  {

//----

   double SMA,sum=NULL;

   for(int iii=0; iii<period; iii++) sum+=inputData[MathMax(index-iii,0)];

   SMA=sum/period;

//----

   return(SMA);

  }

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

// 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);

  }

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

// 2KG8A;5=85 SMMA                                                   |

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

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

  {

//----

   int period_=period-1;

   double SMMA=inputData[index-period];

   for(int iii=period-1; iii>=0; iii--) SMMA=(SMMA*period_+inputData[MathMax(index-iii,0)])/period;

//----

   return(SMMA);

  }

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

// 2KG8A;5=85 LWMA                                                   |

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

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

  {

//----

   double sum=NULL;

   int weightsum=NULL;

   for(int iii=period-1; iii>=0; iii--)

     {

      int ppp=period-iii;

      weightsum+=ppp;

      sum+=ppp*inputData[MathMax(index-iii,0)];

     }

   double LWMA=sum/weightsum;

//----

   return(LWMA);

  }

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

//| 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,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,double &inputData[])

  {

   double lowest=9999999999.0;

//----

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

     {

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

     }

   return( lowest );

  }

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

//|  RightPrice creation                                             |

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

void CreateRightPrice(long chart_id,// chart ID

                      string   name,              // object name

                      int      nwin,              // window index

                      datetime time,              // price level time

                      double   price,             // price level

                      color    Color,             // Text color

                      int     Font                // Text font

                      )

//---- 

  {

//----

   ObjectCreate(chart_id,name,OBJ_ARROW_RIGHT_PRICE,nwin,time,price);

   ObjectSetInteger(chart_id,name,OBJPROP_COLOR,Color);

   ObjectSetInteger(chart_id,name,OBJPROP_WIDTH,Font);

   ObjectSetInteger(chart_id,name,OBJPROP_BACK,true);

//----

  }

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

//|  RightPrice reinstallation                                       |

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

void SetRightPrice(long chart_id,// chart ID

                   string   name,              // object name

                   int      nwin,              // window index

                   datetime time,              // price level time

                   double   price,             // price level

                   color    Color,             // Text color

                   int      Font               // Text font

                   )

//---- 

  {

//----

   if(ObjectFind(chart_id,name)==-1) CreateRightPrice(chart_id,name,nwin,time,price,Color,Font);

   else ObjectMove(chart_id,name,0,time,price);

//----

  }

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

//| >;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);

  }

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