MQL4 ve MQL5 ile ilgili herhangi bir acemi sorusu, algoritmalar ve kodlar hakkında yardım ve tartışma - sayfa 1292

[Ivan Rodionov]

Merhaba.

Ben acemiyim, bu yüzden bana fazla yüklenme. )

https://www.mql5.com/en/articles/100

Bu makale, yalnızca bir satın alma sinyali olması ve açık uzun pozisyon olmaması durumunda satın alma siparişi vermesi gereken bir EA'nın bir örneğini sağlar. Benzer şekilde, bir satış durumunda - satış koşulları ve açık kısa pozisyonların olmaması.

İlk test sırasında, bir pozisyonun değil, birkaç pozisyonun açıldığı ortaya çıktı. Soru - neden?

Danışman kodunu okudum, nedenini anlamaya ve bulmaya çalıştım ama her şey yolunda görünüyor.

[Tretyakov Rostyslav]

Ivan Rodionov :

Merhaba.

Ben acemiyim, bu yüzden bana fazla yüklenme. )

https://www.mql5.com/en/articles/100

Bu makale, yalnızca bir satın alma sinyali olması ve açık uzun pozisyon olmaması durumunda satın alma siparişi vermesi gereken bir EA'nın bir örneğini sağlar. Benzer şekilde, bir satış durumunda - satış koşulları ve açık kısa pozisyonların olmaması.

İlk test sırasında, bir pozisyonun değil, birkaç pozisyonun açıldığı ortaya çıktı. Soru - neden?

Danışman kodunu okudum, nedenini anlamaya ve bulmaya çalıştım ama her şey yolunda görünüyor.

değiştirmeyi dene

         if (Buy_opened)

üzerinde

         if (Buy_opened== true )

Aynı satılık

[Alexey Viktorov]

MakarFX :

değiştirmeyi dene

üzerinde

Aynı satılık

yardım etmeyecek. Daha fazla belge okuyun.

[Александр]

Merhaba! KOD kullanarak ZigZag'ın dizine paralel bir "geleceğe trend çizgisi" nasıl "çizilir" çözemiyorum. Expert Advisor'da bu trend çizgisini geçen fiyatın kontrolü ile.Aslında buna ihtiyacımız var. ZigZag'ın sağına doğru bir kayma . Lütfen bana söyleyin! Teşekkürler!

[Aleksei Stepanenko]

Александр :
geleceğe bir trend "çizmek"

Düz bir çizgi üzerinde iki nokta ile, gelecekte de dahil olmak üzere (ve tersi) bu düz çizgide isteğe bağlı bir üçüncü noktanın fiyatını bulabilirsiniz.

 //находит дату точки (координату X) на прямой, на заданную цену (координата Y)
datetime GetPointTimeOnStraight( datetime eTime1, double ePrice1, datetime eTime2, double ePrice2, double ePrice3, string eSymbol, int eTimeFrame)
   {
   if (ePrice2-ePrice1== 0 ) return ( 0.0 );
   //индекс бара соответствующий заданному времени, возможно задавать будующее время
   int eIndex1=(eTime1> iTime (eSymbol,eTimeFrame, 0 ))?( int )(( iTime (eSymbol,eTimeFrame, 0 )-eTime1)/ PeriodSeconds (eTimeFrame)): iBarShift (eSymbol,eTimeFrame,eTime1);
   int eIndex2=(eTime2> iTime (eSymbol,eTimeFrame, 0 ))?( int )(( iTime (eSymbol,eTimeFrame, 0 )-eTime2)/ PeriodSeconds (eTimeFrame)): iBarShift (eSymbol,eTimeFrame,eTime2);
   int eIndex3=eIndex1+( int )((eIndex2-eIndex1)*(ePrice3-ePrice1)/(ePrice2-ePrice1));
   return ( iTime (eSymbol,eTimeFrame,eIndex3));
   }

//находит цену точки (координату Y) на прямой, на заданное время (координата X)
double GetPointPriceOnStraight( datetime eTime1, double ePrice1, datetime eTime2, double ePrice2, datetime eTime3, string eSymbol, int eTimeFrame)
   {
   //индекс бара соответствующий заданному времени, возможно задавать будующее время
   int eIndex1=(eTime1> iTime (eSymbol,eTimeFrame, 0 ))?( int )(( iTime (eSymbol,eTimeFrame, 0 )-eTime1)/ PeriodSeconds (eTimeFrame)): iBarShift (eSymbol,eTimeFrame,eTime1);
   int eIndex2=(eTime2> iTime (eSymbol,eTimeFrame, 0 ))?( int )(( iTime (eSymbol,eTimeFrame, 0 )-eTime2)/ PeriodSeconds (eTimeFrame)): iBarShift (eSymbol,eTimeFrame,eTime2);
   if (eIndex2-eIndex1== 0 ) return ( 0.0 );
   int eIndex3=(eTime3> iTime (eSymbol,eTimeFrame, 0 ))?( int )(( iTime (eSymbol,eTimeFrame, 0 )-eTime3)/ PeriodSeconds (eTimeFrame)): iBarShift (eSymbol,eTimeFrame,eTime3);
   return (ePrice1+(ePrice2-ePrice1)*(eIndex3-eIndex1)/(eIndex2-eIndex1));
   }

[IndependentMK]

extern double Lot= 0.1 ;            
extern int Slippage = 3 ;
extern int TakeProfit = 30 ;
extern int StopLoss   = 30 ;
extern int MA_Smoth_S = 60 ;
extern int MA_Smoth_B = 12 ;
extern int MA_Simpl_S = 3 ;
extern int MA_Simpl_B = 1 ;
int start()
         {
           //___________________

           double SL, TP;
           int MA_Simpl_S_Cl,       //
              MA_Simpl_S_Op,       //
              MA_Simpl_B_Cl,       //
              MA_Simpl_B_Op;       //
         
           //________________

           //------------

          SL= NormalizeDouble (Bid-StopLoss* Point , Digits );       // 
          TP= NormalizeDouble (Bid+TakeProfit* Point , Digits );     //
          SL = StopLoss;                        
          TP = TakeProfit;
           if ( _Digits == 5 || _Digits == 3 )
            {
             SL = SL* 10 ;
             TP = TP* 10 ;
             return ( 0 );
            }
            
           //_______________

          MA_Smoth_S = iMA ( NULL , 0 , 60 , 0 , MODE_SMMA , PRICE_CLOSE , 1 );
          MA_Smoth_B = iMA ( NULL , 0 , 12 , 0 , MODE_SMMA , PRICE_CLOSE , 1 );
          MA_Simpl_S = iMA ( NULL , 0 , 3 , 0 , MODE_SMA , PRICE_CLOSE , 1 );
          MA_Simpl_B = iMA ( NULL , 0 , 1 , 0 , MODE_SMA , PRICE_CLOSE , 1 );
          MA_Simpl_S_Cl = iMA ( NULL , 0 , 3 , 0 , MODE_SMA , PRICE_CLOSE , 1 );
          MA_Simpl_S_Op = iMA ( NULL , 0 , 3 , 0 , MODE_SMA , PRICE_CLOSE , 2 );
          MA_Simpl_B_Cl = iMA ( NULL , 0 , 1 , 0 , MODE_SMA , PRICE_CLOSE , 1 );
          MA_Simpl_B_Op = iMA ( NULL , 0 , 1 , 0 , MODE_SMA , PRICE_CLOSE , 2 );
          
           //______________________

           while (MA_Smoth_B > MA_Smoth_S)
               {
                 if (MA_Simpl_B_Op < MA_Simpl_S_Op && MA_Simpl_B_Cl > MA_Simpl_S_Cl)
                  {
                   bool check = OrderSend ( Symbol (),OP_BUY,Lot, NormalizeDouble (Ask, Digits ),Slippage,SL,TP, "Buy" , 0 , 0 , clrGreen );
                   return ( 0 );
                  }
               }
               
           //_____________________

           while (MA_Smoth_S > MA_Smoth_B)
               {
                 if (MA_Simpl_B_Op > MA_Simpl_S_Op && MA_Simpl_B_Cl < MA_Simpl_S_Cl)
                  {
                   check = OrderSend ( Symbol (),OP_SELL,Lot, NormalizeDouble (Ask, Digits ),Slippage,SL,TP, "Sell" , 0 , 0 , clrRed );
                   return ( 0 );
                  }   
               }     
           return ( 0 );
         } 

Merhaba.
Lütfen " Çako "ya dikkat edin.
Koddaki hataları belirtmek gerekir, çünkü test cihazında, EA siparişleri açmıyor...
Aynı zamanda, derleyici hata ve uyarı vermez, günlük benzer - hata yoktur ...

[MrBrooklin]

Ivan Rodionov :

Merhaba.

Ben acemiyim, bu yüzden bana fazla yüklenme. )

https://www.mql5.com/en/articles/100

Bu makale, yalnızca bir satın alma sinyali olması ve açık uzun pozisyon olmaması durumunda satın alma siparişi vermesi gereken bir EA'nın bir örneğini sağlar. Benzer şekilde, bir satış durumunda - satış koşulları ve açık kısa pozisyonların olmaması.

İlk test sırasında, bir pozisyonun değil, birkaç pozisyonun açıldığı ortaya çıktı. Soru - neden?

Danışman kodunu okudum, nedenini anlamaya ve bulmaya çalıştım ama her şey yolunda görünüyor.

Merhaba Ivan! Burada kimse yeni gelenleri azarlamıyor, aksine yardım etmeye çalışıyorlar. Ben kendim bir acemiyim. Şimdi, sorunuzla ilgili olarak. Bir pozisyon açmak için bir çek yapıldığı için birkaç pozisyon açıldı, ancak kontrolü durdurmayı unuttular. Return ifadesi , kontrolü çağıran programa döndürür (MQL5 Referansından alınır).

EA koduna geri dönüş eklemeniz gerekir (sarı renkle vurgulanmıştır):

 //--- есть ли открытые позиции?
   bool Buy_opened= false ;   // переменные, в которых будет храниться информация 
   bool Sell_opened= false ; // о наличии соответствующих открытых позиций

   if ( PositionSelect ( _Symbol )== true ) // есть открытая позиция
     {
       if ( PositionGetInteger ( POSITION_TYPE )== POSITION_TYPE_BUY )
        {
         Buy_opened= true ;   //это длинная позиция
         return ;
        }
       else if ( PositionGetInteger ( POSITION_TYPE )== POSITION_TYPE_SELL )
        {
         Sell_opened= true ; // это короткая позиция
         return ;
        }
     }

Ayrıca derleyicinin uyarı vermemesi için Al ve Sat pozisyonları açma koşullarında OrderSend(mrequest,mresult) kontrol etmek için bir koşul daha eklenmelidir. Bu koşul, if ifadesi tarafından belirlenir ve şöyle görünür:

 //--- отсылаем ордер
if ( OrderSend (mrequest,mresult))

Ve bir şeyin daha dikkate alınması gerekiyor. 23:59:59'da bir işlem gününden diğerine geçerken, daha önce açılan pozisyon kapatılır ve 00:00:00'da hemen yeni bir pozisyon açılır. Bu, belirli forex satıcısına ve ticaret koşullarına bağlı olan, rollover kapanışı ve rollover açılışıdır. Forumda biraz araştırın bir yerlerde bununla ilgili bilgiler var.

Saygılarımla, Vladimir.

[Игорь]

Merhaba. İnsanların yardımınıza ihtiyacı var. Farklı parametrelere sahip iki zikzağı tek bir göstergeye bağladım (hata veya uyarı yok) Sorun şu ki 2. zikzak yanlış çizilmiş.

İşte kodun kendisi (MQL5)

 //+------------------------------------------------------------------+
//|                                                            6.mq5 |
//|                        Copyright 2020, MetaQuotes Software Corp. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "2009-2017, MetaQuotes Software Corp."
#property link        "http://www.mql5.com"
#property version    "1.00"
#property indicator_chart_window
#property indicator_buffers 6
#property indicator_plots    2
//---- plot ZigZag 1
#property indicator_label1    "ZigZag1"
#property indicator_type1    DRAW_SECTION
#property indicator_color1    clrRed
#property indicator_style1    STYLE_SOLID
#property indicator_width1    1
//---- plot ZigZag 2
#property indicator_label3    "ZigZag2"
#property indicator_type3    DRAW_SECTION
#property indicator_color3    clrBlueViolet
#property indicator_style3    STYLE_SOLID
#property indicator_width3    1
//--- input parameters ZigZag 1
input int       InpDepth    = 26 ;
input int       InpDeviation= 12 ;
input int       InpBackstep = 9 ;
//--- input parameters ZigZag 2
input int       Inp_Depth    = 12 ;
input int       Inp_Deviation= 5 ;
input int       Inp_Backstep = 3 ;
//--- indicator buffers ZigZag 1
double          ZigZagBuffer[];       //
double          HighMapBuffer[];     //
double          LowMapBuffer[];       //
int             ExtRecalc= 3 ;         //
//--- indicator buffers ZigZag 2
double          ZigZag_Buffer[];       // main buffer
double          HighMap_Buffer[];     // ZigZag high extremes (peaks)
double          LowMap_Buffer[];       // ZigZag low extremes (bottoms)
int             Ext_Recalc= 3 ;         // number of last extremes for recalculation
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit ()
  {
//--- indicator buffers mapping
   SetIndexBuffer ( 0 ,ZigZagBuffer, INDICATOR_DATA );
   SetIndexBuffer ( 1 ,HighMapBuffer, INDICATOR_CALCULATIONS );
   SetIndexBuffer ( 2 ,LowMapBuffer, INDICATOR_CALCULATIONS );
//
   SetIndexBuffer ( 3 ,ZigZag_Buffer, INDICATOR_DATA );
   SetIndexBuffer ( 4 ,HighMap_Buffer, INDICATOR_CALCULATIONS );
   SetIndexBuffer ( 5 ,LowMap_Buffer, INDICATOR_CALCULATIONS );

//--- set short name and digits
   PlotIndexSetString ( 0 , PLOT_LABEL , "ZigZag(" +( string )InpDepth+ "," +( string )InpDeviation+ "," +( string )InpBackstep+ ")" );
   PlotIndexSetString ( 3 , PLOT_LABEL , "ZigZag(" +( string )Inp_Depth+ "," +( string )Inp_Deviation+ "," +( string )Inp_Backstep+ ")" );

   IndicatorSetInteger ( INDICATOR_DIGITS , _Digits );

//--- set an empty value
   PlotIndexSetDouble ( 0 , PLOT_EMPTY_VALUE , 0.0 );
   PlotIndexSetDouble ( 3 , PLOT_EMPTY_VALUE , 0.0 );

//---
   return ( 0 );
  }
//+------------------------------------------------------------------+
//|  Search for the index of the highest bar                         |
//+------------------------------------------------------------------+
int Highest( const double &array[], int depth, int start)
  {
//--- validation of the start index
   if (start< 0 )
     {
       Print ( "Invalid parameter in the function Highest, start =" ,start);
       return 0 ;
     }
   int size= ArraySize (array);
//--- reduce depth to the available data if needed
   if (start-depth< 0 )
      depth=start;
   double max=array[start];
//--- start searching
   int index=start;
   for ( int i=start; i>start-depth; i--)
     {
       if (array[i]>max)
        {
         index=i;
         max=array[i];
        }
     }
//--- return index of the highest bar
   return (index);
  }
//+------------------------------------------------------------------+
//|  Search for the index of the lowest bar                          |
//+------------------------------------------------------------------+
int Lowest( const double &array[], int depth, int start)
  {
//--- validation of the start index
   if (start< 0 )
     {
       Print ( "Invalid parameter in the function iLowest, start =" ,start);
       return 0 ;
     }
   int size= ArraySize (array);
//--- reduce depth to the available data if needed
   if (start-depth< 0 )
      depth=start;
   double min=array[start];
//--- start searching
   int index=start;
   for ( int i=start; i>start-depth; i--)
     {
       if (array[i]<min)
        {
         index=i;
         min=array[i];
        }
     }
//--- return index of the lowest bar
   return (index);
  }
//--- auxiliary enumeration
enum EnSearchMode
  {
   Peak= 1 ,     // searching for the next ZigZag peak
   Bottom=- 1    // searching for the next ZigZag bottom
  };
//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int zig( 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= 0 ;
   int limit= 0 ,extreme_counter= 0 ,extreme_search= 0 ;
   int shift= 0 ,back= 0 ,last_high_pos= 0 ,last_low_pos= 0 ;
   double val= 0 ,res= 0 ;
   double curlow= 0 ,curhigh= 0 ,last_high= 0 ,last_low= 0 ;
//--- initializing
   if (prev_calculated== 0 )
     {
       ArrayInitialize (ZigZag_Buffer, 0.0 );
       ArrayInitialize (HighMap_Buffer, 0.0 );
       ArrayInitialize (LowMap_Buffer, 0.0 );
     }
//---
   if (rates_total< 100 )
       //return(0);
       //--- set start position for calculations
       if (prev_calculated== 0 )
         limit=Inp_Depth;

//--- ZigZag was already calculated before
   if (prev_calculated> 0 )
     {
      i=rates_total- 1 ;
       //--- searching for the third extremum from the last uncompleted bar
       while (extreme_counter<ExtRecalc && i>rates_total- 100 )
        {
         res=ZigZag_Buffer[i];
         if (res!= 0 )
            extreme_counter++;
         i--;
        }
      i++;
      limit=i;

       //--- what type of exremum we search for
       if (LowMap_Buffer[i]!= 0 )
        {
         curlow=LowMap_Buffer[i];
         extreme_search=Peak;
        }
       else
        {
         curhigh=HighMap_Buffer[i];
         extreme_search=Bottom;
        }
       //--- clear indicator values
       for (i=limit+ 1 ; i<rates_total && ! IsStopped (); i++)
        {
         ZigZag_Buffer[i] = 0.0 ;
         LowMap_Buffer[i] = 0.0 ;
         HighMap_Buffer[i]= 0.0 ;
        }
     }

//--- searching for high and low extremes
   for (shift=limit; shift<rates_total && ! IsStopped (); shift++)
     {
       //--- low
      val=low[Lowest(low,Inp_Depth,shift)];
       if (val==last_low)
         val= 0.0 ;
       else
        {
         last_low=val;
         if ((low[shift]-val)>Inp_Deviation* _Point )
            val= 0.0 ;
         else
           {
             for (back= 1 ; back<=Inp_Backstep; back++)
              {
               res=LowMap_Buffer[shift-back];
               if ((res!= 0 ) && (res>val))
                  LowMap_Buffer[shift-back]= 0.0 ;
              }
           }
        }
       if (low[shift]==val)
         LowMap_Buffer[shift]=val;
       else
         LowMap_Buffer[shift]= 0.0 ;
       //--- high
      val=high[Highest(high,Inp_Depth,shift)];
       if (val==last_high)
         val= 0.0 ;
       else
        {
         last_high=val;
         if ((val-high[shift])>Inp_Deviation* _Point )
            val= 0.0 ;
         else
           {
             for (back= 1 ; back<=Inp_Backstep; back++)
              {
               res=HighMap_Buffer[shift-back];
               if ((res!= 0 ) && (res<val))
                  HighMap_Buffer[shift-back]= 0.0 ;
              }
           }
        }
       if (high[shift]==val)
         HighMap_Buffer[shift]=val;
       else
         HighMap_Buffer[shift]= 0.0 ;
     }

//--- set last values
   if (extreme_search== 0 ) // undefined values
     {
      last_low= 0 ;
      last_high= 0 ;
     }
   else
     {
      last_low=curlow;
      last_high=curhigh;
     }

//--- final selection of extreme points for ZigZag
   for (shift=limit; shift<rates_total && ! IsStopped (); shift++)
     {
      res= 0.0 ;
       switch (extreme_search)
        {
         case 0 : // search for an extremum
             if (last_low== 0 && last_high== 0 )
              {
               if (HighMap_Buffer[shift]!= 0 )
                 {
                  last_high=high[shift];
                  last_high_pos=shift;
                  extreme_search=Bottom;
                  ZigZag_Buffer[shift]=last_high;
                  res= 1 ;
                 }
               if (LowMap_Buffer[shift]!= 0 )
                 {
                  last_low=low[shift];
                  last_low_pos=shift;
                  extreme_search=Peak;
                  ZigZag_Buffer[shift]=last_low;
                  res= 1 ;
                 }
              }
             break ;
         case Peak: // search for peak
             if (LowMap_Buffer[shift]!= 0.0 && LowMap_Buffer[shift]<last_low && HighMap_Buffer[shift]== 0.0 )
              {
               ZigZag_Buffer[last_low_pos]= 0.0 ;
               last_low_pos=shift;
               last_low=LowMap_Buffer[shift];
               ZigZag_Buffer[shift]=last_low;
               res= 1 ;
              }
             if (HighMap_Buffer[shift]!= 0.0 && LowMap_Buffer[shift]== 0.0 )
              {
               last_high=HighMap_Buffer[shift];
               last_high_pos=shift;
               ZigZag_Buffer[shift]=last_high;
               extreme_search=Bottom;
               res= 1 ;
              }
             break ;
         case Bottom: // search for bottom
             if (HighMap_Buffer[shift]!= 0.0 && HighMap_Buffer[shift]>last_high && LowMap_Buffer[shift]== 0.0 )
              {
               ZigZag_Buffer[last_high_pos]= 0.0 ;
               last_high_pos=shift;
               last_high=HighMap_Buffer[shift];
               ZigZag_Buffer[shift]=last_high;
              }
             if (LowMap_Buffer[shift]!= 0.0 && HighMap_Buffer[shift]== 0.0 )
              {
               last_low=LowMap_Buffer[shift];
               last_low_pos=shift;
               ZigZag_Buffer[shift]=last_low;
               extreme_search=Peak;
              }
             break ;
         default :
             return (rates_total);
        }
     }

//--- return value of prev_calculated for next call
   return (rates_total);
  }
//+------------------------------------------------------------------+
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= 0 ;
   int limit= 0 ,extreme_counter= 0 ,extreme_search= 0 ;
   int shift= 0 ,back= 0 ,last_high_pos= 0 ,last_low_pos= 0 ;
   double val= 0 ,res= 0 ;
   double curlow= 0 ,curhigh= 0 ,last_high= 0 ,last_low= 0 ;
//--- initializing
   if (prev_calculated== 0 )
     {
       ArrayInitialize (ZigZagBuffer, 0.0 );
       ArrayInitialize (HighMapBuffer, 0.0 );
       ArrayInitialize (LowMapBuffer, 0.0 );
     }
//---
   if (rates_total< 100 )
       return ( 0 );
//--- set start position for calculations
   if (prev_calculated== 0 )
      limit=InpDepth;

//--- ZigZag was already calculated before
   if (prev_calculated> 0 )
     {
      i=rates_total- 1 ;
       //--- searching for the third extremum from the last uncompleted bar
       while (extreme_counter<ExtRecalc && i>rates_total- 100 )
        {
         res=ZigZagBuffer[i];
         if (res!= 0 )
            extreme_counter++;
         i--;
        }
      i++;
      limit=i;

       //--- what type of exremum we search for
       if (LowMapBuffer[i]!= 0 )
        {
         curlow=LowMapBuffer[i];
         extreme_search=Peak;
        }
       else
        {
         curhigh=HighMapBuffer[i];
         extreme_search=Bottom;
        }
       //--- clear indicator values
       for (i=limit+ 1 ; i<rates_total && ! IsStopped (); i++)
        {
         ZigZagBuffer[i] = 0.0 ;
         LowMapBuffer[i] = 0.0 ;
         HighMapBuffer[i]= 0.0 ;
        }
     }

//--- searching for high and low extremes
   for (shift=limit; shift<rates_total && ! IsStopped (); shift++)
     {
       //--- low
      val=low[Lowest(low,InpDepth,shift)];
       if (val==last_low)
         val= 0.0 ;
       else
        {
         last_low=val;
         if ((low[shift]-val)>InpDeviation* _Point )
            val= 0.0 ;
         else
           {
             for (back= 1 ; back<=InpBackstep; back++)
              {
               res=LowMapBuffer[shift-back];
               if ((res!= 0 ) && (res>val))
                  LowMapBuffer[shift-back]= 0.0 ;
              }
           }
        }
       if (low[shift]==val)
         LowMapBuffer[shift]=val;
       else
         LowMapBuffer[shift]= 0.0 ;
       //--- high
      val=high[Highest(high,InpDepth,shift)];
       if (val==last_high)
         val= 0.0 ;
       else
        {
         last_high=val;
         if ((val-high[shift])>InpDeviation* _Point )
            val= 0.0 ;
         else
           {
             for (back= 1 ; back<=InpBackstep; back++)
              {
               res=HighMapBuffer[shift-back];
               if ((res!= 0 ) && (res<val))
                  HighMapBuffer[shift-back]= 0.0 ;
              }
           }
        }
       if (high[shift]==val)
         HighMapBuffer[shift]=val;
       else
         HighMapBuffer[shift]= 0.0 ;
     }

//--- set last values
   if (extreme_search== 0 ) // undefined values
     {
      last_low= 0 ;
      last_high= 0 ;
     }
   else
     {
      last_low=curlow;
      last_high=curhigh;
     }

//--- final selection of extreme points for ZigZag
   for (shift=limit; shift<rates_total && ! IsStopped (); shift++)
     {
      res= 0.0 ;
       switch (extreme_search)
        {
         case 0 : // search for an extremum
             if (last_low== 0 && last_high== 0 )
              {
               if (HighMapBuffer[shift]!= 0 )
                 {
                  last_high=high[shift];
                  last_high_pos=shift;
                  extreme_search=Bottom;
                  ZigZagBuffer[shift]=last_high;
                  res= 1 ;
                 }
               if (LowMapBuffer[shift]!= 0 )
                 {
                  last_low=low[shift];
                  last_low_pos=shift;
                  extreme_search=Peak;
                  ZigZagBuffer[shift]=last_low;
                  res= 1 ;
                 }
              }
             break ;
         case Peak: // search for peak
             if (LowMapBuffer[shift]!= 0.0 && LowMapBuffer[shift]<last_low && HighMapBuffer[shift]== 0.0 )
              {
               ZigZagBuffer[last_low_pos]= 0.0 ;
               last_low_pos=shift;
               last_low=LowMapBuffer[shift];
               ZigZagBuffer[shift]=last_low;
               res= 1 ;
              }
             if (HighMapBuffer[shift]!= 0.0 && LowMapBuffer[shift]== 0.0 )
              {
               last_high=HighMapBuffer[shift];
               last_high_pos=shift;
               ZigZagBuffer[shift]=last_high;
               extreme_search=Bottom;
               res= 1 ;
              }
             break ;
         case Bottom: // search for bottom
             if (HighMapBuffer[shift]!= 0.0 && HighMapBuffer[shift]>last_high && LowMapBuffer[shift]== 0.0 )
              {
               ZigZagBuffer[last_high_pos]= 0.0 ;
               last_high_pos=shift;
               last_high=HighMapBuffer[shift];
               ZigZagBuffer[shift]=last_high;
              }
             if (LowMapBuffer[shift]!= 0.0 && HighMapBuffer[shift]== 0.0 )
              {
               last_low=LowMapBuffer[shift];
               last_low_pos=shift;
               ZigZagBuffer[shift]=last_low;
               extreme_search=Peak;
              }
             break ;
         default :
             return (rates_total);
        }
     }

//--- return value of prev_calculated for next call
   return (rates_total);
  }
//+------------------------------------------------------------------+

[SanAlex]

Игорь :

Merhaba. İnsanların yardımınıza ihtiyacı var. Farklı parametrelere sahip iki zikzağı tek bir göstergeye bağladım (hata veya uyarı yok) Sorun şu ki 2. zikzak yanlış çizilmiş.

İşte kodun kendisi (MQL5)

her şey sizin için çalışıyor - sayıları biraz üstte düzeltin

[Игорь]

SanAlex :

her şey sizin için çalışıyor - sayıların üzerinde biraz düzeltin

Yardım için teşekkürler. Bana bir şey daha söyle, neden bir zikzak her zamanki gibi (maksimum, minimum) oluşturuldu ve ikincisi sadece maksimumda oluşturuldu.