Preguntas de los principiantes MQL5 MT5 MetaTrader 5 - página 421

 

Hice el cálculo sólo en el cambio de barra - mi método :) Si tiene alguna idea de optimización, le escucharé.

//+------------------------------------------------------------------+
//|                                                       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


double CC;
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//---

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

  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
   if (Close[1]-CC!=0)
   {
   CC=Close[1]; 
 
   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 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 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++)
         for(int i=4; i>=0; 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,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);

            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],"MaxSell=",TargetMassivOk[MaxSell],"MaxSell=",TargetMassivOk[MinSell]);
         Print("Среднее значение массива TargetMassivOk= ",sr_Target);
         Print("Среднее значение массива TargetMassivOk наиболее соответствует индексу= ",X);
         Print("Target= ",Target);
        }

     }
  }
}
//+------------------------------------------------------------------+

Автоматический трейдинг и тестирование торговых стратегий
Автоматический трейдинг и тестирование торговых стратегий
  • www.mql5.com
MQL5: язык торговых стратегий для MetaTrader 5, позволяет писать собственные торговые роботы, технические индикаторы, скрипты и библиотеки функций
 
-Aleks-:
Error - la enumeración funciona tal cual, si el valor del índice superara el tamaño del array, recibiría maldiciones, y no hay ninguna. Hay un valor con ceros, ¡y N puede ser distinto de cero! Resulta que la comprobación también ocurre, entonces resulta que el array no escribe datos.
No estaba adivinando, estaba señalando lo incorrecto del bucle propuesto. Piensa tú mismo desde-donde y hasta-donde con un tamaño de array igual a cinco necesitas hacer un bucle...
 
Artyom Trishkin:
No estaba adivinando, estaba señalando lo incorrecto del bucle propuesto. Piensa por ti mismo desde-donde y hasta-donde con un tamaño de array igual a cinco, necesitas hacer un bucle...
Tanto en mi variante como en la suya hay cinco valores, por favor explique la diferencia.
 
-Aleks-:
Tanto el mío como el tuyo tienen cinco valores, ¿cuál es la diferencia?

El tamaño de la matriz es cinco. Si se indexa el array de 4 a 0, incluyendo el cero, el bucle pasará por todos los valores del array. Si intentas indexar a partir de cinco, el array está fuera de rango. Si se indexa desde el 4 hasta el cero, sin incluir el cero, el bucle no recorrerá todo el array - la celda cero del array no se leerá.

Es decir, esto es correcto:

for(int i=4; i>=0; i--) {}

o

for(int i=0; i<5; i++) {}

El índice de la matriz (i)
4
3
2
1
0
Número de célula de la matriz
5
4
3
2
1
 
Artyom Trishkin:

El tamaño de la matriz es cinco. Si se indexa el array de 4 a 0, incluyendo el cero, el bucle pasará por todos los valores del array. Si intentas indexar a partir de cinco, el array está fuera de rango. Si se indexa desde el 4 hasta el cero, sin incluir el cero, el bucle no recorrerá todo el array - la celda cero del array no se leerá.

Es decir, esto es correcto:

for(int i=4; i>=0; i--) {}

o

for(int i=0; i<5; i++) {}

El índice de la matriz (i)
4
3
2
1
0
Número de célula de la matriz
5
4
3
2
1
Así que escribiste en el ejemplo lo que yo había escrito en el código. No entiendo cuál es la diferencia aquí...
 
Leanid Aladzyeu:

hacer un ataque de fuerza bruta desde el final ( ya que el ataque de fuerza bruta puede perder primero los datos si se cambia la lista)


 

Leanid Aladzyeu:


Leanid Aladzyeu:

Hacer la reconstrucción desde el final ( ya que la reconstrucción puede perder primero los datos si se cambia la lista)


Nunca deja de sorprenderme... ¿Por qué en lugar de aprender a usar los espejos retrovisores, la gente se aprende una sola norma de tráfico y gira la esquina sin mirar y se adelanta?

Por qué una vez que has leído que al cerrar varias órdenes de una lista de abiertas tienes que ir del índice más grande al más pequeño e incluso aconsejar a otros que vayan en esta dirección en todas partes...

 
Alexey Viktorov:

Nunca deja de sorprenderme... ¿Por qué en lugar de aprender a usar los espejos retrovisores, la gente se aprende un punto de las normas de tráfico y gira la esquina sin mirar y sigue de frente?

¿Por qué una vez leímos que si cerramos varias órdenes de una lista de abiertas, debemos mirar de un índice mayor a uno menor y aconsejar a los demás que usen siempre esta dirección?

Las posibilidades de búsqueda pueden ser las que quieras, a mí me molestó cuando cerraba del último al primero, debería haber sido al revés. Y lo hizo, sólo que hay matices, no sólo el contador para girar.
 
Alexey Viktorov:

Nunca deja de sorprenderme... ¿Por qué en lugar de aprender a usar los espejos retrovisores, la gente se aprende un punto de las normas de tráfico y gira la esquina sin mirar y sigue de frente?

¿Por qué una vez leí que si cierras varias órdenes de una lista de abiertas debes ir de un índice mayor a uno menor y aconsejas a los demás ir siempre en esta dirección?

Esto es cierto para todo lo que se borra en el bucle (órdenes, objetos gráficos, etc.), porque la eliminación llena las celdas anteriores del "array de objetos" con los "objetos" posteriores. En general, por supuesto, tenemos que considerar la situación. Por ejemplo, cuando se dibujan indicadores, es una tontería, por decirlo suavemente, empezar a dibujar desde el último elemento (rates_total-1).
 
Vladimir Zubov:
Pato, puedes hacerlo como quieras, yo me esforzaba por cerrar de último a primero, debería haberlo hecho al revés. Y lo hice, sólo que hay matices, no sólo el contador para girar.
Tapochun:
Esto es cierto para todo lo que se borra en el bucle (órdenes, objetos del gráfico, etc.) porque el borrado llena las celdas anteriores del "array de objetos" con "objetos" posteriores. En general, por supuesto, tenemos que considerar la situación. Por ejemplo, cuando se escriben indicadores, es una tontería, por decirlo suavemente, empezar a dibujar desde el último elemento (rates_total-1).

¿Intentas explicarme cómo hacerlo correctamente? ¿O quizás he entendido algo mal?

En realidad, si estoy conduciendo por una carretera desierta y no veo un solo coche o tractor alrededor, no giro.