Wedges

#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 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;

double WedgeH_Buffer[];
double WedgeL_Buffer[];
double TopBuffer[];
double BtmBuffer[];
double HighBuffer[];
double LowBuffer[];
double TrendBuffer[];

double StdDevBuffer[];
double ScoreH_Buffer[];
double ScoreL_Buffer[];
double SlopeA_Buffer[];
double SlopeB_Buffer[];
double CalcWedgeH_Buffer[];
double CalcWedgeL_Buffer[];

struct Point_Type
  {
   int               pos;
   double            point;
  };

int OnInit()
  {
      // код доступен только после оплаты
   }

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;

   if(rates_total<=min_rates_total)
      return(0);

   ArraySetAsSeries(WedgeH_Buffer,false);
   ArraySetAsSeries(WedgeL_Buffer,false);
   ArraySetAsSeries(HighBuffer,false);
   ArraySetAsSeries(LowBuffer,false);
   ArraySetAsSeries(TrendBuffer,false);

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

   ArraySetAsSeries(high,false);
   ArraySetAsSeries(low,false);
   ArraySetAsSeries(close,false);
   ArraySetAsSeries(time,false);

   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;
        }
     }

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

      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];
     }

   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;
        }
     }

   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;

      double price[];
      ArrayResize(price,InpCalcPeriod);
      int sz=0;
      double sum=0.0;

      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;

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

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

      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;
           }
        }

      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;

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

      if(!cancel)
        {

         if(upcnt>0)
           {

            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;

               if(CalcWedgeH_Buffer[i-1]!=0 && 
                  (CalcWedgeH_Buffer[i-1]<HighBuffer[i-1]) && 
                  (CalcWedgeH_Buffer[i-1]>LowBuffer[i-1]))
                 {

                  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((ScoreH_Buffer[i-k]!=EMPTY_VALUE) && score>ScoreH_Buffer[i-k])
                          {
                           best_score=false;
                           break;
                          }
                       }
                    }
                 }
               if(b

Показано первые 50% кода (символов: 12544)