Bonjour je fais le calcul suivant que je stock dans un float
1e-9+1e9

Et lorsque j'affiche le résultat à 10 chiffres après la virgule cela arrondi la fin à 0
J'obtiens donc 1 000 000 000.000 000 00'''0'''
Alors que je veux 1 000 000 000.000 000 00'''1'''

On me demande de proposer une solution pour obtenir le résultat correct sauf que je ne trouves rien sur le net qui pourrait me mettre sur la piste
Des idées ?

Tu as double et long double comme type de variables qui te permettent de stocker un nombre à virgule flottante avec plus de précision

ça fait longtemps que je me suis pas plongé dans ce genre de truc, mais vas jeter un œil à la norme IEEE 754, quantization etc.. une fois que t'auras compris comment ça marche transpose avec les types dispo en C et ça devrait aller

Ces deux nombres:

J'obtiens donc 1 000 000 000.000 000 000
Alors que je veux 1 000 000 000.000 000 001

ont la meme representation au format IEEE 754 32-bit.
Ce n'est pas une question de langage de programmation.

La seule solution possible est de change le format de representation. Une fois que tu change de format, il y en a plsueyrs qui peuvent fournir cette fonctionallite. Mais float (IEEE 754 32-bit) ne le fera jamais.

Ça me rappelle les fameux troll sur javascript 0.1 + 0.2 != 0.3 alors que ça n'a rien à voir avec le langage

Ça me rappelle les fameux troll sur javascript 0.1 + 0.2 != 0.3 alors que ça n'a rien à voir avec le langage

exactement. Alors qu'il y a tellement a dire sur javascript!

Le 15 septembre 2021 à 22:25:35 :
Ça me rappelle les fameux troll sur javascript 0.1 + 0.2 != 0.3 alors que ça n'a rien à voir avec le langage

J'avais le souvenir de cette exemple de la fac, j'ai un peu oublié le pourquoi du comment (j'ai souvenir que c'est une histoire de mantisse etc..), mais je viens de tester en python 3.7

>>> (0.1 + 0.2) == 0.3
False
>>> (0.1 + 0.2) != 0.3
True

Je suis quand même surpris qu'il y ai pas un workarround mis en place pour forcer une sortie correcte ? Il y a un risque d'avoir un bug ultra rare et spécifique avec ce genre de petit problème non ?

Le 16 septembre 2021 à 00:45:32 :

Le 15 septembre 2021 à 22:25:35 :
Ça me rappelle les fameux troll sur javascript 0.1 + 0.2 != 0.3 alors que ça n'a rien à voir avec le langage

J'avais le souvenir de cette exemple de la fac, j'ai un peu oublié le pourquoi du comment (j'ai souvenir que c'est une histoire de mantisse etc..), mais je viens de tester en python 3.7

<code>

(0.1 + 0.2) == 0.3

False

(0.1 + 0.2) != 0.3

True
</code>

Je suis quand même surpris qu'il y ai pas un workarround mis en place pour forcer une sortie correcte ? Il y a un risque d'avoir un bug ultra rare et spécifique avec ce genre de petit problème non ?

Non; aucun risque, chacun sait qu'on ne teste jamais l'égalité entre deux floats.
Après dans les langages non typé où tu sais pas forcément si c'est un int ou un float ça peut en surprendre plus d'un

Le 16 septembre 2021 à 00:45:32 :

Le 15 septembre 2021 à 22:25:35 :
Ça me rappelle les fameux troll sur javascript 0.1 + 0.2 != 0.3 alors que ça n'a rien à voir avec le langage

J'avais le souvenir de cette exemple de la fac, j'ai un peu oublié le pourquoi du comment (j'ai souvenir que c'est une histoire de mantisse etc..), mais je viens de tester en python 3.7

<code>

(0.1 + 0.2) == 0.3

False

(0.1 + 0.2) != 0.3

True
</code>

Je suis quand même surpris qu'il y ai pas un workarround mis en place pour forcer une sortie correcte ? Il y a un risque d'avoir un bug ultra rare et spécifique avec ce genre de petit problème non ?

Basiquement, il ne faut pas tester l'egalite pour des nombres a virgule flotantes (sauf dans des cas extreme). Il faut tester |a-b|<epsilon pour un epsilon qui a du sens pour ton application.

Le 16 septembre 2021 à 00:45:32 :

Le 15 septembre 2021 à 22:25:35 :
Ça me rappelle les fameux troll sur javascript 0.1 + 0.2 != 0.3 alors que ça n'a rien à voir avec le langage

J'avais le souvenir de cette exemple de la fac, j'ai un peu oublié le pourquoi du comment (j'ai souvenir que c'est une histoire de mantisse etc..), mais je viens de tester en python 3.7

<code>

(0.1 + 0.2) == 0.3

False

(0.1 + 0.2) != 0.3

True
</code>

Je suis quand même surpris qu'il y ai pas un workarround mis en place pour forcer une sortie correcte ? Il y a un risque d'avoir un bug ultra rare et spécifique avec ce genre de petit problème non ?

Encore heureux que les langages fassent pas leur popote et utilisent des standards universellement reconnus, testés et étudiés

D'autant que je rappelle : python n'est pas un langage scientifique, pourquoi un langage non scientifique utiliserait des décimaux à précision arbitraire ou des rationnels plutôt que des flottants pour leurs nombres littéraux de base ?