[FLOAT] Problème sur addition et soustraction

Bonjour,

Je cherche à manipuler des données de type float , pour d'une part faire des opérations mathématiques (additions, soustraction) et d'autre part afficher ces informations à l'écran (g.drawString).

Les données me proviennent depuis un serveur distant dans une Hashtable et sont de type String. Je dois les caster en float, effectuer mes opérations, les recaster en String avant de les afficher via mon drawString.

Le problème est que j'obtiens des erreurs d'arrondis.
Exemple:

J'ai 1999.99, je le convertis en float et lui rajoute 1999.99, je caste le résultat en String pour affichage et vois affiché 3999.98 (normal)

Je caste 3999.98 en float et lui ajoute 1999.99, je caste en String pour affichage et vois affiché 5999.9697 (problème d'arrondis)

Et ainsi de suite, par moment des opérations se passent sans problèmes et d'autres fois elles donnent ce type de résultat avec une précision plus faible.

Est-ce qu'il y a une solution ? Est-il possible de positionner la précision des float (le nombre de digits après la virgule) ?

Merci d'avance.

Salut.

Alors ton problème est tout à fait normal et est lié à la manière utilisée dont les nombres flottants sont représentées en binaire (IEEE 754).

Vu que tu as des String au départ, tu ferais mieux d'utiliser la classe BigDecimal qui n'a pas ce problème et qui se construit à partir de String.

Voir la FAQ à ce sujet. ;)

Salut,

Merci pour la rapidité de cette réponse.
Cependant, la classe BigDecimal n'est pas présente dans la jsr118 (midp 2.0) ; je pense alors suivre le chapitre de la FAQ pour créer une méthode d'arrondi.

Encore merci pour la réponse et sa précision.

:oops: :oops:

Effectivement, j'avais pas vu que c'était pour du J2ME.

Désolé. :oops:

Petite précision également : la méthode Math.pow n'est pas disponible en mdip. Il faut donc la refaire.

Sinon, maintenant mes arrondis sont bien faits et je n'ai plus de problèmes de précision.

Encore merci.

salut,

si tu connais à l'avance le nombre maximum de décimales dont tu auras besoin, tu peux utiliser la notion de 'fixed point'. Ainsi, tu définis par convention qu'un nombre de bits de ton entier représente en fait la partie décimale.

Exemple concret, prenons un nombre codé sur 8 bits (byte) où on décide que les deux derniers bits sont la partie décimale. On aura alors une précision de 1 / 2^2 = 0.25

le nombre 1 sera alors représenté par (0x00000100)
le nombre 0.5 sera alors représenté par (0x00000010).

Pour convertir un entier en fixed point, un simple décalage de deux bits vers la gauche suffira. Idem pour la conversion inverse (décalage à droite).

Pour additionner deux nombres en fixedPoint, on les ... additionne, tout bêtement. Idem pour la soustraction.
Exemple: 2 + 4 = (0x00001000) + (0x00010000) = (0x00011000)

Pour diviser, on divise par le facteur représenté en entier, par en fixed Point:
exemple: 2 / 4 = (0x00001000) / (0x00000100) = (0x00000010) = 0.5

Bien entendu, l'exemple est sur 8 bits, mais un Integer (codé sur 32 bits donc) avec par exemple une partie décimale de 16 bits te donne un nombre qui peut valoir entre -32000 et 32000 avec une précision de l'ordre de 0.0000152.
A toi ensuite de voir tes besoins.

L'avantage de ce genre de représentation est que les calculs qu'on fait sont bien plus efficaces (une opération sur un entier étant bien plus rapide que sur un nombre flottant pour un processeur). C'est d'ailleurs non négligeable pour les processeurs peu puissants embarqués dans les téléphones mobiles, ...

Le gros désavantage est que tu dois dès le départ fixer le nombre de bits assigné aux décimales, donc fixer une fois pour toutes la précision de tes nombres.