Fora de alcance em Necessidade de ajuda

Dark Kchlyzov 2020.12.10 12:33 #41

Ihor Herasko:

Eu nem sei o que mais acrescentar... Eu basicamente dei os exemplos básicos. Este é o código. É por isso que você pode me perguntar o que não está claro.

Saudações! Igor um exemplo claro de como obter um valor . Tenho uma linha de nível_baixo_D1_baixo que encontra a barra mais próxima na história qual o valor será inferior ao nível_baixo_D1_baixo

Se eu trabalhar com Estrutura sem matriz, obtenho o mesmo resultado que no último código.

Escreva um exemplo , e se não se importar com uma descrição .

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

Noite de fim de Perguntas de Iniciantes MQL4 Ajuda na codificação

Aleksei Stepanenko 2020.12.10 14:31 #42

Dark Kchlyzov:

Se o Nível_Baixo_D1_Nível é o nível do dia anterior, então o Nível_Mín_D_Nível é pesquisado a partir doNível_Baixo_D1_Nível e é igual a i=1 , ou estou enganado?

Desculpe, eu não entrei no código, pedi para ter certeza de que você estava fazendo isso de forma consciente.

Você pode me dizer o que você quer obter como resultado? Algum nível diário ou o quê? Olhando para a primeira linha, copiar constantemente um array no ArrayCopyRates e depois passar por ele não é a opção mais econômica. Você poderia encontrar uma solução mais elegante.

Como posso determinar se O que é a Qualquer pergunta de novato,

Dark Kchlyzov 2020.12.10 18:19 #43

Aleksei Stepanenko :

Peço desculpas, não me aprofundei no código, pedi para ter certeza de que você está fazendo isso conscientemente.

Você pode dizer o que quiser no final. Algum nível diário ou o quê? Observar a primeira linha, copiar constantemente a matriz para ArrayCopyRates e depois fazer um loop por ela não é a opção mais econômica. Você pode encontrar uma solução mais elegante.

Estou na bolsa há mais de 5 anos, e no momento vivo completamente ( você faz isso conscientemente ). Há um ano, quando o entendimento da negociação em bolsa já estava mais ou menos fortalecido,

Decidiu-se automatizar os seus conhecimentos no ofício, quer fazer um bom DIY.

Foi assim que o MQL4 conscientemente veio até mim, no momento o EA tem mais de 6.000 linhas.

aqui está um código de exemplo ao calcular o lote 1 ano atrás.

 // Примитивно но работало 
//+-------------------------------------------------------------------------+
//                       Функция расчета лота от прибыли                    +                                                   +
//+-------------------------------------------------------------------------+
// 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);
  }

E aqui está a mesma função depois de meio ano

 //+-------------------------------------------------------------------------+
//                  Функция расчета лота от прибыли  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);

Aqui está o motivo da criação deste tópico.

Percebi puramente por acaso e visualmente quando comecei a executar o advisor em longos períodos, se a segunda condição foi removida no ciclo, ocorreu um erro (fora do array) e a segunda condição simplesmente mascarou o erro real.

Aqui está a Função que precisa ser depurada, e é hora de estudar Estruturas, Classes.

Não julgue estritamente por escrever código - :)

 глоб. переменные
//+------------------------------------------------------------------+
//|                        Функция 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);
      }
   }       
}

Cronograma dinâmico É possível fazer um Explique o mecanismo. Se

Aleksei Stepanenko 2020.12.10 18:52 #44

Dark Kchlyzov:

Aqui está a função de depuração.

OK, e você pode me dizer com o que você quer acabar?

Dark Kchlyzov 2020.12.10 19:01 #45

Aleksei Stepanenko:

Ok, você pode me dizer com o que você quer acabar?

Aqui está a versão abreviada executada no AUDUSD 2020

Por que não vai mais longe na matriz?

//+------------------------------------------------------------------+
//|                                                   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();
   }
}

Aleksei Stepanenko 2020.12.10 19:04 #46

Você me pergunta por que não funciona, e eu estou tentando entender o essencial em palavras, porque pode haver uma solução melhor para o seu problema, que é o que eu estou tentando descobrir.

Explique o que você está tentando alcançar.

FOREX - Tendências, Previsões Da teoria à prática Gunn, astromecânica. Previsões, discussão

Vitaly Muzichenko 2020.12.10 19:07 #47

Aleksei Stepanenko:

Você me pergunta por que isso não funciona, e eu estou tentando entender o essencial em palavras, porque pode haver uma solução melhor para seu problema, que é o que eu estou tentando descobrir.

Explique o que você quer obter.

Até agora eu vejo _so_

Aleksei Stepanenko 2020.12.10 19:12 #48

Vitaly Muzichenko:

Até agora eu vejo _that_.

Sim, é assim que funciona a percepção humana. Eu também, quando estou realmente apaixonado por uma idéia, mal consigo ouvir os argumentos da outra pessoa. Ah, bem...

Dark Kchlyzov 2020.12.10 19:20 #49

Vitaly Muzichenko:

Até agora eu vejo _ so_.

Háum nívelBaixo_D1_Nível_Baixo , então precisamos obter o valor do próximo nível Min_D_Nível, que será o próximo mais baixo da história e será inferior ao Nível_Baixo_D1_Nível.

Não sei como explicar melhor. Se você executar o código no testador com a visualização na minha opinião, tudo é visível.

E, em geral, se você vier ao posto, por favor, tenha a gentileza de, pelo menos, ler a essência.

Isso não tem nada a ver com a questão:

Qual é o "problema XY"?

É um erro que muitas vezes desperdiça o tempo tanto da pessoa que pede ajuda quanto das pessoas que tentam respondê-la. Também é chamado de "Problema do Martelo". Em resumo, as pessoas tendem a perguntar sobre suas tentativas fracassadas de resolver o problema, e não sobre o problema em si. Acaba indo algo parecido com isto:

Uma pessoa quer fazer X.
Ele não sabe como fazer X, mas adivinha que fazer Y pode levar ao sucesso.
Entretanto, a pessoa também não sabe como fazer Y.
Neste momento, ele decide pedir ajuda a outras pessoas.
Todos tentam ajudar a pessoa com o problema Y, se perguntando porque não está claro por que alguém precisaria de tal coisa.
Depois de muito questionamento e muito tempo perdido, finalmente fica claro que a pessoa realmente queria resolver X, e que Y não pode ajudá-lo em nada.

Como encontrar o tempo Programação ao pôr-do-sol? Quaisquer perguntas de recém-chegados

Dark Kchlyzov 2020.12.10 19:38 #50

Vitaly Muzichenko:

Até agora, eu vejo _so_.

Então eu acho que você ainda não encontrou seu X e Y !!!

Fora de alcance em Necessidade de ajuda - página 5

Qual é o "problema XY"?