Any questions from newcomers on MQL4 and MQL5, help and discussion on algorithms and codes - page 1292

[Ivan Rodionov]

Hello.

I'm a newbie, so don't scold me too much. )

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

This article gives an example of an EA which should only place a buy order if there is a buy signal and no open long positions. Similarly in the case of sell - sell conditions and no open short positions.

During the first test, we soon realized that not only one position was opened, but several positions were. The question is why?

I read the Expert Advisor's code and tried to understand and find the reason, but everything seems ok.

[Tretyakov Rostyslav]

Ivan Rodionov:

Hello.

I'm a newbie, so don't scold me too much. )

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

This article gives an example of an EA which should only place a buy order if there is a buy signal and no open long positions. Similarly in the case of sell - sell conditions and no open short positions.

During the first test, we soon realized that not only one position was opened, but several positions were. The question is why?

I read the Expert Advisor's code and tried to understand it and find the reason.

Try to change

         if(Buy_opened)

it to

         if(Buy_opened==true)

The same for sell

[Alexey Viktorov]

MakarFX:

Try replacing

to

Similarly for sale

It won't help. Read the documentation more often.

[Александр]

Hi all, I cannot figure out how to "draw" a trend line parallel to a zigzag knee by CODE. In fact, I need a shift to the right of the ZigZag. Please advise! Thank you!

[Aleksei Stepanenko]

Александр:
"draw a trend line, into the future"

From two points on a line, you can find the price of an arbitrary third point on that line, also in the future (and vice versa).

//находит дату точки (координату 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);
         } 

Hello.
Please pay attention to"Chechako ".
Need to point out errors in the code, because in the tester, EA does not open orders...
The compiler does not show any errors or warnings, the same journal shows no errors...

[MrBrooklin]

Ivan Rodionov:

Hello.

I'm a newbie, so don't scold me too much. )

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

This article gives an example of an EA which should only place a buy order if there is a buy signal and no open long positions. Similarly in the case of sell - sell conditions and no open short positions.

During the first test, we soon realized that not only one position was opened, but several positions were. The question is why?

I have read the Expert Advisor's code and tried to understand it and find the reason.

I have tried to help. I am a newbie myself. Now, regarding your question. Several positions are opened because the check to open a position was performed and the check was forgotten to stop. The operator return returns control to the calling program (taken from the MQL5 Reference).

We must add return to the Expert Advisor code (highlighted in yellow):

//--- есть ли открытые позиции?
   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;
        }
     }

In addition, to prevent the compiler from generating warnings, one more condition should be added in the Buy and Sell position opening conditions to check OrderSend(mrequest,mresult). This condition is defined by the if operator and should look like this

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

One more thing should be taken into account. Sometimes, when moving from one trading day to another at 23:59:59, an opened position closes and then, at 00:00:00, a new position opens. This is so-called rollover close and rollover open, which depends on the particular forex dealer and its trading conditions. Search the forum, there was some information about it somewhere.

Regards, Vladimir.

[Игорь]

Hello. People need your help. I connected two zigzags with different parameters into one indicator (no errors or warnings) The problem is that the 2nd zigzag is drawn incorrectly.

Here is the code itself (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]

Игорь:

Hello all. People need your help. I combined two zigzags with different parameters into one indicator (no errors or warnings) The problem is that 2 zigzags are not drawn correctly.

Here is the code itself (MQL5)

It all works - just fix a few digits at the top

[Игорь]

SanAlex:

It's all working - just fix the numbers at the top.

Thanks for the help. One more thing, why is it that one zigzag is formed as usual (maximum, minimum) and the other is only formed at the maximum.