Discussion :

[Pascale38]

Bonjour,
si quelqu'un peut m'expliquer pourquoi ce code se comporte de façon "inattendue", c'est à dire que je passe dans le "if", alors que les 2 valeurs sont identiques.
Si j'enlève la ligne min*=6 et que j'affecte 1.6 à value1, je ne passe pas dans le if -> comportement attendu.
C'est le fait de multiplier qui engendre ce comportement.
Si je remplace les double par des float, le comportement est "correct".
Un truc sur les "double" qu'il faudrait savoir?

Code :

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

1
2
3
4
5
6
7
8
9
 
        double min = 1.6;
	min *= 6;
 
	UnicodeString value1 = "9.6";
	double value2 = value1.ToDouble();
	if (value2 < min) {
		....
	}

Je vous remercie d'éclairer ma lanterne !
Pascale38

[Daïmanu]

Bonjour.

C'est une question classique en C et C++, traitée dans la FAQ C (mais ça marche aussi pour le C++).

Mais pour faire simple, une nombre flottant (float et double) ont une précision limitée, des arrondis peuvent avoir lieu et fausser les résultats.

Typiquement, chez moi, 1.6 est stocké sous la forme 1.60000000000000008 (probablement la valeur la plus proche que la machine puisse stocker). L'imprécision est propagée avec la multiplication et fausse la comparaison.

[Crayon]

Avec C++Builder tu peux utiliser Math::CompareValue pour faire des comparaisons de double.

Exemple:

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
    double min = 1.6;
    min *= 6;
 
    UnicodeString value1 = "9.6";
    double value2 = value1.ToDouble();
    const System::Types::TValueRelationship LRelation = Math::CompareValue(value2, min);
    if (LRelation == LessThanValue) {
        // <
    }
    else if (LRelation == GreaterThanValue) {
        // >
    }
    else if (LRelation == EqualsValue) {
        // ==
    }

[Pascale38]

Merci !!!!

[dalfab]

Bonjour,

Mais attention à l'utilisation d'outils qui semblent absorber le problème. Le fait que les flottants sont toujours des approximations et ne sont pas des vérités mathématiques ne doit jamais être oublié. Les pièges sont :
- savoir que le nombre est une approximation. P.e 1.6 est un nombre qui tombe juste en décimal mais qui a une infinité de décimales en binaire (et ici il semble que le 1.6f float est plus petit que le vrai 1.6 et que le 1.6 double est plus grand que le vrai 1.6)
- savoir qu'effectuer des calculs provoque une amplification de ces approximations y compris sur des nombres entiers. P.e pow(7.0,3.0) peut être différent de 7*7*7 alors que 7.0 et 3.0 sont pourtant toujours exacts.
- ne jamais effectuer de test d'égalité entre 2 flottants pour les raisons ci-dessus
- et les tests d'inégalité doivent utiliser une marge de sécurité. en gros on a 4 cas:

• nombre nettement inférieur
• nombres presque égaux
• nombre nettement supérieur
• nombres non comparables. Très rare (p.e. 0.0/0.0 est ni inférieur, ni supérieur, ni égal à quelque nombre que ce soit, il n'est pas même égal à lui même. C'est normal ça n'est pas un nombre!)

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
void tester( double test ) {
    if ( test < 9.6*0.9999 )
        std::cout << test << " est inférieur à 9.6\n";
    else if ( test < 9.6*1.0001 )
        std::cout << test << " est égal ou presque à 9.6, l'écart est " << test-9.6 << "\n";
    else if ( test >= 9.6*1.0001 )
        std::cout <<  test << " est supérieur à 9.6\n";
    else         // oui c'est possible d'arriver là avec des inégalités sur des flottants!
        std::cout << "le 'nombre' " << test << " n'est pas comparable\n";
}
int main() {
    double test=1.6;
    test *= 6;
    tester( test );
    test = 0.0;
    test /= 0.0;
    tester( test );
}

[foetus]

pow(7.0,3.0) peut être différent de 7*7*7 alors que 7.0 et 3.0 sont pourtant toujours exacts.

Pour être précis (mais à confirmer) pour des raisons de nombres négatifs, la fonction pow ne fait pas de multiplication.

pow(x,y) = exp(y * ln(x))