Discussion :

[nikobordx]

Bonjour à tous et à toutes !

J'ai développé un programme qui utilise que des entiers ou des flottants (pas de double), lors de la conversion d'un flottant vers un entier, j'ai un résultat inattendu et je souhaiterai si possible avoir une explication...

Code :

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

1
2
3
4
5
6
7
8
9
#include <iostream>
 
using namespace std;
 
int main(int argc, char** argv) {
    float t = 0.45;
    cout << "t = " << static_cast<int>(t*100) << endl;
    return 0;
}

Quand ce code est exécuté il me retourne "44", savez-vous pourquoi ?
Merci d'avance,
Nicolas.

[ternel]

Bonjour,
C'est parce que les floats ne sont pas exacts (en base 10). Ils sont précis (mais limités) en base 2.

Du coup, 0.45 * 100 est probablement 44.999... ce qui donne le 44 que tu obtiens.

[nikobordx]

Bonsoir et merci pour cette réponse, j'utilise un double, ça fonctionne bien.

[JolyLoic]

Bonsoir et merci pour cette réponse, j'utilise un double, ça fonctionne bien.

Il n'y a pas de raisons...
Peut-être qu'en double, 0.45 est représenté par 0.4500000....0001, et que ça se passe bien, mais que 0.46 sera représenté par 0.4599999999... et que ça se passera mal.

[nikobordx]

A vrai dire je n'ai que du 0.45, 0.35 et au pire 0.25, donc pas de souci en vue...

Mais, y a t'il une solution pour que ce soit vraiment précis ?

[Jean-Marc.Bourguet]

J'ai développé un programme qui utilise que des entiers ou des flottants (pas de double)

Deuxième règle d'emploi des flottants: on utilise le type le plus précis qu'on peut sauf si on sait ce que l'on fait.

A vrai dire je n'ai que du 0.45, 0.35 et au pire 0.25, donc pas de souci en vue...

Je n'en suis pas aussi sûr que toi. (La valeur avec le moins de soucis, c'est 0.25 qui est représentable exactement dans les formats courants).

Mais, y a t'il une solution pour que ce soit vraiment précis ?

Défini précis. Il y a une infinité non dénombrable de réel, et en prime ceux-ci sont denses (entre deux réels, il y en a toujours une infinité non dénombrables d'autres). Être vraiment précis, il faut utiliser du calcul symbolique, avec son lot de problèmes et de limitations propres.

Les flottants décimaux ne donnent guère qu'une illusion de précision (ils permettent de représenter une partie des réels dont l'expression décimale est simple), mais son en fait moins précis que les flottants binaires et ont tous les autres problèmes des flottants binaires, et quelques uns en plus. P.e. (a+b)/2 peut être strictement plus petit que min(a, b)).

Bon, dans le cas présent, ton problème n'est pas un vrai problème de précision, c'est plutôt parce que tu tronques quand arrondir conviendrait mieux. Autrement dit, utilise lround() à la place de static_cast<int>

[ternel]

0.5 et 0.25 sont exactement représentés.
Mais 3 * 0.25 ne l'est pas. en fait, même 0.1 ne l'est pas.

En résumé, seules les sommes de puissances de 2 (1/2, 1/4, 1/8, ...) sont représentables exactement (et encore, pas toutes).

[Jean-Marc.Bourguet]

0.5 et 0.25 sont exactement représentés.
Mais 3 * 0.25 ne l'est pas.

3*0.25 est représentable exactement dans les formats courants et les processeurs incapables de faire cette multiplication exactement doivent tous être à la casse ou dans des musées pour ceux qui ont eu le plus de chance. (C'est 0.11 en binaire)

[Bousk]

Si tu n'as que 3 valeurs, autant passer par un enum.

[nikobordx]

Merci à tous pour ces précisions !

Finalement, j'ai remis un float et j'utilise "lroundf"

[Jean-Marc.Bourguet]

Finalement, j'ai remis un float et j'utilise "lroundf"

Pour quelle raison utiliser float plutôt que double?

[nikobordx]

A vrai dire il n'y a pas de raison particulière.
Comme mon programme utilise des nombres à virgule (en très grand nombre), je suis parti sur des floats...

[Jean-Marc.Bourguet]

A vrai dire il n'y a pas de raison particulière.
Comme mon programme utilise des nombres à virgule (en très grand nombre), je suis parti sur des floats...

1/ Moi j'ose pas utiliser les floats sans avoir estimé les erreurs et m'être assuré que c'était bon. 24 bits de précision relative, c'est vraiment trop imprécis pour prendre des risques.

2/ Même quand on utilise des floats pour le stockage, on fait normalement les calculs avec des doubles autant que possible.