Discussion :

[olix2007]

Bonjour,

Voici mon problème, qui est connu, mais pour lequel je ne trouve pas de solutions correctes.
Je recherche a arrondir et tronquer un double dans le seul but de faire des calculs qui ne seront jamais affichés mais envoyés à un périphérique du PC.
Je prend un exemple :
200.0/500.0 = 0.40000000000000002
A priori pas de problème, vu du coté microprocesseur on sait que la représentation exacte d'un flottant est presque impossible, d'ou le 2 qui traine.
Le problème c'est que ce 2 qui traine m'emm.....de.
Dans l'autre sens 1- (200.0/500.0) = 0.59999999999999998

La question est simple : est il possible de faire des calculs en ayant les valeurs correctes (tronquées ou arrondies).

Marc

[JolyLoic]

Le problème c'est que ce 2 qui traine m'emm.....de.

La question est : En quoi te pose-t-il problème ?

Si vraiment c'est parce que tu as besoin de t'en débarrasser (ex : Calculs financiers où les modes d'arrondis sont spécifiés au niveau légal), pas le choix, il te faut ne plus utiliser des flottants, mais un type monétaire fait pour (par exemple codé en base 10), bien que moins performant.

Si c'est juste pour de l'esthétisme, la question n'est pas "comment se débarasser du 2", mais plutôt "comment spécifier la précision à l'affichage (ou sauvegarde...) des flottants"

[olix2007]

Bonjour,

ce n'est pas pour un calcul monétaire, mais pour un calcul de math précis.
Si je reprend cet exemple :
1- (200.0/500.0) = 0.59999999999999998

Dans mes calculs je dois le multiplier par un entier (qui n'est jamais le même) :
(long)(0.59999999999999998 * 16000000.0) = 9599999
Le fait de ne pas avoir le bon nombre 9600000, fait que mon algorithme diverge rapidement.
Mon but est simple quand je fait 1-(200.0/500.0) je veux 0.6 et non 0.59999999999999998. Ce n'est pas une question de représentation puisque je n'affiche jamais les valeurs, elles sont utilisées par un périphérique du PC.

Merci

[olix2007]

Une solution serait de travailler avec des entiers :
(1- (200.0/500.0)) + EPSILON = 0.60000000099999998
(long)(0.60000000099999998 * 1000000) = 600000

Maintenant on redivise par 1000000:
600000 / 1000000 = 0.59999999999999998 loupé !!!! ça marche pas !!!

Les valeurs trouvées sont lues a partir du debuguer (VS2008).

[white_tentacle]

En fait, la question est "de quelle précision as-tu besoin" ?

Si c'est d'une précision à 3 chiffres, par exemple, tu peux travailler sur des entiers * 1000.

S'il s'agit d'une précision exacte (par exemple, 3*1/3 = 1), il te faut une librairie de calcul formel. Je n'en ai jamais utilisé donc je ne peux pas te conseiller là-dessus. Tu peux regarder mupad comme logiciel, par contre.

[Jean-Marc.Bourguet]

C'est un probleme de representation interne: les flottants ont (en general) une representation binaires. Essaie d'exprimer 0.6 comme une fraction avec une puissance de 2 au denominateur, tu n'y arriveras pas plus que tu n'arrives a exprimer 1/3 comme une fraction avec une puissance de 10 au denominateur.

Suivant la nature de ton probleme, la solution est de
- essayer de masquer le probleme. On peut parfois le faire de maniere a prouver qu'on a un resultat correct. Si on n'a pas de preuve mathematique de ca, on a un risque non negligeable de passer son temps a ajouter des verrues sans jamais arriver a l'objectif dans tous les cas
- utiliser un format flottant ou virgule fixe non binaire mais decimal (ou sur une autre base choisie de maniere intelligente). Si on essaie ca pour le mauvais probleme, on est en fait dans la premiere solution. Et c'est ce a quoi s'exposent ceux qui pensent que les flottants decimaux sont la solution universelle a ce probleme (p.e. avec des flottants decimaux on peut avoir pour 0<a<b, (a+b)/2 > b ce qui n'arrive pas avec des flottans binaires et qui est quand meme genant si on suppose que de la dichotomie va converger)
- utiliser un vrai format de rationnel
- utiliser un format d'intervalle
- utiliser du calcul symbolique pour avoir un resultat exact
- vivre avec et travailler sur le reste de la chaine pour ne pas etre aussi sensible.

[olix2007]

Bonjour white,

effectivement le fait de travailler avec des entiers fonctionne, tant que l'on reste dans les monde des "entiers". Dès que l'on veut retourner au monde des "flottants" on réintroduit l'erreur de calcul due aux flottants.
Alors peut être que la solution est toute simple : on ne peut pas ! car effectivement le représentation précise d'un flottant par un microprocesseur est impossible. J'aimerai avoir une confirmation.

Merci

[olix2007]

Merci jean marc pour cette réponse.

Je vais partir sur la solution virgule fixe, qui doit être la solution la plus rapide.
J'enverrai un post pour soumettre les résultats.

Merci.