RenkoOneBuffer

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

//|                                               RenkoOneBuffer.mq4 |

//|                                                            IgorM |

//|                              https://www.mql5.com/ru/users/igorm |

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

#property copyright "IgorM"

#property link      "https://www.mql5.com/ru/users/igorm"

#property version   "1.00"

#property description "=48:0B>@ RenkoOneBuffer ?>72>;O5B >B>1@060BL 3@0D8:8  5=:> 2 >:=5 8=48:0B>@0."

#property description " MB>< 8=48:0B>@5 @0AG8BK205AO >48= 1CD5@ 8=48:0B>@0 ( H ), >= A>>B25BA2C5B <0:A8<0;L=>9 F5=5 10@0  5=:> ( High[ ] )"

#property description "2B>@>9 8=48:0B>@=K9 1CDD5@ ( L ) =5 O2;O5BAO @0AG5B=K< - >= 8=D>@<0F8>==K9 8 A;C68B 4;O 287C0;870F88 <8=8<0;L=>9 F5=K 10@0  5=:> ( Low[ ] = High 5=:> - BoxSize )."

#property description "With special thanks to maj1es2tic"



//    =48:0B>@ RenkoOneBuffer ?>72>;O5B >B>1@060BL 3@0D8:8  5=:> 2 >:=5 8=48:0B>@0.

//    "8? 3@0D8:>2  5=:> ?>:07K205B ;8HL 42865=8O F5=K, 1>;LH85 7040==>3> (box size).

//    = ?><>305B CAB@0=8BL HC< 8 A>A@54>B>G8BLAO =0 >A=>2=KE B@5=40E.

//    @8 ?>AB@>5=88 3@0D8:0 2@5<O =5 CG8BK205BAO, 8A?>;L7CNBAO ;8HL F5=>2K5 42865=8O.

//    > MB>9 ?@8G8=5 3@0D8:8  5=:> =5 ?>E>68 =0 3@0D8:8 F5=K.

//     MB>< 8=48:0B>@5 @0AG8BK205AO >48= 1CD5@ 8=48:0B>@0 (H[]), >= A>>B25BA2C5B <0:A8<0;L=>9 F5=5 10@0  5=:> ( High[] )

//    2B>@>9 8=48:0B>@=K9 1CDD5@ ( L[] ) =5 O2;O5BAO @0AG5B=K< - >= 8=D>@<0F8>==K9 8 A;C68B 4;O 287C0;870F88 <8=8<0;L=>9 

//    F5=K 10@0  5=:> ( Low[] = High 5=:> - BoxSize )

//    C 8 8B>3: G5< <>65B 1KBL 8=B5@5A5= MB>B 8=48:0B>@?

//    - @0AG5B=K9 2A53> 1 1CD5@, >AB0;L=K5 8=48:0B>@=K5 1CD5@0 <>6=> 8A?>;L7>20BL 4;O @0AG5B0 A>1AB25==KE B5E=8G5A:8E 8=68:0B>@>2 =0 1075 @0AG8B0==>3> High 5=:>

//    - DC=:F8O @0AG5B0  5=:> 10@>2 =0 8AB>@8G5A:8E 40==KE >D>@<;5=0 2 2845 >B45;L=>9 DC=:F88 int RENKO( int NBar,double BoxP,double &R[] )

//       55 <>6=> 8A?>;L7>20BL :0: A0<>AB>OB5;L=CN DC=:F8N 2 A>25B=8:0E =5 8A?>;L7CO 8=48:0B>@



#property strict

#property indicator_separate_window

#property indicator_buffers 2

#property indicator_plots   2

//--- plot Label1

#property indicator_label1  "R_High"

#property indicator_type1   DRAW_HISTOGRAM

#property indicator_color1  clrGreen

#property indicator_width1  3

//--- plot Label2

#property indicator_label2  "R_Low"

#property indicator_type2   DRAW_HISTOGRAM

#property indicator_color2  clrBlack

#property indicator_width2  3



input double   RenkoBoxSize   = 10;         // KA>B0 10@0  5=:>

input int      History        = -1;         // 3@0=8G8BL 8AB>@8G5A:85 40==K5

input int      RenkoHistory   = -1;         // 3@0=8G8BL :>;8G5AB2>  5=:> 10@>2



static double BoxPoints,PrevLow,PrevHigh,CurLow,CurHigh;

static int AllCalc,DG,StartBar;

static datetime newBar=0;

//--- indicator buffers

double        H[],L[];

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

//| Custom indicator initialization function                         |

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

int OnInit()

  {

//--- indicator buffers mapping  

   SetIndexBuffer(0,H);

   SetIndexBuffer(1,L);

   DG=Digits;

   newBar=0;

   if(History>0) StartBar=MathMin(History,Bars-1); else StartBar=Bars -1;

   BoxPoints=NormalizeDouble(RenkoBoxSize*Point,DG);

   switch(DG)

     {

      case 6:  BoxPoints=NormalizeDouble(RenkoBoxSize*100*Point,DG);

      break;

      case 5:  BoxPoints=NormalizeDouble(RenkoBoxSize*10*Point,DG);

      break;

      case 4:  if(StringFind(Symbol(),"JPY")!=-1) BoxPoints=NormalizeDouble(RenkoBoxSize*100*Point,DG);

      break;

      case 3:  if(StringFind(Symbol(),"JPY")!=-1) BoxPoints=NormalizeDouble(RenkoBoxSize*10*Point,DG);

      break;

     }

   AllCalc=0;

   ArrayInitialize(H,EMPTY_VALUE);

   ArrayInitialize(L,EMPTY_VALUE);

//---

   return(INIT_SUCCEEDED);

  }

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

//|   OnDeinit                                                       |

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

void OnDeinit(const int reason)

  {

  }

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

//| Custom indicator iteration function                              |

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

int OnCalculate(const int rates_total,

                const int prev_calculated,

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

  {

//---

   int i;

   if(prev_calculated==0)

     {

      double tmparr[];

      AllCalc=0;

      ArrayInitialize(H,EMPTY_VALUE);

      ArrayInitialize(L,EMPTY_VALUE);

      if(IsTesting()) ArrayResize(tmparr,1,2000); else ArrayResize(tmparr,1,150000);

      AllCalc=RENKO(StartBar,BoxPoints,tmparr);

      ArraySetAsSeries(tmparr,true);

      if(RenkoHistory>0) AllCalc=MathMin(RenkoHistory+2,rates_total -1);

      if(AllCalc>rates_total-1) AllCalc=rates_total -1;

      for(i=0;i<AllCalc;i++)

        {

         H[i]=NormalizeDouble(tmparr[i],DG);

         L[i]=NormalizeDouble(tmparr[i]-BoxPoints,DG);

        }

      ArrayFree(tmparr);

      newBar=Time[0];

     }

   else

     {

      AllCalc=prev_calculated;

      if(newBar!=Time[0])

        {

         newBar=Time[0];

         for(i=0;i<AllCalc;i++)

           {

            H[i] = H[i+1];

            L[i] = L[i+1];

           }

         if(AllCalc<rates_total)

           {

            H[AllCalc] = EMPTY_VALUE;

            L[AllCalc] = EMPTY_VALUE;

           }

        }

      if(Bid>PrevHigh+BoxPoints || NormalizeDouble(PrevHigh+BoxPoints-Bid,8)==0)

        {

         while(Bid>PrevHigh+BoxPoints || NormalizeDouble(PrevHigh+BoxPoints-Bid,8)==0)

           {

            PrevHigh+=BoxPoints; PrevLow+=BoxPoints;

            CurHigh=PrevHigh; CurLow=PrevHigh;

            H[0]=NormalizeDouble(PrevHigh,DG);

            L[0] = NormalizeDouble(PrevHigh - BoxPoints,DG);

            for(i=AllCalc-1;i>=0;i--)

              {

               H[i+1] = H[i];

               L[i+1] = L[i];

              }

            AllCalc++;

            if(AllCalc>rates_total-1)AllCalc=rates_total -1;

           }

        }

      else if(Bid<PrevLow-BoxPoints || NormalizeDouble(PrevLow-BoxPoints-Bid,8)==0)

        {

         while(Bid<PrevLow-BoxPoints || NormalizeDouble(PrevLow-BoxPoints-Bid,8)==0)

           {

            PrevHigh-=BoxPoints; PrevLow-=BoxPoints;

            CurHigh=PrevLow; CurLow=PrevLow;

            H[0] = NormalizeDouble(PrevHigh,DG);

            L[0] = NormalizeDouble(PrevHigh - BoxPoints,DG);

            for(i=AllCalc-1;i>=0;i--)

              {

               H[i+1] = H[i];

               L[i+1] = L[i];

              }

            AllCalc++;

            if(AllCalc>rates_total-1)AllCalc=rates_total -1;

           }

        }

      else

        {

         if(Bid>CurHigh) CurHigh = Bid;

         if(Bid < CurLow) CurLow = Bid;

         H[0] = NormalizeDouble(CurHigh,DG);

         L[0] = NormalizeDouble(CurLow,DG);

        }

     }

//--- return value of prev_calculated for next call     

   return(AllCalc);

  }

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

int RENKO(int NBar,double BoxP,double &R[])

  {

   int i,calc;

   bool UpTrend;

   calc=0;

   PrevLow=NormalizeDouble(MathFloor(Close[NBar-1]/BoxP)*BoxP,Digits);

   PrevHigh=PrevLow+BoxP;

   i=NBar-2;

   if(i<1) i=2;

   while(i>=0)

     {

      UpTrend=High[i]+Low[i]>High[i+1]+Low[i+1];

      while(UpTrend && (Low[i]<PrevLow-BoxP || NormalizeDouble(PrevLow-BoxP-Low[i],8)==0))

        {

         PrevHigh-=BoxP; PrevLow-=BoxP; CurHigh=PrevLow; CurLow=PrevLow;

         calc++; ArrayResize(R,calc+1); R[calc]=PrevHigh;

        }

      while(High[i]>PrevHigh+BoxP || NormalizeDouble(PrevHigh+BoxP-High[i],8)==0)

        {

         PrevHigh+=BoxP; PrevLow+=BoxP; CurHigh=PrevHigh;CurLow=PrevHigh;

         calc++; ArrayResize(R,calc+1); R[calc]=PrevHigh;

        }

      while(!UpTrend && (Low[i]<PrevLow-BoxP || NormalizeDouble(PrevLow-BoxP-Low[i],8)==0))

        {

         PrevHigh-=BoxP; PrevLow-=BoxP; CurHigh=PrevLow; CurLow=PrevLow;

         calc++; ArrayResize(R,calc+1); R[calc]=PrevHigh;

        }

      i--;

     }

   calc++;

   ArrayResize(R,calc+1);

   R[calc]=PrevHigh;

   return(calc);

  }

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