Características da linguagem mql5, subtilezas e técnicas - página 241

[Ihor Herasko]

fxsaber #:

Você se recusa a entender.

Talvez eu entendesse se conhecesse o contexto da situação. Mas, do jeito que está, parece certo.

[Denis Kirichenko]

amrali #:

Desde que os dois valores sejam iguais, qualquer um deles é um mínimo válido. Considere MathMin(1, 1), não há diferença se a função retorna o primeiro (1) ou o segundo (1).

Portanto, retornar 0,0 não é diferente de -0,0.

Edit: a propósito, as duas expressões destacadas NÃO são idênticas.

Acho que concordo com meu colega amrali. Eu também acrescentaria que há uma função nativa MathMin(). Ela também considera que os zeros com sinais diferentes são iguais. Pelo que entendi, seu algoritmo é bastante simples. Eu o dupliquei em minha função CustomMathMin().

//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
void OnStart()
   {
   double positive_zero_val, negative_zero_val;
   positive_zero_val = 0.0;
   negative_zero_val = -0.0;
   // 1) -0.0 / 0.0
   double native_min_val, custom_min_val;
   native_min_val = ::MathMin(negative_zero_val, positive_zero_val);
   custom_min_val = CustomMathMin(negative_zero_val, positive_zero_val);
   ::Print("\nArguments: -0.0, 0.0");
   ::PrintFormat("Native min value = %0.2f", native_min_val);
   ::PrintFormat("Custom min value = %0.2f", custom_min_val);
   // 2) 0.0 / -0.0
   native_min_val = ::MathMin(positive_zero_val, negative_zero_val);
   custom_min_val = CustomMathMin(positive_zero_val, negative_zero_val);
   ::Print("\nArguments: 0.0, -0.0");
   ::PrintFormat("Native min value = %0.2f", native_min_val);
   ::PrintFormat("Custom min value = %0.2f", custom_min_val);
   }
//+------------------------------------------------------------------+
//| Custom MathMin                                                   |
//+------------------------------------------------------------------+
double CustomMathMin(double  value1, double  value2)
   {
   if(value1 < value2)
      return value1;
   return value2;
   }
//+------------------------------------------------------------------+

Temos isso no registro:

2024.01.29 23:49:46.351 c11 (EURUSD,H1) Arguments: -0.0, 0.0
2024.01.29 23:49:46.351 c11 (EURUSD,H1) Native min value = 0.00
2024.01.29 23:49:46.351 c11 (EURUSD,H1) Custom min value = 0.00
2024.01.29 23:49:46.351 c11 (EURUSD,H1) 
2024.01.29 23:49:46.351 c11 (EURUSD,H1) Arguments: 0.0, -0.0
2024.01.29 23:49:46.351 c11 (EURUSD,H1) Native min value = -0.00
2024.01.29 23:49:46.351 c11 (EURUSD,H1) Custom min value = -0.00

É fácil ver que, a partir de dois números iguais, o algoritmo considerará o segundo número como o valor mínimo de...

[Nikolai Semko]

fxsaber #:

Você se recusa a entender.

   Print(-0.0<0.0);     // false
   Print(-0.0>0.0);     // false
   Print(-0.0<=0.0);    // true
   Print(-0.0>=0.0);    // true
   Print(-0.0==0.0);    // true

Não é nada de especial. Apenas -0,0==0,0.

[fxsaber]

Nikolai Semko #:

nada de especial. Apenas -0,0==0,0

Como conheço muito bem a pergunta, escrevi as duas variantes do MathMin para mostrar que funções matematicamente idênticas em linguagens de programação produzem resultados diferentes.

template <typename T>
T ToType( const double Num )
{
  union UNION
  {
    T Num1;
    double Num2;
  } Union;
  
  Union.Num2 = Num;
  
  return(Union.Num1);
}

void OnStart()
{
  Print(ToType<long>(MathMin(-0.0, 0.0))); // 0
  Print(ToType<long>(MathMin(0.0, -0.0))); // -9223372036854775808
}

[Nikolai Semko]

fxsaber #:

Como tenho um excelente entendimento da questão, escrevi as duas versões do MathMin para mostrar que funções matematicamente idênticas em linguagens de programação produzem resultados diferentes.

template <typename T>
T ToType( const double Num )
{
  union UNION
  {
    T Num1;
    double Num2;
  } Union;
  
  Union.Num2 = Num;
  
  return(Union.Num1);
}

void OnStart()
{
  Print(ToType<long>(MathMin(-0.0, 0.0))); // 0
  Print(ToType<long>(MathMin(0.0, -0.0))); // -9223372036854775808
}

Então, o que é incomum?
O fato de que nos números 0,0 e -0,0 nem todos os 64 bits são iguais é óbvio:

mas ainda assim 0.0 == -0.0

[Nikolai Semko]

Ihor Herasko #:

Os sinais < e <= parecem ser diferentes.....

concordo

[Alain Verleyen]

Nikolai Semko # :

Então, o que é incomum?
O fato de que nos números 0,0 e -0,0 nem todos os 64 bits são iguais é óbvio:

Ele espera que MathMin() seja determinístico. Portanto, que sempre forneça o mesmo resultado quando os dois argumentos forem os mesmos. E não um resultado diferente dependendo de qual argumento é o primeiro ou o segundo.

fxsaber está certo, isso é um problema.

[Denis Kirichenko]

Alain Verleyen #:

Ele espera que a função MathMin() seja determinística. Portanto, que sempre forneça o mesmo resultado quando os dois argumentos forem iguais. E não um resultado diferente dependendo de qual argumento é o primeiro ou o segundo....

E assim é. Quando dois números são iguais, o segundo é retornado. Mostrei acima com um exemplo...

[Nikolai Semko]

   Print(pow(0.0,0.0)); 	// 1.0
   Print(pow(-0.0,-0.0));       // 1.0
   Print(pow(-0.0,0.0));        // 1.0
   Print(pow(0.0,-0.0));        // 1.0
   Print(0.0*-0.0);             // -0.0
   Print(-0.0*-0.0);            // 0.0

e não há nada de errado nisso.

[fxsaber]

Alain Verleyen #:

Ele espera que a função MathMin() seja determinística. Portanto, que sempre forneça o mesmo resultado quando os dois argumentos forem os mesmos. E não um resultado diferente dependendo de qual argumento é o primeiro ou o segundo.

fxsaber está certo, isso é um problema.

Você entendeu bem o que eu quis dizer. Você pode se deparar com o problema difícil de encontrar de obter resultados diferentes em códigos grandes. Foi por isso que notifiquei a comunidade neste tópico.