Discussion :

[gangsoleil]

Bonjour,

Amené à comparer des doubles, je me pose une question quasi rhétorique sur leur comparaison : est-ce que si, dans R, a > b, un mécanisme garantit que dans du code a > b ?

Un exemple sera plus parlant qu'un long discours :
premier double a, dont la valeur réelle est 42 et dont la valeur "codée" est 42.000 000 1
second double b, dont la valeur réelle est 42.000 000 01, et dont la valeur "codée" est 42.000 000 01

Si je considère epsilon = 10^-5, on se retrouve avec dans R, a < b et dans le programme, a > b, ce qui pourrait poser des problèmes si je ne m'intéresse pas qu'au fait qu'ils soient distincts, mais bien au fait que l'un soit supérieur à l'autre.

Et si aucun mécanisme ne garantit cela (et je ne vois pas comment un tel mécanisme pourrait exister), le code de la FAQ C ne peut pas être considéré comme valide : on peut dire si la distance entre a et b est inférieur à epsilon, et dans ce cas ils sont égaux, mais on ne peut tester l'infériorité ou la supériorité que si la distance entre a et b est supérieure à epsilon.

Je ne suis pas certain d'avoir été très clair, et si c'est le cas, n'hésitez pas à me le dire pour que je reformule.

[ternel]

J'ai vu ta question. Elle m'intéresse, mais j'ai besoin de temps pour réfléchir au problème.

[esired]

On ne peut tester l'infériorité ou la supériorité que si la distance entre a et b est supérieure à epsilon

Vous avez raison. Si vous avez envie d'approfondir le sujet, cet article est assez intéressant.

[Sve@r]

Bonjour

Partons du point de vue de la machine: pour elle, 42.0 (dans ton exemple) n'existe pas. Elle, elle ne voit que 42.000 000 100. Or, 42.000 000 100 étant bel et bien supérieur à 42.000 000 010, aucun mécanisme ne pourra arranger cela. Et si un tel mécanisme était tenté, le premier soucis de son programmeur serait de faire la différence entre un vrai 42.000 000 100 et 42.0 qui serait codé en 42.000 000 100.

Tu retombes sur le problème de l'exactitude des calculs en double quand ça s'avère expressément nécessaire (comptes bancaires par exemple) qui nécessitent l'emploi de librairies dédiées (comme Decimal en Python et je suppose qu'il doit en exister en C mais je ne les connais pas) ou de langages dédiés (comme le COBOL) et qui fonctionnent à base de chiffres positionnés un à un dans des cases distinctes. A ce moment là, 42.0 occupe 3 digits (PIC 99V9 en COBOL).

[diogene]

Je ne comprend pas l'exemple que tu cites : Si |a|<|b|, je ne vois pas comment la valeur codée pour |a| pourrait être supérieure à la valeur codée pour |b|

[Sve@r]

Je ne comprend pas l'exemple que tu cites : Si |a|<|b|, je ne vois pas comment la valeur codée pour |a| pourrait être supérieure à la valeur codée pour |b|

C'est vrai, elle ne peut certainement pas être supérieure (les puissances de deux, même en négatif, restent dans l'ordre relatif de leurs valeurs respectives)

Toutefois rien ne garantit qu'elle sera toujours vue comme étant inférieure...

Code c :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
#include <stdio.h>
 
int main()
{
	double a=2.97999999999999999;
	double b=2.98;
	printf("%s\n", a < b ?"vrai" :"faux");
}

[diogene]

Toutefois rien ne garantit qu'elle sera toujours vue comme étant inférieure...

Evidemment, elles peuvent être vues comme égales. Mais ça, c'est la question classique de la comparaison à l'égalité de deux flottants. Cela ne correspond pas à l'exemple cité dans le premier post.

[ternel]

C'est vrai, elle ne peut certainement pas être supérieure (les puissances de deux, même en négatif, restent dans l'ordre relatif de leurs valeurs respectives)

Toutefois rien ne garantit qu'elle sera toujours vue comme étant inférieure...

Cela dit, les valeurs ne sont pas supérieures non plus (avec visual C++ 2008 pour un XP 32bits)
Pour moi, le code suivant affiche faux pour les deux tests.

Code c :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
#include <stdio.h>
int main()
{
	double a=2.97999999999999999;
	double b=2.98;
	printf("2.97999...<2.98 ? %s\n", a < b ?"vrai" :"faux");
	printf("2.97999...>2.98 ? %s\n", a < b ?"vrai" :"faux");
}

[gangsoleil]

Je ne comprend pas l'exemple que tu cites : Si |a|<|b|, je ne vois pas comment la valeur codée pour |a| pourrait être supérieure à la valeur codée pour |b|

Dans R, j'aurai a qui vaut 42, et b qui vaut 42, pas de soucis.

Dans un monde discret, a et b sont représentés à epsilon près, par exemple, si epsilon vaut 3*10^-6
a pourrait être codé, par exemple, 42.000 001
b pourrait être codé, par exemple, 41.999 999

Et comme on le sait, pour savoir si a == b, on fait la différence entre a et b et on compare cette différence à epsilon.


Bien. Maintenant, dans R, j'ai a qui vaut 42.000 001, et b qui vaut 42.000 0002
Dans mon ordi, chaque nombre est codé à epsilon près, ce qui pourrait donner :
a = 42.000 002
b = 42.000 001

Dans ce cas précis, dans R, a < b, mais dans l'ordi a > b. En fait, ce que je dis, c'est que dans le cas où (a-b) < epsilon, on ne peut pas dire que a > b ou a < b. Et donc ce que je dis aussi, c'est que le code qui est dans la FAQ n'est pas bon.

Pour moi, le code devrait ressembler à cela -- sauf qu'ici je ne gère qu'un seul epsilon, et que la fonction abs() prend un int en entrée :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
int compare_double (double a, double b, double epsilon)
{
  int ret;
 
  if (abs(b-a) < epsilon)
  {
    ret = 0; /* ils sont égaux */
  }
  else
  {
    if ( a < b )
    { 
      ret = -1;
    }
    else
    {
      ret = 1;
    }
  }
 
  return ret;

[diogene]

Bien. Maintenant, dans R, j'ai a qui vaut 42.000 001, et b qui vaut 42.000 0002
Dans mon ordi, chaque nombre est codé à epsilon près, ce qui pourrait donner :
a = 42.000 002
b = 42.000 001

C'est ça que je ne crois pas possible : le nombre |a| est codé par une certaine approximation de sa valeur réelle. Celle-ci peut être, (1) la plus grande valeur codable inférieure ou égale à |a|, (2) la plus petite valeur codable supérieure ou égale à |a|, (3) la valeur codable la plus proche de |a|.
Ce peut être une option du compilateur que de choisir parmi ces possibilités, mais elle s'applique à l'ensemble des flottants. Dans ces trois choix, la configuration que tu évoques ne peut se produire.

Faut-il envisager le cas d'utilisation d'unités de compilation séparées qui auraient été compilées avec des options différentes ?