دانلود اندیکاتور الگو مثلث – Download Wedge indicator

دسامبر 6th, 2021 ام کیو ال و اتو تریدینگ اندیکاتور

5 / 3.7

3.7/5 - (3 امتیاز)

دانلود اندیکاتور Wedge برای متاتریدر 4

توضیحات دانــــلود دیدگاه ها

دانلود اندیکاتور Wedge برای متاتریدر 4

دانلود اندیکاتور الگو مثلث – Download Wedge indicator

برچسب‌ها :

wedge الگو اندیکاتور کانال متاتریدر مثلث

مقالات مرتبط

نوامبر 3rd, 2022 بایگانی‌ها

5 / 5

High Volume Turns دانلود و معرفی اندیکاتور

معرفی و دانلود اندیکاتور High Volume Turns اندیکاتور High Volume Turns . عقب‌نشینی‌های بازار معمولاً به دنبال افزایش حجم و قیمت می‌شوند، بنابراین این افزایش‌ها می‌تواند اولین نشانه‌ای از فرسودگی و احتمال بازگشت باشد. معرفی اندیکاتور High Volume Turns چرخش های با حجم بالا شاخصی است که بازار را برای افزایش قیمت و حجم در […]

0 ادامه مقاله

آگوست 16th, 2023 بایگانی‌ها

5 / 0

Trend Power Bot دانلود و معرفی اکسپرت

معرفی اکسپرت کاربردی Trend Power Bot اکسپرت کاربردی Trend Power Bot ترند پاور بات ترکیبی منحصر به فرد بین الگوریتم تشخیص شکست بسیار کارآمد و مدیریت پول جبران خسارت بسیار موثر است. معرفی اکسپرت کاربردی Trend Power Bot مدیریت پول را می‌توان یک مارتینگل در نظر گرفت، اما با استفاده از ریسک کم، این استراتژی […]

0 ادامه مقاله

دسامبر 15th, 2022 بایگانی‌ها

5 / 5

STOCH and RSI Alert دانلود و معرفی اندیکاتور

معرفی و دانلود اندیکاتور کاربردی STOCH and RSI Alert اندیکاتور STOCH and RSI Alert هر زمان که خط اصلی تصادفی از خط سیگنال خود در منطقه اشباع خرید یا فروش بیش از حد عبور کرده باشد، یک فلش را بر روی نمودار می‌کشد. معرفی اندیکاتور STOCH and RSI Alert همچنین هر زمان که خط RSI […]

0 ادامه مقاله

آخرین مقالات

فوریه 27th, 2024 بایگانی‌ها

5 / 0

FT ADX Color Candles اندیکاتور MT5

معرفی و دانلود اندیکاتور کاربردی FT ADX Color Candles اندیکاتور کاربردی FT ADX Color Candles زمانی که نیاز دارید به طور همزمان به چندین مورد نگاه کنید، معامله می تواند بسیار خسته کننده باشد. اندیکاتور کاربردی FT ADX Color Candles قالب شمع ها، ساپورت ها، مقاومت ها، برنامه ها، اخبار و اندیکاتورها. هدف این ابزار […]

0 ادامه مقاله

می 19th, 2024 بایگانی‌ها

5 / 0

Bollinger Bands Filled اندیکاتور MT5

معرفی و دانلود اندیکاتور کاربردی Bollinger Bands Filled اندیکاتور کاربردی Bollinger Bands Filled نشانگر BB سبک مینیمالیستی کاملاً با یک رنگ پر شده است. اندیکاتور مناسب تازه کاران نوع این نشانگر: نشانگر تکنیکال اندیکاتور Bollinger Bands Filled شما خیلی با خطوط زیگزاگ پیچیده در اندیکاتور BB گیج شده اید، به خصوص زمانی که استراتژی شما […]

0 ادامه مقاله

می 19th, 2024 بایگانی‌ها

5 / 0

Key Price Levels MT5 اندیکاتور

معرفی و دانلود اندیکاتور کاربردی Key Price Levels MT5 Key Price Levels MT5 که بالا و پایین را برای سطوح قیمت قابل توجه برای دوره های گذشته نشان می دهد که به طور بالقوه می توانند به عنوان سطوح واکنش در نظر گرفته شوند. اندیکاتور کاربردی Key Price Levels MT5 این نشانگر سطوح قیمت زیر […]

0 ادامه مقاله

بخش دانلود

فایل های که پسوند آنها rar یا zip یا 7z هست را چگونه باز کنم؟
توسط نرم افزار Winrar فایل را از حالت فشرده خارج کنید و بعد برای اجرا و یا نصب اقدام کنید. دانلود WINRAR

فایل های با فرمت mq4 و mq5 را چگونه اجرا کنم ؟
جهت اجرای این نوع فایل ها برای نسخه mq4 باید متاتریدر 4 را روی سیستم خود و برای نسخه mq5 متاتریدر 5 را روی سیستم عامل خود نصب داشته باشید . جهت راهنمایی کلیک کنید

3.7/5 - (3 امتیاز)
رمز تمامی فایل ها :

دانلود اندیکاتور wedge

کد فایل

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

ویدیو های آموزشی فارسی

کتاب های آموزش فارکس

کتاب های آموزش بورس

مطالعه مقالات بازار بورس

مطالعه مقالات بازار فارکس

مطالعه مقالات ارز های دیجیتال

معرفی بروکر های بازار فارکس

استراتژی ها و ابزار های معاملاتی

فرهنگ تخصصی لغات

ویدیو های آموزشی انگلیسی

دانلود کتاب ها و مقالات انگلیسی

دانلود اکسپرت های معاملاتی

دانلود اندیکاتور های کاربردی

دانلود اسکریپت های کاربردی

دانلود اندیکاتور الگو مثلث – Download Wedge indicator

برچسب‌ها :

مقالات مرتبط

High Volume Turns دانلود و معرفی اندیکاتور

Trend Power Bot دانلود و معرفی اکسپرت

STOCH and RSI Alert دانلود و معرفی اندیکاتور

آخرین مقالات

FT ADX Color Candles اندیکاتور MT5

Bollinger Bands Filled اندیکاتور MT5

Key Price Levels MT5 اندیکاتور

بخش دانلود

کد فایل