wedges

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

//|                                                       Wedges.mq4 |

//| Wedges v1.0                               Copyright 2015, fxborg |

//|                                   http://fxborg-labo.hateblo.jp/ |

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

#property copyright "Copyright 2015, fxborg"

#property link      "http://fxborg-labo.hateblo.jp/"

#property version   "1.0"

#property strict

#property indicator_chart_window

#property indicator_buffers 5

#property indicator_type1 DRAW_LINE

#property indicator_type2 DRAW_LINE

#property indicator_type3 DRAW_LINE

#property indicator_type4 DRAW_LINE

#property indicator_type5 DRAW_LINE

//---

#property indicator_color1 LightSeaGreen

#property indicator_color2 LightSeaGreen

#property indicator_color3 DarkGray

#property indicator_color4 DarkGray

#property indicator_color5 Gold

//---

#property indicator_label1 "Wedge"

#property indicator_label2 "Wedge"

#property indicator_label3 "Upper Line"

#property indicator_label4 "Lower Line"

#property indicator_label5 "Trend Line"

//---

#property indicator_width1 2

#property indicator_width2 2

#property indicator_width3 1

#property indicator_width4 1

#property indicator_width5 1

//---

#property indicator_style1 STYLE_SOLID

#property indicator_style2 STYLE_SOLID

#property indicator_style3 STYLE_DOT

#property indicator_style4 STYLE_DOT

#property indicator_style5 STYLE_SOLID

//--- input parameters

input int InpCalcPeriod=100;     // Calculation period

input int InpMaxKeepPeriod=60;   // Maximum Keep period

input string _="1: line only, 2: set buffer ,3:both";

input int InpWedgeLineMode=3;   // WedgeLineMode

input double InpDeviations=1.0; // High Low Bands Deviations

input double InpLineFilter=1.2; // Line Filter Deviations 

input  double InpReversalNoiseFilter=5;  // NoiseFilter (Minimam Reversal Spread) 

//---

double RevNoiseFilter=InpReversalNoiseFilter*Point;

int    ReversalPeriod=6;

int    CalcPeriod=InpCalcPeriod*3;

//---

int min_rates_total;

//--- indicator buffers

double WedgeH_Buffer[];

double WedgeL_Buffer[];

double TopBuffer[];

double BtmBuffer[];

double HighBuffer[];

double LowBuffer[];

double TrendBuffer[];

//---- for calc 

double StdDevBuffer[];

double ScoreH_Buffer[];

double ScoreL_Buffer[];

double SlopeA_Buffer[];

double SlopeB_Buffer[];

double CalcWedgeH_Buffer[];

double CalcWedgeL_Buffer[];

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

//|  Point Type                                                      |

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

struct Point_Type

  {

   int               pos;

   double            point;

  };

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

//| Custom indicator initialization function                         |

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

int OnInit()

  {

//---- Initialization of variables of data calculation starting point

   min_rates_total=1+CalcPeriod+ReversalPeriod+1;

//--- indicator buffers mapping

   IndicatorBuffers(14);

//--- indicator buffers

   SetIndexBuffer(0,WedgeH_Buffer);

   SetIndexBuffer(1,WedgeL_Buffer);

   SetIndexBuffer(2,HighBuffer);

   SetIndexBuffer(3,LowBuffer);

   SetIndexBuffer(4,TrendBuffer);

   SetIndexBuffer(5,TopBuffer);

   SetIndexBuffer(6,BtmBuffer);

   SetIndexBuffer(7,SlopeA_Buffer);

   SetIndexBuffer(8,SlopeB_Buffer);

   SetIndexBuffer(9,StdDevBuffer);

   SetIndexBuffer(10,ScoreH_Buffer);

   SetIndexBuffer(11,ScoreL_Buffer);

   SetIndexBuffer(12,CalcWedgeH_Buffer);

   SetIndexBuffer(13,CalcWedgeL_Buffer);

//   SetIndexArrow(5,159);

//   SetIndexArrow(6,159);

   SetIndexEmptyValue(0,0);

   SetIndexEmptyValue(1,0);

   SetIndexEmptyValue(2,0);

   SetIndexEmptyValue(3,0);

   SetIndexEmptyValue(4,0);

   SetIndexEmptyValue(5,0);

   SetIndexEmptyValue(6,0);

   SetIndexEmptyValue(7,EMPTY_VALUE);

   SetIndexEmptyValue(8,EMPTY_VALUE);

   SetIndexEmptyValue(9,EMPTY_VALUE);

   SetIndexEmptyValue(10,EMPTY_VALUE);

   SetIndexEmptyValue(11,EMPTY_VALUE);

   SetIndexEmptyValue(12,0);

   SetIndexEmptyValue(13,0);

//---

   SetIndexDrawBegin(0,min_rates_total);

   SetIndexDrawBegin(1,min_rates_total);

   SetIndexDrawBegin(2,min_rates_total);

   SetIndexDrawBegin(3,min_rates_total);

   SetIndexDrawBegin(4,min_rates_total);

   SetIndexDrawBegin(5,min_rates_total);

   SetIndexDrawBegin(6,min_rates_total);

//---

   string short_name="Wedges v1.0("+IntegerToString(InpCalcPeriod)+")";

   IndicatorShortName(short_name);

//---

   return(INIT_SUCCEEDED);

  }

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

//| 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,j,k,first;

//--- check for bars count

   if(rates_total<=min_rates_total)

      return(0);

//--- indicator buffers

   ArraySetAsSeries(WedgeH_Buffer,false);

   ArraySetAsSeries(WedgeL_Buffer,false);

   ArraySetAsSeries(HighBuffer,false);

   ArraySetAsSeries(LowBuffer,false);

   ArraySetAsSeries(TrendBuffer,false);

//--- calc buffers

   ArraySetAsSeries(TopBuffer,false);

   ArraySetAsSeries(BtmBuffer,false);

   ArraySetAsSeries(SlopeA_Buffer,false);

   ArraySetAsSeries(SlopeB_Buffer,false);

   ArraySetAsSeries(ScoreH_Buffer,false);

   ArraySetAsSeries(ScoreL_Buffer,false);

   ArraySetAsSeries(StdDevBuffer,false);

   ArraySetAsSeries(CalcWedgeH_Buffer,false);

   ArraySetAsSeries(CalcWedgeL_Buffer,false);

//--- rate data

   ArraySetAsSeries(high,false);

   ArraySetAsSeries(low,false);

   ArraySetAsSeries(close,false);

   ArraySetAsSeries(time,false);

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

//|Init Buffeer                                        |

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

   first=rates_total-InpCalcPeriod+2-1;

   if(first+1<prev_calculated)

      first=prev_calculated-2;

   else

     {

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

        {

         BtmBuffer[i]=0;

         TopBuffer[i]=0;

        }

     }

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

//|Set Top Btm                                         |

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

   for(i=first; i<rates_total-1 && !IsStopped(); i++)

     {

      //--- find top and bottom point 

      if(low[i-2]<MathMin(MathMax(low[i-5],low[i-4]),low[i-1]) && low[i-2]<=low[i-3] && low[i-2]+RevNoiseFilter<close[i-1])

         BtmBuffer[i-2]=low[i-2];

      if(high[i-2]>MathMax(MathMin(high[i-5],high[i-4]),high[i-1]) && high[i-2]>=high[i-3] && high[i-2]-RevNoiseFilter>close[i-1])

         TopBuffer[i-2]=high[i-2];

     }

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

//|Init                                                |

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

   first=rates_total-InpCalcPeriod+2-1;

   if(first+1<prev_calculated)

      first=prev_calculated-2;

   else

     {

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

        {

         TrendBuffer[i]=0.0;

         HighBuffer[i]=0.0;

         LowBuffer[i]=0.0;

         WedgeH_Buffer[i]=0;

         WedgeL_Buffer[i]=0;

        }

     }

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

//|Main loop                                           |

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

   for(i=first; i<rates_total-1 && !IsStopped(); i++)

     {

      TrendBuffer[i]=0;

      SlopeA_Buffer[i]=EMPTY_VALUE;

      SlopeB_Buffer[i]=EMPTY_VALUE;

      StdDevBuffer[i]=EMPTY_VALUE;

      //--- calc trend line

      double price[];

      ArrayResize(price,InpCalcPeriod);

      int sz=0;

      double sum=0.0;

      //---  set HLC/3 data

      for(j=InpCalcPeriod-1;j>=0;j--)

        {

         price[sz]=(high[i-j]+low[i-j]+close[i-j])/3;

         sz++;

        }

      //--- 

      double slope_price,slope_height;

      calc_regression(slope_price,slope_height,InpCalcPeriod,price);

      SlopeA_Buffer[i]=slope_price;

      SlopeB_Buffer[i]=slope_height;

      //--- draw line , calc deviation

      for(j=InpCalcPeriod-1;j>=0;j--)

        {

         TrendBuffer[i-j]=slope_price-(slope_height*j);

         sum+=MathPow(high[i-j]-TrendBuffer[i-j],2);

         sum+=MathPow(low[i-j]-TrendBuffer[i-j],2);

        }

      //--- 

      TrendBuffer[i-InpCalcPeriod]=0;

      StdDevBuffer[i]=MathSqrt(sum/InpCalcPeriod*2);

      //--- 

      bool cancel=false;

      Point_Type UpPoints[];

      Point_Type DnPoints[];

      int top_i=-1;

      int btm_i=-1;

      double new_top,new_btm,top_angle,btm_angle;

      //---

      int upcnt=0,dncnt=0;

      int maxcnt=InpCalcPeriod;

      ArrayResize(UpPoints,0,maxcnt);

      //--- set top points            

      for(j=(i-maxcnt)+1;j<i;j++)

        {

         if(TopBuffer[j]>0)

           {

            upcnt++;

            ArrayResize(UpPoints,upcnt,maxcnt);

            UpPoints[upcnt-1].point=TopBuffer[j]/_Point;

            UpPoints[upcnt-1].pos=j;

           }

        }

      ArrayResize(DnPoints,0,maxcnt);

      //--- set bottom points           

      for(j=(i-maxcnt)+1;j<i;j++)

        {

         if(BtmBuffer[j]>0)

           {

            dncnt++;

            ArrayResize(DnPoints,dncnt,maxcnt);

            DnPoints[dncnt-1].point=BtmBuffer[j]/_Point;

            DnPoints[dncnt-1].pos=j;

           }

        }

      //--- draw high low line

      for(j=InpCalcPeriod-1;j>=0;j--)

        {

         HighBuffer[i-j]=TrendBuffer[i-j]+StdDevBuffer[i]*InpDeviations;

         LowBuffer[i-j]=TrendBuffer[i-j]-StdDevBuffer[i]*InpDeviations;

        }

      HighBuffer[i-InpCalcPeriod]=0;

      LowBuffer[i-InpCalcPeriod]=0;

      //--- check atr filter

      cancel=atr_filter(14,25,50,rates_total-i);

      //---

      if(!cancel)

        {

         //--- 

         if(upcnt>0)

           {

            //--- calc wedges line (upper) 

            if(better_line(top_i,new_top,top_angle,UpPoints,SlopeA_Buffer[i],SlopeB_Buffer[i],StdDevBuffer[i],i,1))

              {

               double score;

               bool best_score=true;

               //--- check deviation filter

               if(CalcWedgeH_Buffer[i-1]!=0 && 

                  (CalcWedgeH_Buffer[i-1]<HighBuffer[i-1]) && 

                  (CalcWedgeH_Buffer[i-1]>LowBuffer[i-1]))

                 {

                  //--- check high score 

                  if(calc_score(score,UpPoints,top_i,high[top_i]/_Point,top_angle/_Point))

                    {

                     ScoreH_Buffer[i]=score;

                     for(k=1;k<InpMaxKeepPeriod;k++)

                       {

                        //--- if not best score then

                        if((ScoreH_Buffer[i-k]!=EMPTY_VALUE) && score>ScoreH_Buffer[i-k])

                          {

                           best_score=false;

                           break;

                          }

                       }

                    }

                 }

               if(best_score)

                 {

                  //--- best score then update

                  for(j=top_i;j<=i;j++) CalcWedgeH_Buffer[j]=new_top-(top_angle*(i-j));

                  CalcWedgeH_Buffer[top_i-1]=0;

                  //--- set buffer by setting

                  if(InpWedgeLineMode==2 || InpWedgeLineMode==3)

                     for(j=top_i-1;j<=i;j++) WedgeH_Buffer[j]=CalcWedgeH_Buffer[j];

                  //--- draw line by setting

                  if(InpWedgeLineMode==1 || InpWedgeLineMode==3)

                    {

                     cleaningObj("Wedge_H");

                     ObjectCreate("Wedge_H"+IntegerToString(1),OBJ_TREND,0,time[top_i],high[top_i],time[i],new_top);

                     ObjectSet("Wedge_H"+IntegerToString(1),OBJPROP_COLOR,LightSeaGreen);

                     ObjectSet("Wedge_H"+IntegerToString(1),OBJPROP_WIDTH,2);

                    }

                 }

              }

           }

         //---            

         if(dncnt>0)

           {

            //--- calc wedges line (upper) 

            if(better_line(btm_i,new_btm,btm_angle,DnPoints,SlopeA_Buffer[i],SlopeB_Buffer[i],StdDevBuffer[i],i,-1))

              {

               double score;

               bool best_score=true;

               //--- check deviation filter

               if(CalcWedgeL_Buffer[i-1]!=0 && 

                  (CalcWedgeL_Buffer[i-1]>LowBuffer[i-1]) && 

                  (CalcWedgeL_Buffer[i-1]<HighBuffer[i-1]))

                 {

                  //--- check high score 

                  if(calc_score(score,DnPoints,btm_i,low[btm_i]/_Point,btm_angle/_Point))

                    {

                     ScoreL_Buffer[i]=score;

                     for(k=1;k<InpMaxKeepPeriod;k++)

                       {

                        //--- if not best score then

                        if((ScoreL_Buffer[i-k]!=EMPTY_VALUE) && score>ScoreL_Buffer[i-k])

                          {

                           best_score=false;

                           break;

                          }

                       }

                    }

                 }

               if(best_score)

                 {

                  //--- best score then update

                  for(j=btm_i;j<=i;j++)CalcWedgeL_Buffer[j]=new_btm-(btm_angle*(i-j));

                  CalcWedgeL_Buffer[btm_i-1]=0;

                  //--- set buffer by setting

                  if(InpWedgeLineMode==2 || InpWedgeLineMode==3)

                     for(j=btm_i-1;j<=i;j++) WedgeL_Buffer[j]=CalcWedgeL_Buffer[j];

                  //--- draw line by setting

                  if(InpWedgeLineMode==1 || InpWedgeLineMode==3)

                    {

                     cleaningObj("Wedge_L");

                     ObjectCreate("Wedge_L"+IntegerToString(1),OBJ_TREND,0,time[btm_i],low[btm_i],time[i],new_btm);

                     ObjectSet("Wedge_L"+IntegerToString(1),OBJPROP_COLOR,LightSeaGreen);

                     ObjectSet("Wedge_L"+IntegerToString(1),OBJPROP_WIDTH,2);

                    }

                 }

              }

           }

        }

      //--- Keep Wedges Line  

      if(CalcWedgeH_Buffer[i-2]>0 && CalcWedgeH_Buffer[i-1]>0)

        {

         CalcWedgeH_Buffer[i]=CalcWedgeH_Buffer[i-1]+(CalcWedgeH_Buffer[i-1]-CalcWedgeH_Buffer[i-2]);

         if(InpWedgeLineMode==2 || InpWedgeLineMode==3)

            WedgeH_Buffer[i]=CalcWedgeH_Buffer[i];

        }

      //--- Keep Wedges Line  

      if(CalcWedgeL_Buffer[i-2]>0 && CalcWedgeL_Buffer[i-1]>0)

        {

         CalcWedgeL_Buffer[i]=CalcWedgeL_Buffer[i-1]+(CalcWedgeL_Buffer[i-1]-CalcWedgeL_Buffer[i-2]);

         if(InpWedgeLineMode==2 || InpWedgeLineMode==3)

            WedgeL_Buffer[i]=CalcWedgeL_Buffer[i];

        }

     }

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

   return(rates_total);

  }

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

//| random func                                        |

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

bool random(int x)

  {

   int ran=MathRand();

   bool res=(MathMod(ran,x)==0);

   return(res);

  }

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

//| Regression                                         |

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

void calc_regression(double  &a,double  &b,int span,double  &price[])

  {

//--- 

   double sumy=0.0; double sumx=0.0; double sumxy=0.0; double sumx2=0.0;

   int x;

   int cnt=0;

//--- 

   for(x=1; x<=span; x++)

     {

      //---

      if(price[x-1]==0)continue;

      sumx+=x;

      sumx2+= x*x;

      sumy += price[x-1];

      sumxy+= price[x-1]*x;

      cnt++;

     }

//---

   double c=sumx2*cnt-sumx*sumx;

   if(c==0.0)

     {

      b=0.0;

      a=sumy/cnt;

     }

   else

     {

      b=(sumxy*cnt-sumx*sumy)/c;

      a=(sumy-sumx*b)/cnt;

      a+=b*span;

     }

  }

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

//| angle_line                                         |

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

bool angle_line(int  &from_pos,double &a,

                double &b,

                const Point_Type  &points[],

                int test_pos,

                double test_price,

                int last_pos,

                double limit_high,double limit_low,int dir)



  {

//--- init

   int p_sz=ArraySize(points);

   if(p_sz < 5) return (false);

   int maxcnt=0;

   double angles[][2];

//--- calc angles

   int cnt=calc_angles(angles,points,p_sz,test_pos,test_price);

   if(cnt==0)return (false);

//--- sort data

   if(dir==1) ArraySort(angles,WHOLE_ARRAY,0,MODE_DESCEND);

   else ArraySort(angles);

//--- calc mean

   double sum=0.0;

   for(int j=0; j<cnt; j++)sum+=angles[j][0];

   double mean=sum/cnt;

//--- calc deviation

   sum=0.0;

   for(int j=0; j<cnt; j++)sum+=MathPow(angles[j][0]-mean,2);

   double StdDev=MathSqrt(sum/cnt)*InpLineFilter;

//--- check filter

   int idx=0;

   bool ok=false;

   for(int j=0;j<cnt;j++)

     {

      //--- 

      idx=j;

      //--- check deviation

      if((dir==1 && angles[j][0]<mean+StdDev) || (dir==-1 && angles[j][0]>mean-StdDev))

        {

         //--- check high low limit

         double chk_a=(test_price+(last_pos-test_pos)*angles[j][0])*_Point;

         if((chk_a<limit_high) && (chk_a>limit_low))

           {

            ok=true;

            break;

           }

        }

     }

   if(!ok) return (false);

//--- set result

   a=(test_price+(last_pos-test_pos)*angles[idx][0])*_Point;

   b=angles[idx][0] * _Point;

   from_pos=(int)MathMin(test_pos,angles[idx][1]);

   return(true);

//--- 

  }

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

//| calculating the slope angle of to all vertex from starting points|

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

int calc_angles(double  &angles[][2],const Point_Type  &points[],int p_sz,int pos,double price)

  {

   string s="";

   ArrayResize(angles,0,p_sz);

   int cnt=0;

   for(int j=0;j<p_sz;j++)

     {

      int x=points[j].pos-pos;

      if(x==0)continue;

      double y=points[j].point-price;

      cnt++;

      ArrayResize(angles,cnt,p_sz);

      angles[cnt-1][0]=y/x;

      angles[cnt-1][1]=points[j].pos;

     }

   return (cnt);

  }

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

//| better_line                                                      |

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

bool better_line(int  &from_pos,double &a,

                 double &b,

                 const Point_Type  &points[],

                 double slope_price,

                 double slope_height,

                 double slope_dev,

                 int last_pos,

                 int dir)



  {

//--- init 

   int p_sz=ArraySize(points);

   if(p_sz < 5) return (false);

   double distance[][2];

   ArrayResize(distance,0,p_sz);

   int cnt=0;

   int j;

//---  

   for(j=0;j<p_sz;j++)

     {

      //---  

      int x=last_pos-points[j].pos;

      if(x==0)continue;

      //---  base price

      double base_price=(slope_price -(x*slope_height))/_Point;

      //---  distance

      double dist=(points[j].point-base_price);

      //---  check distance by StdDev

      if((dist*dir)>slope_dev*0.5/_Point)

        {

         cnt++;

         ArrayResize(distance,cnt,p_sz);

         distance[cnt-1][0]= dist;

         distance[cnt-1][1]= j;

        }

     }

//---  

   if(cnt==0)return(false);

   if(dir>0)ArraySort(distance,WHOLE_ARRAY,0,MODE_DESCEND);

   else  ArraySort(distance);

//---  

   for(j=0;j<MathMin(cnt,5);j++)

     {

      //---  

      int test_pos;

      int pos=(int)distance[j][1];

      double test_a,test_b;

      double limit_high,limit_low;

      //---  

      if(dir==1)

        {

         limit_high=slope_price+slope_dev*InpDeviations;

         limit_low=slope_price-slope_dev*2;

        }

      else

        {

         limit_high=slope_price+slope_dev*2;

         limit_low=slope_price-slope_dev*InpDeviations;

        }

      //---  

      if(angle_line(test_pos,test_a,test_b,points,points[pos].pos,points[pos].point,last_pos,limit_high,limit_low,dir))

        {

         from_pos=test_pos;

         a=test_a;

         b=test_b;

         return(true);

        }

     }

   return(false);

  }

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

//| Delete all objects with given prefix                             |

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

void cleaningObj(string Prefix)

  {

   int L = StringLen(Prefix);

   int i = 0;

   while(i<ObjectsTotal())

     {

      string ObjName=ObjectName(i);

      if(StringSubstr(ObjName,0,L)!=Prefix)

        {

         i++;

         continue;

        }

      ObjectDelete(ObjName);

     }

  }

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

//|                                                                  |

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

bool calc_score(double  &score,const Point_Type  &points[],int test_pos,double test_price,double mean)

  {

   int  p_sz=ArraySize(points);

   if(p_sz < 5) return (false);

   int maxcnt=0;

   double angles[][2];

   int cnt=calc_angles(angles,points,p_sz,test_pos,test_price);

   if(cnt<4)return (false);



   double sum=0.0;

   for(int j=0; j<cnt; j++)

     {

      sum+=MathPow(angles[j][0]-mean,2);

     }

//---

   score=MathSqrt(sum/cnt);

//---

   return (true);

  }

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

//| atr_filter                                                       |

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

bool atr_filter(int sig,int fast,int slow,int pos)

  {

   double atr1sig=iCustom(Symbol(),PERIOD_CURRENT,"ATR_3LWMA",sig,fast,slow,0,pos+1);

   double atr1fast=iCustom(Symbol(),PERIOD_CURRENT,"ATR_3LWMA",sig,fast,slow,1,pos+1);

   double atr0sig=iCustom(Symbol(),PERIOD_CURRENT,"ATR_3LWMA",sig,fast,slow,0,pos);

   double atr0fast=iCustom(Symbol(),PERIOD_CURRENT,"ATR_3LWMA",sig,fast,slow,1,pos);

   double atr0slow=iCustom(Symbol(),PERIOD_CURRENT,"ATR_3LWMA",sig,fast,slow,2,pos);

   if(atr0slow<atr0fast && atr0fast<atr0sig && atr1fast<atr0fast)

      return(true);

   else

      return(false);

  }

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