The code has issues with data loss and unexpected behavior in specific cases.

Aleksey Vyazmikin 2015.08.28 12:21 #4191

-Aleks-:

This is not convenient, especially with a large number of parameters...

It's an interesting solution via an array. Especially interesting how to find the closest variable value when averaging the total number of values.

This is the kind of code I got.

//+------------------------------------------------------------------+
//|                                                       Target.mq4 |
//|                      Copyright © 2008, MetaQuotes Software Corp. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2008, MetaQuotes Software Corp."
#property link      "https://www.mql5.com"
#property version   "1.00"
#property strict
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
{
//---

//---
return(INIT_SUCCEEDED);
}
//+------------------------------------------------------------------+
//| Expert deinitialization function |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
//---

}
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
{
   double MAT=NormalizeDouble(iMA(Symbol(),0,100,0,0,0,0),Digits);
   double S=11*Point;
   double Target;
   int Buy=1;
   int Sell=1;
   if(Open[0]-MAT>S || MAT-Open[0]<S) //Условие убытка - надо искать новый TP
     {
      if(Buy==1) //Если условно ордеров на покупку больше, чем ордеров на продажу (проверять лучше по объему позиции)
        {
         double TargetMassiv[5];        //Создаем массив
         double TargetMassivOk[5];      //Создаем массив
         int N=0;                       //Переменная для изменения размера массива
         int X=0;                       //Переменная для получение информации о номере индекса массива, наиболее соответствующему усредненному значению массива
         int NN=0;

         int Max=0;
         int Min=0;
         int MaxBuy=0;
         int MinBuy=0;
         double sr_Target=0;

         ArrayFree (TargetMassiv);         //Очищаем массив
         ArrayFree (TargetMassivOk);       //Очищаем массив
         ArrayResize(TargetMassiv,5,0);     //Восстанавливаем размер массива
         ArrayResize(TargetMassivOk,5,0);   //Восстанавливаем размер массива

         TargetMassiv[0]=NormalizeDouble (iMA(Symbol(),0,100,0,0,0,100),Digits);
         TargetMassiv[1]=NormalizeDouble (iMA(Symbol(),0,100,0,1,0,0),Digits);
         TargetMassiv[2]=NormalizeDouble (iMA(Symbol(),0,55,0,2,0,0),Digits);
         TargetMassiv[3]=NormalizeDouble (iMA(Symbol(),0,88,0,3,0,0),Digits);
         TargetMassiv[4]=NormalizeDouble (iMA(Symbol(),0,12,0,0,0,0),Digits);

         for(int i=0;i<5;i++) //Записываем значение в новый массив по условию
           {
            if(TargetMassiv[i]>MAT && TargetMassiv[i]!=0)
              {
               TargetMassivOk[i]=TargetMassiv[i];
               N++;

}

ArraySort(TargetMassivOk,WHOLE_ARRAY,0,MODE_DESCEND); //Сортировка массива
if(N!=0)

{
ArrayResize(TargetMassivOk,N,0);

            Max=ArrayMaximum(TargetMassiv,WHOLE_ARRAY,0);
            Min=ArrayMinimum(TargetMassiv,WHOLE_ARRAY,0);
            MaxBuy=ArrayMaximum(TargetMassivOk,WHOLE_ARRAY,0);
            MinBuy=ArrayMinimum(TargetMassivOk,WHOLE_ARRAY,0);
            sr_Target=NormalizeDouble(iMAOnArray(TargetMassivOk,0,N,0,0,0),Digits);

if(N==0)
{X=N;}

else

              {
               for(int i=0;i<N-1;i++)
                 {
                  if(sr_Target<=TargetMassivOk[i] && sr_Target>TargetMassivOk[i+1]) X=i; //Берем большее значение т.к. для ордеров на покупку
                 }
              }

Target=TargetMassivOk[X];
}

else

           {
            Max=0;
            Min=0;
            MaxBuy=0;
            MinBuy=0;
            sr_Target=0;
            Target=-1;
           }

         Print("Покупка");
         Print("Значения последних 5 элементов массива");
         for(int i=0;i<5;i++) printf("TargetMassiv[%d] = %G",i,TargetMassiv[i]);
         for(int i=0;i<N;i++) printf("TargetMassivOk[%d] = %G",i,TargetMassivOk[i]);

         Print("MAT= ",MAT);
         Print("Max= ",TargetMassiv[Max],"Min=",TargetMassiv[Min],"MaxBuy=",TargetMassivOk[MaxBuy],"MinBuy=",TargetMassivOk[MinBuy]);
         Print("Среднее значение массива TargetMassivOk= ",sr_Target);
         Print("Среднее значение массива TargetMassivOk наиболее соответствует индексу= ",X);
         Print("Target= ",Target);
        }

/////////////////////////////////////////////////////////////////////////////

      if(Sell==1) //Если условно ордеров на продажу больше, чем ордеров на продажу (проверять лучше по объему позиции)
        {
         double TargetMassiv[5];        //Создаем массив
         double TargetMassivOk[5];      //Создаем массив
         int N=0;                       //Переменная для изменения размера массива
         int X=0;                       //Переменная для получение информации о номере индекса массива, наиболее соответствующему усредненному значению массива
         int NN=0;

         int Max=0;
         int Min=0;
         int MaxSell=0;
         int MinSell=0;
         double sr_Target=0;

         ArrayFree (TargetMassiv);         //Очищаем массив
         ArrayFree (TargetMassivOk);       //Очищаем массив
         ArrayResize(TargetMassiv,5,0);     //Восстанавливаем размер массива
         ArrayResize(TargetMassivOk,5,0);   //Восстанавливаем размер массива

         TargetMassiv[0]=NormalizeDouble (iMA(Symbol(),0,100,0,0,0,100),Digits);
         TargetMassiv[1]=NormalizeDouble (iMA(Symbol(),0,100,0,1,0,0),Digits);
         TargetMassiv[2]=NormalizeDouble (iMA(Symbol(),0,55,0,2,0,0),Digits);
         TargetMassiv[3]=NormalizeDouble (iMA(Symbol(),0,88,0,3,0,0),Digits);
         TargetMassiv[4]=NormalizeDouble (iMA(Symbol(),0,12,0,0,0,0),Digits);

         for(int i=0;i<5;i++)
           {
            if(TargetMassiv[i]<MAT && TargetMassiv[i]!=0) //Записываем значение в новый массив по условию
              {
               TargetMassivOk[i]=TargetMassiv[i];
               N++;
              }

           }
         Print("N=",N);
         for(int i=0;i<N;i++) printf("До обработки TargetMassivOk[%d] = %G",i,TargetMassivOk[i]);
         ArraySort(TargetMassivOk,N,0,MODE_ASCEND);                //Сортировка массива
         if(N!=0)
           {
            ArrayResize(TargetMassivOk,N,0);
            ArraySort(TargetMassivOk,WHOLE_ARRAY,0,MODE_DESCEND);          //Дополнительная сортировка
            Max=ArrayMaximum(TargetMassiv,WHOLE_ARRAY,0);
            Min=ArrayMinimum(TargetMassiv,WHOLE_ARRAY,0);
            MaxSell=ArrayMaximum(TargetMassivOk,WHOLE_ARRAY,0);
            MinSell=ArrayMinimum(TargetMassivOk,WHOLE_ARRAY,0);
            sr_Target=NormalizeDouble(iMAOnArray(TargetMassivOk,0,N,0,0,0),Digits);

            for(int i=0;i<N-1;i++)
              {
               if(sr_Target<=TargetMassivOk[i] && sr_Target>TargetMassivOk[i+1]) X=i;
               //              if (X=!0) X=X-1;
              }
            Target=TargetMassivOk[X];
           }

else

           {
            Max=0;
            Min=0;
            MaxSell=0;
            MinSell=0;
            sr_Target=0;
            Target=-1;
           }

         Print("Продажа");
         Print("Значения последних 5 элементов массива");
         for(int i=0;i<5;i++) printf("TargetMassiv[%d] = %G",i,TargetMassiv[i]);
         for(int i=0;i<N;i++) printf("TargetMassivOk[%d] = %G",i,TargetMassivOk[i]);

         Print("MAT=",MAT);
         Print("Max=",TargetMassiv[Max],"Min=",TargetMassiv[Min],"MaxBuy=",TargetMassivOk[MaxSell],"MinBuy=",TargetMassivOk[MinSell]);
         Print("Среднее значение массива TargetMassivOk= ",sr_Target);
         Print("Среднее значение массива TargetMassivOk наиболее соответствует индексу= ",X);
         Print("Target= ",Target);
        }

}
}

//+------------------------------------------------------------------+

I have gained experience in working with arrays. Have I done everything correctly or have I made it more complicated? Maybe additional checks are needed?

Numerical series density Any questions from newcomers Any rookie question, so

Aleksey Vyazmikin 2015.08.28 14:37 #4192

I can't understand why data is lost from TargetMassivOk array if Sell==1, but when Buy==1 everything works?

for(int i=0;i<5;i++)
           {
            if(TargetMassiv[i]<MAT && TargetMassiv[i]!=0) //Записываем значение в новый массив по условию
              {
               TargetMassivOk[i]=TargetMassiv[i];
               N++;
              }

}

Scripts: Pending orders DOWN Loop in array, check Any questions from newcomers

Leanid Aladzyeu 2015.08.28 14:44 #4193

-Aleks-:

I can't understand why data is lost from TargetMassivOk array if Sell==1, but when Buy==1 everything works?

for(int i=0;i<5;i++)
           {
            if(TargetMassiv[i]<MAT && TargetMassiv[i]!=0) //Записываем значение в новый массив по условию
              {
               TargetMassivOk[i]=TargetMassiv[i];
               N++;
              }

}

Do the brute force attack from the end ( as in the brute force attack, data may be lost first if the list is modified)

for(int i=5; i>0; i--)

Artyom Trishkin 2015.08.28 14:53 #4194

Leanid Aladzyeu:

Do the brute force attack from the end ( as the brute force attack may first lose data if the list is modified)

for(int i=5; i>0; i--)

Not so. From 4 to >=0

Leanid Aladzyeu 2015.08.28 14:57 #4195

Artyom Trishkin:
Not like that. From 4 to >=0.

I thought his total number was odd too, so I put the same...

Got it one higher.

Aleksey Vyazmikin 2015.08.28 16:19 #4196

Leanid Aladzyeu:

Start the brute force attack at the end of the list (because the brute force attack may first lose data if the list is changed)

for(int i=5; i>0; i--)

Artyom Trishkin:
Not so. From 4 to >=0

Wrong - the enumeration works anyway, if the index value exceeds the array size, I'd get curses, but there aren't any. There is a value with zeros, and N may not equal zero! It turns out that the check also happens, then it turns out that the array doesn't write data.

returns the execution policy. [WARNING CLOSED!] Any newbie Any questions from newcomers

Aleksey Vyazmikin 2015.08.28 16:29 #4197

If the code is corrected like this

         TargetMassiv[0]=0.1;//NormalizeDouble (iMA(Symbol(),0,100,0,0,0,100),Digits);
         TargetMassiv[1]=0.2;//NormalizeDouble (iMA(Symbol(),0,100,0,1,0,0),Digits);
         TargetMassiv[2]=0.3;//NormalizeDouble (iMA(Symbol(),0,55,0,2,0,0),Digits);
         TargetMassiv[3]=2.4;//NormalizeDouble (iMA(Symbol(),0,88,0,3,0,0),Digits);
         TargetMassiv[4]=0.5;//NormalizeDouble (iMA(Symbol(),0,12,0,0,0,0),Digits);

then everything starts to work better, but zero still comes up sometimes!

close target directly Useful features from KimIV NormalizeDouble info

Aleksey Vyazmikin 2015.08.28 16:40 #4198

-Aleks-:

If the code is corrected in the following way

         TargetMassiv[0]=0.1;//NormalizeDouble (iMA(Symbol(),0,100,0,0,0,100),Digits);
         TargetMassiv[1]=0.2;//NormalizeDouble (iMA(Symbol(),0,100,0,1,0,0),Digits);
         TargetMassiv[2]=0.3;//NormalizeDouble (iMA(Symbol(),0,55,0,2,0,0),Digits);
         TargetMassiv[3]=2.4;//NormalizeDouble (iMA(Symbol(),0,88,0,3,0,0),Digits);
         TargetMassiv[4]=0.5;//NormalizeDouble (iMA(Symbol(),0,12,0,0,0,0),Digits);

Everything starts working better, but zero still comes sometimes!

I figured it out - when I was checking for adequate work with negative numbers I put reverse sorting of the array - I don't think it's relevant now.

         Print("N=",N);
         for(int i=0;i<N;i++) printf("До обработки TargetMassivOk[%d] = %G",i,TargetMassivOk[i]);
         ArraySort(TargetMassivOk,WHOLE_ARRAY,0,MODE_DESCEND);
        // ArraySort(TargetMassivOk,N,0,MODE_ASCEND);                //Сортировка массива
         if(N!=0)
           {
            ArrayResize(TargetMassivOk,N,0);
      //      ArraySort(TargetMassivOk,WHOLE_ARRAY,0,MODE_DESCEND);          //Дополнительная сортировка
            Max=ArrayMaximum(TargetMassiv,WHOLE_ARRAY,0);
            Min=ArrayMinimum(TargetMassiv,WHOLE_ARRAY,0);
            MaxSell=ArrayMaximum(TargetMassivOk,WHOLE_ARRAY,0);
            MinSell=ArrayMinimum(TargetMassivOk,WHOLE_ARRAY,0);
            sr_Target=NormalizeDouble(iMAOnArray(TargetMassivOk,0,N,0,0,0),Digits);

Any questions from newcomers Arraybsearch problem Need some help implementing

Aleksey Vyazmikin 2015.08.28 16:45 #4199

So for some unknown reason the indicator value is not copied to another buffer in this part of the code... mystique!

Aleksey Vyazmikin 2015.08.28 16:54 #4200

These are glitches - switched currency pairs and it seemed to work...

Questions from Beginners MQL5 MT5 MetaTrader 5 - page 420