Array out of range in Besoin d'aide

Dark Kchlyzov 2020.12.10 13:33 #41

Ihor Herasko:

Je ne sais même pas quoi ajouter... J'ai essentiellement donné les exemples de base. Voici le code. C'est pourquoi vous pouvez vous demander ce qui n'est pas clair.

Salutations ! Igor un exemple clair de comment obtenir une valeur . J'ai une ligne Low_D1_Level qui trouve la barre la plus proche dans l'historique dont la valeur sera inférieure à Low_D1_Level.

Si je travaille avec Structure sans tableau, j'obtiens le même résultat que dans le dernier code.

Donnez un exemple et, si vous le voulez bien, une description.

//+------------------------------------------------------------------+
//|                                                   Dark_Level.mq4 |
//|                        Copyright 2020, MetaQuotes Software Corp. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2020, MetaQuotes Software Corp."
#property link      "https://www.mql5.com"
#property version   "1.00"
#property strict

double Low_D1_Level;

struct BarData
{ 
   datetime time;         // время начала периода 
   double   open;         // цена открытия 
   double   high;         // наивысшая цена за период 
   double   low;          // наименьшая цена за период 
   double   close;        // цена закрытия 
   long     tick_volume;  // тиковый объем 
};
BarData Bar_data_D1[]; // обьявляем массив структуры в памяти 
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
{

 return(INIT_SUCCEEDED);
}
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
}
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
{
 Low_D1_Level   = iLow (_Symbol,PERIOD_D1,1);   // Возвращает значение минимальной цены бара  D1
 
// Bar_data_D1.low [i]; //Минимум свечи
// Bar_data_D1.low [i]= iLow (_Symbol,PERIOD_D1,1);
}

Открой новые возможности в MetaTrader 5 с сообществом и сервисами MQL5

www.mql5.com

One Click Close The script allows users to easily close positions if their profit/loss reaches or exceeds a value specified in pips. Please set slippage value first. Sometimes some positions do not close due to high volatility of the market. Please set larger slippage or restart the script. The free demo version is: ...

Suggestions pour améliorer le Questions des débutants MQL5 Soirée de fin de

[Supprimé] 2020.12.10 15:31 #42

Dark Kchlyzov:

Si Low_D1_Level est le niveau du jour précédent, alors Min_D_Level est recherché à partir deLow_D1_Level et il est égal à i=1 , ou est-ce que je me trompe ?

Désolé, je ne suis pas entré dans le code, j'ai demandé à être sûr que vous le faisiez consciemment.

Pouvez-vous me dire ce que vous voulez obtenir comme résultat. Des niveaux quotidiens ou quoi ? En regardant la première ligne, le fait de copier constamment un tableau dans ArrayCopyRates et de le parcourir ensuite en boucle n'est pas l'option la plus économique. Vous pourriez trouver une solution plus élégante.

Moyenne mobile Pourquoi les souscriptions ont-elles ouvrir des ordres avec

Dark Kchlyzov 2020.12.10 19:19 #43

Aleksei Stepanenko :

Je m'excuse, je n'ai pas approfondi le code, j'ai demandé de m'assurer que vous le faites consciemment.

Vous pouvez dire ce que vous voulez obtenir à la fin. Des niveaux quotidiens ou quoi? En regardant la première ligne, copier constamment le tableau dans ArrayCopyRates, puis le parcourir en boucle n'est pas l'option la plus économique. Vous pouvez trouver une solution plus élégante.

Je suis en bourse depuis plus de 5 ans, et en ce moment je vis complètement ( vous le faites consciemment ). Il y a un an, alors que la compréhension du trading en bourse était déjà plus ou moins renforcée,

Il a été décidé d'automatiser leurs connaissances dans le métier, envie de faire un bon bricolage.

C'est ainsi que MQL4 m'est consciemment venu, pour le moment l'EA a plus de 6000 lignes.

voici un exemple de code lors du calcul du lot il y a 1 an.

 // Примитивно но работало 
//+-------------------------------------------------------------------------+
//                       Функция расчета лота от прибыли                    +                                                   +
//+-------------------------------------------------------------------------+
// double Lots;    
//string lots;      
double FloatingLots()
  {
   double Lots1= 1200 ,Lots2= 2200 ,Lots3= 3200 ,Lots4= 4200 ,Lots5= 5200 ,Lots6= 6200 ,Lots7= 7200 ,Lots8= 8200 ,Lots9= 9200 ,Lots10= 10200 ;
   if (AccountBalance()<=Lots1){Lots= 0.1 ;}
   if (AccountBalance()>=Lots1 && AccountBalance()<=Lots2){Lots= 0.2 ;}
   if (AccountBalance()>=Lots2 && AccountBalance()<=Lots3){Lots= 0.3 ;}
   if (AccountBalance()>=Lots3 && AccountBalance()<=Lots4){Lots= 0.4 ;}
   if (AccountBalance()>=Lots4 && AccountBalance()<=Lots5){Lots= 0.5 ;}
   if (AccountBalance()>=Lots5 && AccountBalance()<=Lots6){Lots= 0.6 ;}
   if (AccountBalance()>=Lots6 && AccountBalance()<=Lots7){Lots= 0.7 ;}
   if (AccountBalance()>=Lots7 && AccountBalance()<=Lots8){Lots= 0.8 ;}
   if (AccountBalance()>=Lots8 && AccountBalance()<=Lots9){Lots= 0.9 ;}
   if (AccountBalance()>=Lots9){Lots= 1 ;}
   return (Lots);
  }

Et voici la même fonction après six mois

 //+-------------------------------------------------------------------------+
//                  Функция расчета лота от прибыли  V 1.1                                                        +
//+-------------------------------------------------------------------------+
//double Lots; // переменная для расчёта лота и вывода в кнопке   
double FloatingLots()
{
 double S_lots = 0.1 ;
 double i;
 for ( i = 1000 ; i <= AccountBalance();i+= 1000 )
    {
     if (i > (AccountBalance())- 1000 )
       {
        Lots = S_lots; break ;
       }
     else S_lots+= 0.1 ;
    }
 return (S_lots);

Voici la raison de la création de ce fil.

J'ai remarqué purement par hasard et visuellement lorsque j'ai commencé à exécuter le conseiller sur de longues périodes, si la deuxième condition était supprimée dans le cycle, une erreur se produisait (hors du tableau) et la deuxième condition masquait simplement l'erreur réelle.

Voici la fonction qui doit être déboguée, et il est temps d'étudier les structures, les classes.

Ne jugez pas strictement pour l'écriture de code - :)

 глоб. переменные
//+------------------------------------------------------------------+
//|                        Функция Level 
//+------------------------------------------------------------------+
double   Bar_data_D1 [][6]; // Копирует в массив данные баров указанного графика и возвращает количество скопированных баров D1
double   Bar_data_W1 [][6]; // Копирует в массив данные баров указанного графика и возвращает количество скопированных баров W1
double   Bar_data_MN [][6];
double   High_D1_Level;     // Возвращает значение максимальной цены бара D1
double   Low_D1_Level;      // Возвращает значение минимальной цены бара  D1
double   High_W1_Level;     // Возвращает значение максимальной цены бара W1
double   Low_W1_Level ;     // Возвращает значение минимальной цены бара  W1
double   High_MN1_Level;    // Возвращает значение максимальной цены бара MN1
double   Low_MN1_Level;     // Возвращает значение минимальной цены бара  MN1
double   Max_D_Level;       // ближайшей максимальный D уровень
double   Min_D_Level ;      // ближайшей минимальный  D уровень
double   Max_W_Level ;      // ближайшей максимальный W уровень
double   Min_W_Level ;      // ближайшей минимальный  W уровень
double   Max_MN_Level ;     // ближайшей максимальный MN уровень
double   Min_MN_Level ;     // ближайшей минимальный  MN уровень

int      Max_D_Num ;        // ближайшей максимальный день (номер бара)  
int      Min_D_Num ;        // ближайшей минимальный  день (номер бара)
int      Max_D_Volume ;     // ближайшей максимальный день (Объём)  
int      Min_D_Volume ;     // ближайшей минимальный  день (Объём)
datetime Max_D_Time;        // 
datetime Min_D_Time;        //
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
//|                        Функция Level v 1.0
//+------------------------------------------------------------------+
void Level()
{
 ArrayCopyRates(Bar_data_D1, _Symbol , PERIOD_D1 ); // Копирует в массив данные баров указанного графика и возвращает количество скопированных баров
 ArrayCopyRates(Bar_data_W1, _Symbol , PERIOD_W1 ); // Копирует в массив данные баров указанного графика и возвращает количество скопированных баров
 ArrayCopyRates(Bar_data_MN, _Symbol , PERIOD_MN1 ); // Копирует в массив данные баров указанного графика и возвращает количество скопированных баров
 
 High_D1_Level  = iHigh ( _Symbol , PERIOD_D1 , 1 );   // Возвращает значение максимальной цены бара D1
 Low_D1_Level   = iLow ( _Symbol , PERIOD_D1 , 1 );   // Возвращает значение минимальной цены бара  D1
 High_W1_Level  = iHigh ( _Symbol , PERIOD_W1 , 1 );   // Возвращает значение максимальной цены бара W1
 Low_W1_Level   = iLow ( _Symbol , PERIOD_W1 , 1 );   // Возвращает значение минимальной цены бара  W1 
 High_MN1_Level = iHigh ( _Symbol , PERIOD_MN1 , 1 );   // Возвращает значение максимальной цены бара MN1
 Low_MN1_Level  = iLow ( _Symbol , PERIOD_MN1 , 1 );   // Возвращает значение минимальной цены бара  MN1
 
//--- Max_D_Level
 for ( int i = 1 ; i< ArrayRange (Bar_data_D1, 0 ) ;i++)
    {
     //Print(" i = ",i);
     if (Bar_data_D1 [i][ 3 ]>= 0 )
       {
         if (Bar_data_D1 [i][ 3 ] > High_D1_Level)  
          {
           Max_D_Level = Bar_data_D1 [i][ 3 ]; break ;
          }
       }
    } 
    
//--- Min_D_Leve  
 for ( int i = 1 ; i< ArrayRange (Bar_data_D1, 0 ) ;i++)
    {
     Print ( "i = " ,i, " Bar_data_D1 [i][2] = " ,Bar_data_D1 [i][ 2 ]);
     if (Bar_data_D1 [i][ 2 ]>= 0 )
       {
         if ( Bar_data_D1 [i][ 2 ] < Low_D1_Level)
          {
           Min_D_Level = Bar_data_D1 [i][ 2 ]; break ;
          }
       }   
    } 
    
    
//--- Max_W_Level
 for ( int i = 1 ; i< ArrayRange (Bar_data_D1, 0 ) ;i++)
    {
     //Print(" i = ",i);
     if (Bar_data_D1 [i][ 3 ]>= 0 )
       {
         if (Bar_data_W1 [i][ 3 ] > High_W1_Level)    
          {
           Max_W_Level = Bar_data_W1 [i][ 3 ]; break ;
          }
       }  
    } 
    
//--- Min_W_Level 
 for ( int i = 1 ; i< ArrayRange (Bar_data_D1, 0 ) ;i++)
    {
     // Print(" i = ",i);
     if (Bar_data_D1 [i][ 2 ]>= 0 )
       {
         if (Bar_data_W1 [i][ 2 ] < Low_W1_Level)
          {
           Min_W_Level = Bar_data_W1 [i][ 2 ]; break ;
          }
       }  
    } 

 //+-----------------------High_D1_Level-----------------------------+  
 if ( ObjectFind ( "High_D1" )!=High_D1_Level) 
   {
     ObjectDelete ( "High_D1" );
     if ( ObjectFind ( "High_D1" )!= 0 )
      {
       ObjectCreate ( "High_D1" , OBJ_HLINE , 0 , Time[ 0 ],High_D1_Level);
       ObjectSet( "High_D1" , OBJPROP_COLOR , clrMaroon );
       ObjectSet( "High_D1" , OBJPROP_WIDTH , 1 );
      }
   } 
 if ( ObjectFind ( "High_D1_label" )!=High_D1_Level)
   {
     ObjectDelete ( "High_D1_label" ); 
     if ( ObjectFind ( "High_D1_label" ) != 0 )
      {
       ObjectCreate ( "High_D1_label" , OBJ_TEXT , 0 , Time[ 13 ], High_D1_Level);
       ObjectSetText( "High_D1_label" , "High_D1: " + DoubleToStr(High_D1_Level, _Digits ), 8 , "Verdana" , Brown);
      }
   } 
 //+-------------------------Low_D1_Level----------------------------+ 
 if ( ObjectFind ( "Low_D1" )!=Low_D1_Level) 
   {
     ObjectDelete ( "Low_D1" );
     if ( ObjectFind ( "Low_D1" )!= 0 )
      {
       ObjectCreate ( "Low_D1" , OBJ_HLINE , 0 , Time[ 0 ],Low_D1_Level);
       ObjectSet( "Low_D1" , OBJPROP_COLOR , clrMaroon );
       ObjectSet( "Low_D1" , OBJPROP_WIDTH , 1 );
      }
   } 
   
 if ( ObjectFind ( "Low_D1_label" )!=Low_D1_Level)
   {
     ObjectDelete ( "Low_D1_label" ); 
     if ( ObjectFind ( "Low_D1_label" ) != 0 )
      {
       ObjectCreate ( "Low_D1_label" , OBJ_TEXT , 0 , Time[ 13 ], Low_D1_Level);
       ObjectSetText( "Low_D1_label" , "Low_D1: " + DoubleToStr(Low_D1_Level, _Digits ), 8 , "Verdana" , Brown);
      }
   } 
   
     //+-----------------------Max_D_Level-----------------------------+  
 if ( ObjectFind ( "Max_D" )!=Max_D_Level) 
   {
     ObjectDelete ( "Max_D" );
     if ( ObjectFind ( "Max_D" )!= 0 )
      {
       ObjectCreate ( "Max_D" , OBJ_HLINE , 0 , Time[ 0 ],Max_D_Level);
       ObjectSet( "Max_D" , OBJPROP_COLOR , clrMaroon );
       ObjectSet( "Max_D" , OBJPROP_WIDTH , 1 );
      }
   } 
 if ( ObjectFind ( "Max_D_label" )!=Max_D_Level)
   {
     ObjectDelete ( "Max_D_label" ); 
     if ( ObjectFind ( "Max_D_label" ) != 0 )
      {
       ObjectCreate ( "Max_D_label" , OBJ_TEXT , 0 , Time[ 30 ], Max_D_Level);
       ObjectSetText( "Max_D_label" , "Max_D: " + DoubleToStr(Max_D_Level, _Digits ), 8 , "Verdana" , Brown);
      }
   } 
 //+-------------------------Min_D_Level----------------------------+ 
 if ( ObjectFind ( "Min_D" )!= Min_D_Level) 
   {
     ObjectDelete ( "Min_D" );
     if ( ObjectFind ( "Min_D" )!= 0 )
      {
       ObjectCreate ( "Min_D" , OBJ_HLINE , 0 , Time[ 0 ],Min_D_Level);
       ObjectSet( "Min_D" , OBJPROP_COLOR , clrMaroon );
       ObjectSet( "Min_D" , OBJPROP_WIDTH , 1 );
      }
   } 
   
 if ( ObjectFind ( "Min_D_label" )!=Min_D_Level)
   {
     ObjectDelete ( "Min_D_label" ); 
     if ( ObjectFind ( "Min_D_label" ) != 0 )
      {
       ObjectCreate ( "Min_D_label" , OBJ_TEXT , 0 , Time[ 30 ], Min_D_Level);
       ObjectSetText( "Min_D_label" , "Min_D: " + DoubleToStr(Min_D_Level, _Digits ), 8 , "Verdana" , Brown);
      }
   }  
 //+-----------------------High_W1_Level-----------------------------+         
 if ( ObjectFind ( "High_W1" )!=High_W1_Level) 
   {
     ObjectDelete ( "High_W1" );
     if ( ObjectFind ( "High_W1" )!= 0 )
      {
       ObjectCreate ( "High_W1" , OBJ_HLINE , 0 , Time[ 0 ],High_W1_Level);
       ObjectSet( "High_W1" , OBJPROP_COLOR , clrMaroon );
       ObjectSet( "High_W1" , OBJPROP_WIDTH , 1 );
      }
   } 
 if ( ObjectFind ( "High_W1_label" )!=High_W1_Level)
   {
     ObjectDelete ( "High_W1_label" ); 
     if ( ObjectFind ( "High_W1_label" ) != 0 )
      {
       ObjectCreate ( "High_W1_label" , OBJ_TEXT , 0 , Time[ 47 ], High_W1_Level);
       ObjectSetText( "High_W1_label" , "High_W1: " + DoubleToStr(High_W1_Level, _Digits ), 8 , "Verdana" , Brown);
      }
   } 
 //+-------------------------Low_W1_Level----------------------------+       
 if ( ObjectFind ( "Low_W1" )!=Low_W1_Level) 
   {
     ObjectDelete ( "Low_W1" );
     if ( ObjectFind ( "Low_W1" )!= 0 )
      {
       ObjectCreate ( "Low_W1" , OBJ_HLINE , 0 , Time[ 0 ],Low_W1_Level);
       ObjectSet( "Low_W1" , OBJPROP_COLOR , clrMaroon );
       ObjectSet( "Low_W1" , OBJPROP_WIDTH , 1 );
      }
   } 
   
 if ( ObjectFind ( "Low_W1_label" )!=Low_W1_Level)
   {
     ObjectDelete ( "Low_W1_label" ); 
     if ( ObjectFind ( "Low_W1_label" ) != 0 )
      {
       ObjectCreate ( "Low_W1_label" , OBJ_TEXT , 0 , Time[ 47 ], Low_W1_Level);
       ObjectSetText( "Low_W1_label" , "Low_W1: " + DoubleToStr(Low_W1_Level, _Digits ), 8 , "Verdana" , Brown);
      }
   }  
   
   
 //+-----------------------Max_W_Level-----------------------------+         
 if ( ObjectFind ( "Max_W" )!=Max_W_Level) 
   {
     ObjectDelete ( "Max_W" );
     if ( ObjectFind ( "Max_W" )!= 0 )
      {
       ObjectCreate ( "Max_W" , OBJ_HLINE , 0 , Time[ 0 ],Max_W_Level);
       ObjectSet( "Max_W" , OBJPROP_COLOR , clrMaroon );
       ObjectSet( "Max_W" , OBJPROP_WIDTH , 1 );
      }
   } 
 if ( ObjectFind ( "Max_W_label" )!= Max_W_Level)
   {
     ObjectDelete ( "Max_W_label" ); 
     if ( ObjectFind ( "Max_W_label" ) != 0 )
      {
       ObjectCreate ( "Max_W_label" , OBJ_TEXT , 0 , Time[ 64 ], Max_W_Level);
       ObjectSetText( "Max_W_label" , "Max_W: " + DoubleToStr(Max_W_Level, _Digits ), 8 , "Verdana" , Brown);
      }
   } 
 //+-------------------------Min_W_Level----------------------------+       
 if ( ObjectFind ( "Min_W" )!=Min_W_Level) 
   {
     ObjectDelete ( "Min_W" );
     if ( ObjectFind ( "Min_W" )!= 0 )
      {
       ObjectCreate ( "Min_W" , OBJ_HLINE , 0 , Time[ 0 ],Min_W_Level);
       ObjectSet( "Min_W" , OBJPROP_COLOR , clrMaroon );
       ObjectSet( "Min_W" , OBJPROP_WIDTH , 1 );
      }
   } 
   
 if ( ObjectFind ( "Min_W_label" )!= Min_W_Level)
   {
     ObjectDelete ( "Min_W_label" ); 
     if ( ObjectFind ( "Min_W_label" ) != 0 )
      {
       ObjectCreate ( "Min_W_label" , OBJ_TEXT , 0 , Time[ 64 ], Min_W_Level);
       ObjectSetText( "Min_W_label" , "Min_W: " + DoubleToStr(Min_W_Level, _Digits ), 8 , "Verdana" , Brown);
      }
   }
 //+-----------------------High_MN1_Level-----------------------------+         
 if ( ObjectFind ( "High_MN1" )!=High_MN1_Level) 
   {
     ObjectDelete ( "High_MN1" );
     if ( ObjectFind ( "High_MN1" )!= 0 )
      {
       ObjectCreate ( "High_MN1" , OBJ_HLINE , 0 , Time[ 0 ],High_MN1_Level);
       ObjectSet( "High_MN1" , OBJPROP_COLOR , clrMaroon );
       ObjectSet( "High_MN1" , OBJPROP_WIDTH , 1 );
      }
   } 
 if ( ObjectFind ( "High_MN1_label" )!=High_MN1_Level)
   {
     ObjectDelete ( "High_MN1_label" ); 
     if ( ObjectFind ( "High_MN1_label" ) != 0 )
      {
       ObjectCreate ( "High_MN1_label" , OBJ_TEXT , 0 , Time[ 81 ], High_MN1_Level);
       ObjectSetText( "High_MN1_label" , "High_MN1: " + DoubleToStr(High_MN1_Level, _Digits ), 8 , "Verdana" , Brown);
      }
   } 
 //+-------------------------Low_MN1_Level----------------------------+       
 if ( ObjectFind ( "Low_MN1" )!=Low_MN1_Level) 
   {
     ObjectDelete ( "Low_MN1" );
     if ( ObjectFind ( "Low_MN1" )!= 0 )
      {
       ObjectCreate ( "Low_MN1" , OBJ_HLINE , 0 , Time[ 0 ],Low_MN1_Level);
       ObjectSet( "Low_MN1" , OBJPROP_COLOR , clrMaroon );
       ObjectSet( "Low_MN1" , OBJPROP_WIDTH , 1 );
      }
   } 
   
 if ( ObjectFind ( "Low_MN1_label" )!=Low_MN1_Level)
   {
     ObjectDelete ( "Low_MN1_label" ); 
     if ( ObjectFind ( "Low_MN1_label" ) != 0 )
      {
       ObjectCreate ( "Low_MN1_label" , OBJ_TEXT , 0 , Time[ 81 ], Low_MN1_Level);
       ObjectSetText( "Low_MN1_label" , "Low_MN1: " + DoubleToStr(Low_MN1_Level, _Digits ), 8 , "Verdana" , Brown);
      }
   }       
}

Le côté légal du Questions des débutants MQL5 Différence entre trading manuel

[Supprimé] 2020.12.10 19:52 #44

Dark Kchlyzov:

Voici la fonction à déboguer.

OK, et peux-tu me dire avec quoi tu veux finir ?

Dark Kchlyzov 2020.12.10 20:01 #45

Aleksei Stepanenko:

Ok, peux-tu me dire avec quoi tu veux finir ?

Voici la version abrégée exécutée sur AUDUSD 2020

Pourquoi ne va-t-il pas plus loin dans le tableau ?

//+------------------------------------------------------------------+
//|                                                   Test_Level.mq4 |
//|                        Copyright 2020, MetaQuotes Software Corp. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2020, MetaQuotes Software Corp."
#property link      "https://www.mql5.com"
#property version   "1.00"
#property strict
double   Bar_data_D1 [][6]; // Копирует в массив данные баров указанного графика и возвращает количество скопированных баров D1
double   Low_D1_Level;      // Возвращает значение минимальной цены бара  D1
double   Min_D_Level ;      // ближайшей минимальный  D уровень
datetime  Time_Day;
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
   Level();
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {

   
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
  On_Timer();
  }
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
//|                        Функция Level 
//+------------------------------------------------------------------+
void Level()
{
 ArrayCopyRates(Bar_data_D1,_Symbol,PERIOD_D1); // Копирует в массив данные баров указанного графика и возвращает количество скопированных баров

 Low_D1_Level   = iLow (_Symbol,PERIOD_D1,1);   // Возвращает значение минимальной цены бара  D1
    
//--- Min_D_Leve  
 //for(int i = 1; i<ArrayRange(Bar_data_D1,0) ;i++)
 for(int i = 1; ;i++)
    {
     Print(" i = ",i," Bar_data_D1 [i][2] = ",Bar_data_D1 [i][2]);
     if(Bar_data_D1 [i][2]>=0)
       {
        if( Bar_data_D1 [i][2] < Low_D1_Level)
          {
           Min_D_Level = Bar_data_D1 [i][2];break;
          }
       }   
    } 

 //+-------------------------Low_D1_Level----------------------------+ 
 if(ObjectFind("Low_D1")!=Low_D1_Level) 
   {
    ObjectDelete("Low_D1");
    if(ObjectFind("Low_D1")!=0)
      {
       ObjectCreate("Low_D1",OBJ_HLINE, 0, Time[0],Low_D1_Level);
       ObjectSet("Low_D1", OBJPROP_COLOR, clrMaroon);
       ObjectSet("Low_D1", OBJPROP_WIDTH, 1);
      }
   } 
   
 if(ObjectFind("Low_D1_label")!=Low_D1_Level)
   {
    ObjectDelete("Low_D1_label"); 
    if(ObjectFind("Low_D1_label") != 0)
      {
       ObjectCreate("Low_D1_label", OBJ_TEXT, 0, Time[13], Low_D1_Level);
       ObjectSetText("Low_D1_label", "Low_D1: " + DoubleToStr(Low_D1_Level,_Digits), 8,"Verdana", Brown);
      }
   } 
   
 //+-------------------------Min_D_Level----------------------------+ 
 if(ObjectFind("Min_D")!= Min_D_Level) 
   {
    ObjectDelete("Min_D");
    if(ObjectFind("Min_D")!=0)
      {
       ObjectCreate("Min_D",OBJ_HLINE, 0, Time[0],Min_D_Level);
       ObjectSet("Min_D", OBJPROP_COLOR, clrMaroon);
       ObjectSet("Min_D", OBJPROP_WIDTH, 1);
      }
   } 
   
 if(ObjectFind("Min_D_label")!=Min_D_Level)
   {
    ObjectDelete("Min_D_label"); 
    if(ObjectFind("Min_D_label") != 0)
      {
       ObjectCreate("Min_D_label", OBJ_TEXT, 0, Time[30], Min_D_Level);
       ObjectSetText("Min_D_label", "Min_D: " + DoubleToStr(Min_D_Level,_Digits), 8,"Verdana", Brown);
      }
   }  
 
}
//+------------------------------------------------------------------+
//|        функция удаление всех объектов созданных советником
//+------------------------------------------------------------------+
void DestroyObject()
{
 int tot=ObjectsTotal();
 for( int i=tot; i>=0; i--)
    {
     
     if(ObjectName(i)=="Low_MN1"){ObjectDelete(0,"Low_MN1");Print("<< Объект Low_MN удалён >>");}
     if(ObjectName(i)=="Low_MN1_label"){ObjectDelete(0,"Low_MN1_label");Print("<< Объект Low_MN1_label удалён >>");}
     

     if(ObjectName(i)=="Min_D"){ObjectDelete(0,"Min_D");Print("<< Объект Min_D удалён >>");}
     if(ObjectName(i)=="Min_D_label"){ObjectDelete(0,"Min_D_label");Print("<< Объект Min_D_label удалён >>");}


   }
}
//+-------------------------------------------------------------------------+   
//                         функция Timer                    
//+-------------------------------------------------------------------------+
void On_Timer()
{

     
 if(Day()!= Time_Day)
   {
    Level();
    Time_Day = Day();
   }
}

[Supprimé] 2020.12.10 20:04 #46

Vous me demandez pourquoi cela ne fonctionne pas et j'essaie d'en saisir l'essentiel en mots, car il existe peut-être une meilleure solution à votre problème, ce que j'essaie de découvrir.

Expliquez ce que vous essayez d'obtenir.

Toute question des nouveaux Aide au codage profondeur de marché (DOM)

Vitaly Muzichenko 2020.12.10 20:07 #47

Aleksei Stepanenko:

Vous me demandez pourquoi cela ne fonctionne pas, et j'essaie d'en saisir l'essentiel en mots, car il existe peut-être une meilleure solution à votre problème, ce que j'essaie de découvrir.

Expliquez ce que vous voulez obtenir.

Jusqu'à présent, je vois ...

[Supprimé] 2020.12.10 20:12 #48

Vitaly Muzichenko:

Jusqu'à présent, je ne vois que ça.

Oui, c'est ainsi que fonctionne la perception humaine. Moi aussi, lorsque je suis vraiment passionné par une idée, je peux à peine entendre les arguments de l'autre personne. Oh, eh bien...

EURUSD - Tendances, prévisions EURUSD - Tendances, prévisions Pourcentage de profit pour

Dark Kchlyzov 2020.12.10 20:20 #49

Vitaly Muzichenko:

Jusqu'à présent, je ne vois que ça.

Il y a un niveauLow_D1_Level , alors nous devons obtenir la valeur du niveau suivant Min_D_Level, qui sera le niveau le plus bas suivant dans l'histoire et sera inférieur à Low_D1_Level.

Je ne sais pas comment expliquer davantage. Si vous exécutez le code dans le testeur avec la visualisation à mon avis tout est visible.

Et de manière générale, si vous venez sur le poste, ayez la gentillesse d'en lire au moins l'essentiel.

C'est tout à fait hors sujet :

C'est quoi le "problème XY" ?

C'est une erreur qui fait souvent perdre du temps à la fois à la personne qui demande de l'aide et à celle qui tente d'y répondre. On l'appelle aussi le "problème du marteau". En bref, les gens ont tendance à poser des questions sur leurs tentatives infructueuses de résoudre le problème, plutôt que sur le problème lui-même. Ça finit par donner quelque chose comme ça :

Une personne veut faire X.
Il ne sait pas comment faire X, mais devine que faire Y pourrait mener au succès.
Cependant, la personne ne sait pas non plus comment faire Y.
C'est alors qu'il décide de demander de l'aide à d'autres personnes.
Tout le monde essaie d'aider la personne qui a le problème Y, en s'interrogeant parce qu'on ne voit pas bien pourquoi quelqu'un aurait même besoin d'une telle chose.
Après beaucoup de questions et beaucoup de temps perdu, il apparaît finalement que la personne voulait vraiment résoudre X, et que Y ne peut pas du tout l'aider.

Programmation asynchrone et multithread Payer pour travailler en La formule FLET

Dark Kchlyzov 2020.12.10 20:38 #50

Vitaly Muzichenko:

Jusqu'à présent, c'est ce que je vois.

Alors je suppose que tu n'as toujours pas trouvé tes X et Y ! !!

Array out of range in Besoin d'aide - page 5

C'est quoi le "problème XY" ?