Toute question des nouveaux arrivants sur MQL4 et MQL5, aide et discussion sur les algorithmes et les codes. - page 1292

[Ivan Rodionov]

Bonjour.

Je suis un débutant, alors ne me grondez pas trop. )

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

Cet article donne un exemple d'un EA qui ne doit placer un ordre d'achat que s'il existe un signal d'achat et qu'il n'y a pas de positions longues ouvertes. De même dans le cas d'une vente - conditions de vente et pas de positions courtes ouvertes.

Lors du premier test, nous nous sommes vite rendu compte que ce n'était pas un seul poste qui était ouvert, mais plusieurs. La question est de savoir pourquoi.

J'ai lu le code de l'EA et j'ai essayé de comprendre et de trouver la raison, mais tout semble correct.

[Tretyakov Rostyslav]

Ivan Rodionov:

Bonjour.

Je suis un débutant, alors ne me grondez pas trop. )

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

Cet article donne un exemple d'un EA qui ne doit placer un ordre d'achat que s'il existe un signal d'achat et qu'il n'y a pas de positions longues ouvertes. De même dans le cas d'une vente - conditions de vente et pas de positions courtes ouvertes.

Lors du premier test, nous nous sommes vite rendu compte que ce n'était pas un seul poste qui était ouvert, mais plusieurs. La question est de savoir pourquoi.

J'ai lu le code de l'Expert Advisor et j'ai essayé de le comprendre et de trouver la raison.

Essayez de changer

         if(Buy_opened)

il à

         if(Buy_opened==true)

De même pour la vente

[Alexey Viktorov]

MakarFX:

Essayez de remplacer

à

De même pour la vente

Ça ne servira à rien. Lisez plus souvent la documentation.

[Александр]

Bonjour à tous, Je n'arrive pas à trouver comment "dessiner" une ligne de tendance parallèle à un genou en zigzag par CODE. En fait, j'ai besoin d'un déplacement vers la droite du Zigzag. Veuillez me conseiller ! Merci !

[Aleksei Stepanenko]

Александр:
"dessiner une ligne de tendance, dans le futur"

À partir de deux points sur une ligne, vous pouvez trouver le prix d'un troisième point arbitraire sur cette ligne, également dans le futur (et 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);
         } 

Bonjour.
Veuillez prêter attention à"Chechako ".
Je dois signaler les erreurs dans le code, car dans le testeur, l'EA n'ouvre pas les ordres...
Le compilateur ne montre aucune erreur ou avertissement, le même journal ne montre aucune erreur...

[MrBrooklin]

Ivan Rodionov:

Bonjour.

Je suis un débutant, alors ne me grondez pas trop. )

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

Cet article donne un exemple d'un EA qui ne doit placer un ordre d'achat que s'il existe un signal d'achat et qu'il n'y a pas de positions longues ouvertes. De même dans le cas d'une vente - conditions de vente et pas de positions courtes ouvertes.

Lors du premier test, nous nous sommes vite rendu compte que ce n'était pas un seul poste qui était ouvert, mais plusieurs. La question est de savoir pourquoi.

J'ai lu le code de l'Expert Advisor et j'ai essayé de le comprendre et de trouver la raison.

J'ai essayé d'aider. Je suis moi-même un débutant. Maintenant, concernant votre question. Plusieurs positions sont ouvertes parce que le contrôle pour ouvrir une position a été effectué et que l'on a oublié d' arrêter le contrôle. L'opérateur return renvoie le contrôle au programme appelant (extrait de la référence MQL5).

Nous devons ajouter le retour au code de l'Expert Advisor (surligné en jaune) :

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

En outre, pour éviter que le compilateur ne génère des avertissements, il faut ajouter une condition supplémentaire dans les conditions d'ouverture des positions d'achat et de vente pour vérifier OrderSend(mrequest,mresult). Cette condition est définie par l'opérateur if et doit ressembler à ceci

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

Une autre chose doit être prise en compte. Parfois, lors du passage d'un jour de bourse à un autre, à 23:59:59, une position ouverte se ferme, puis, à 00:00:00, une nouvelle position s'ouvre. Il s'agit de ce que l'on appelle le rollover close et le rollover open, qui dépendent du cambiste particulier et de ses conditions de trading. Cherchez dans le forum, j'ai des informations à ce sujet quelque part.

Salutations, Vladimir.

[Игорь]

Bonjour. Les gens ont besoin de votre aide. J'ai connecté deux zigzags avec des paramètres différents dans un seul indicateur (pas d'erreurs ni d'avertissements) Le problème est que le 2ème zigzag est mal dessiné.

Voici le code lui-même (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]

Игорь:

Bonjour à tous. Les gens ont besoin de votre aide. J'ai combiné deux zigzags avec des paramètres différents en un seul indicateur (pas d'erreurs ou d'avertissements) Le problème est que 2 zigzags ne sont pas dessinés correctement.

Voici le code lui-même (MQL5)

Tout fonctionne - il faut juste corriger quelques chiffres en haut.

[Игорь]

SanAlex:

Tout fonctionne - arrangez un peu les chiffres du haut.

Merci pour votre aide. Une dernière chose, comment se fait-il qu'un zigzag se forme comme d'habitude (maximum, minimum) et que l'autre ne se forme qu'au maximum.