Caractéristiques du langage mql5, subtilités et techniques - page 241

[Ihor Herasko]

fxsaber #:

Vous refusez de comprendre.

Peut-être que je comprendrais si je connaissais le contexte de la situation. Mais en l'état, cela semble correct.

[Denis Kirichenko]

amrali #:

Tant que les deux montants sont égaux, n'importe lequel d'entre eux est un minimum valide. Considérons MathMin(1, 1), il n'y a pas de différence si la fonction renvoie le premier (1) ou le second (1).

Ainsi, renvoyer 0,0 n'est pas différent de -0,0.

Édition : à propos, les deux expressions mises en évidence ne sont PAS identiques.

Je pense que je suis d'accord avec mon collègue amrali. J'ajouterais également qu'il existe une fonction native MathMin(). Elle pense également que les zéros avec des signes différents sont égaux. D'après ce que j'ai compris, son algorithme est assez simple. Je l'ai dupliqué dans ma fonction 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;
   }
//+------------------------------------------------------------------+

Nous l'avons dans le journal :

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

Il est facile de voir qu'à partir de deux nombres égaux, l'algorithme prendra le second nombre comme valeur minimale de...

[Nikolai Semko]

fxsaber #:

Vous refusez de comprendre.

   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

il n'y a rien de spécial. C'est juste -0,0==0,0.

[fxsaber]

Nikolai Semko #:

rien de spécial. Juste -0.0==0.0

Je connais très bien la question et j'ai donc écrit les deux variantes de MathMin pour montrer que des fonctions mathématiquement identiques dans des langages de programmation produisent des résultats différents.

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 #:

J'ai une excellente compréhension de la question et j'ai donc écrit les deux versions de MathMin pour montrer que des fonctions mathématiquement identiques dans des langages de programmation produisent des résultats différents.

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
}

Qu'est-ce qui est donc inhabituel ?
Le fait que les 64 bits des nombres 0,0 et -0,0 ne soient pas tous identiques est évident:

mais quand même 0,0 == -0,0

[Nikolai Semko]

Ihor Herasko #:

Les signes < et <= semblent être différents.....

accepter

[Alain Verleyen]

Nikolai Semko # :

Qu'est-ce qui est donc inhabituel ?
Le fait que les 64 bits des nombres 0,0 et -0,0 ne soient pas tous identiques est évident:

Il s'attend à ce que MathMin() soit déterministe. Donc qu'il donne toujours le même résultat lorsque les deux arguments sont identiques. Et non pas un résultat différent selon que l'argument est le premier ou le second.

fxsaber a raison, c'est un problème.

[Denis Kirichenko]

Alain Verleyen #:

Il s'attend à ce que la fonction MathMin() soit déterministe. C'est-à-dire qu'elle donne toujours le même résultat lorsque les deux arguments sont identiques. Et non un résultat différent selon que l'argument est le premier ou le second....

Et c'est le cas. Lorsque deux nombres sont égaux, c'est le second qui est retourné. Je l'ai montré ci-dessus avec un exemple...

[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

et il n'y a rien de mal à cela.

[fxsaber]

Alain Verleyen #:

Il s'attend à ce que la fonction MathMin() soit déterministe. C'est-à-dire qu'elle donne toujours le même résultat lorsque les deux arguments sont identiques. Et non un résultat différent selon que l'argument est le premier ou le second.

fxsaber a raison, c'est un problème.

Vous avez bien compris mon point de vue. Vous pouvez rencontrer le problème difficile à trouver d'obtenir des résultats différents dans un code volumineux. C'est pourquoi j'ai informé la communauté dans ce fil de discussion.