Questions des débutants MQL5 MT5 MetaTrader 5 - page 421

Nouveau commentaire
 

J'ai fait le calcul seulement au changement de barre - ma méthode :) Si vous avez des idées d'optimisation, je vous écoute !

//+------------------------------------------------------------------+
//|                                                       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-:
Faux - l'énumération fonctionne comme elle est, si la valeur de l'index dépassait la taille du tableau, elle serait maudite, et ce n'est pas le cas. Il existe une valeur avec des zéros, et N peut être non nul ! Il s'avère que la vérification se produit également, puis il s'avère que le tableau n'écrit pas de données.
Je ne faisais pas de suppositions, je soulignais l'inexactitude de la boucle proposée. Pensez vous de-où et à-où avec un tableau de taille égale à cinq vous devez faire une boucle...
 
Artyom Trishkin:
Je ne faisais pas de suppositions, je soulignais l'inexactitude de la boucle proposée. En vous imaginant de-où et à-où avec un tableau de taille égale à cinq, vous devez faire une boucle...
Dans ma variante comme dans la vôtre, il y a cinq valeurs, veuillez expliquer la différence.
 
-Aleks-:
Le mien et le vôtre ont tous deux cinq valeurs, quelle est la différence - veuillez expliquer.

La taille du tableau est de cinq. Si vous indexez le tableau de 4 à 0, y compris zéro, la boucle parcourra toutes les valeurs du tableau. Si vous essayez d'indexer à partir de cinq, le tableau est hors de portée. Si vous indexez de 4 à zéro, sans inclure zéro, la boucle ne parcourra pas tout le tableau - la cellule zéro du tableau ne sera pas lue.

C'est-à-dire que c'est correct :

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

ou

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

L'index du tableau (i)
4
3
2
1
0
Numéro de cellule du tableau
5
4
3
2
1
 
Artyom Trishkin:

La taille du tableau est de cinq. Si vous indexez le tableau de 4 à 0, y compris zéro, la boucle parcourra toutes les valeurs du tableau. Si vous essayez d'indexer à partir de cinq, le tableau est hors de portée. Si vous indexez de 4 à zéro, sans inclure zéro, la boucle ne parcourra pas tout le tableau - la cellule zéro du tableau ne sera pas lue.

C'est-à-dire que c'est correct :

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

ou

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

L'index du tableau (i)
4
3
2
1
0
Numéro de cellule du tableau
5
4
3
2
1
Vous avez donc écrit dans l'exemple ce que j'avais écrit dans le code. Je ne vois pas quelle est la différence ici...
 
Leanid Aladzyeu:

faire une attaque par force brute à partir de la fin ( car l'attaque par force brute peut d'abord perdre des données si la liste est modifiée)


 

Leanid Aladzyeu:


Leanid Aladzyeu:

Faites la reconstruction à partir de la fin (car la reconstruction peut perdre des données lors du changement de liste).


Cela ne cesse de m'étonner... Pourquoi, au lieu d'apprendre à utiliser les rétroviseurs, les gens se contentent d'apprendre un seul code de la route et prennent le virage sans regarder et foncent... ?

Je ne sais pas pourquoi j'ai lu une fois que lorsque je ferme plusieurs ordres de la liste des ordres ouverts, je dois passer d'un indice plus grand à un indice plus petit et je conseille même aux autres de toujours aller dans cette direction...

 
Alexey Viktorov:

Cela ne cesse de m'étonner... Pourquoi, au lieu d'apprendre à utiliser les rétroviseurs, les gens se contentent-ils d'apprendre un point du code de la route et prennent le virage sans regarder et vont tout droit ?

Pourquoi avoir lu une fois que si nous clôturons plusieurs ordres à partir d'une liste d'ordres ouverts, nous devons regarder d'un indice plus grand vers un indice plus petit et conseiller aux autres de toujours utiliser cette direction... ?

Les possibilités de recherche peuvent être ce que vous voulez, cela m'a dérangé lorsque je fermais du dernier au premier, cela aurait dû être vice versa. Et fait, seulement il ya des nuances, pas seulement le compteur de tourner.
 
Alexey Viktorov:

Cela ne cesse de m'étonner... Comment se fait-il qu'au lieu d'apprendre à utiliser les rétroviseurs, les gens se contentent d'apprendre un point du code de la route et tournent le coin sans regarder et vont tout droit ???

Pourquoi avoir lu une fois que si vous fermez plusieurs ordres d'une liste d'ordres ouverts, vous devez passer d'un indice plus grand à un indice plus petit et conseiller aux autres de toujours aller dans cette direction... ?

Cela est vrai pour tout ce qui est supprimé dans la boucle (commandes, objets graphiques, etc.), car la suppression remplit les cellules précédentes du "tableau d'objets" avec les "objets" suivants. En général, bien sûr, nous devons considérer la situation. Par exemple, lorsque vous écrivez les indicateurs, commencer à dessiner à partir du dernier élément (taux_total-1), pour ne pas dire plus, n'est pas judicieux.
 
Vladimir Zubov:
Duck, tu peux le faire de la manière que tu veux, je m'efforçais de fermer de la dernière à la première, j'aurais dû le faire dans l'autre sens. Et je l'ai fait, seulement il y a des nuances, pas seulement le compteur à tourner.
Tapochun:
C'est vrai pour tout ce qui est supprimé dans la boucle (ordres, objets du graphique, etc.) car la suppression remplit les cellules précédentes du "tableau d'objets" avec les "objets" suivants. En général, bien sûr, nous devons considérer la situation. Par exemple, lorsque vous écrivez des indicateurs, il est idiot, pour ne pas dire plus, de commencer à dessiner à partir du dernier élément (taux_total-1).

Essayez-vous de m'expliquer comment le faire correctement ? Ou peut-être ai-je mal compris quelque chose ?

En fait, si je conduis sur une route déserte et que je ne vois pas une seule voiture ou un seul tracteur aux alentours, je ne tourne pas.

1...414415416417418419420421422423424425426427428...1503
Nouveau commentaire