Discussion :

[Kerod]

Salut,

Je tente d'effectuer un simple calcul depuis quelques temps et malgré sa simplicité je n'obtiens pas le bon résultat.

Voici la chose : j'effectue un calcul avec 1 - 1 tous deux des float qui doivent me retourner un float (0). Et non j'obtiens

-1.49012e-08 = 1 - 1

Plutôt étrange

Auriez-vous une idée sur le problème ?

[ZouBi]

c'est ça la magie des float
Bon, sans vouloir dire de connerie, il me semble qu'il est deconseillé de faire des calculs avec des flotants, car les resultats ne sont rarement exactes ( meme pour des calculs simples comme le tiens )

[babar63]

Comment on arrive à ce résultat je ne sais pas mais sachant que -1.49012e-08 = -0.00000000149012, cela doit surement correspondre à une marge d'erreur introduit par le calcul en flottant. En tout cas en effectuant cette opération :

Code :

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

float f = 1.f - 1.f;

j'obtiens bien 0

[Kerod]

Mon calcul ne se limite pas à 1.f mais à des variables que je récupère depuis un vecteur.

Sinon je suis bien obligé d'utiliser des réels sinon mes calculs ne seront pas corrects.

[Edit]
De plus j'ai essayé la solution du 1.f mais rien à faire toujours le même résultat

[JolyLoic]

Lire : http://cpp.developpez.com/faq/cpp/?p...ions_flottants

Ou pour un truc un peu (euphémisme) plus mathématique : http://docs.sun.com/source/806-3568/ncg_goldberg.html

Si ces infos ne suffisent pas, il faudra nous en dire plus sur le contexte de ces calculs pour qu'on puisse tenter de mieux t'aider...

Remarque : C'est un problème avec tous les langages informatiques qui soient...

[Kerod]

A vrai dire voilà une partie de mon code :

Code :

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

1
2
3
4
5
for(int j = 0; j < (2 * nbVar) + 1; j++)
        {
            float temp = valeur * tmp[0][j];
            matrice[i][j] = tmp[i][j] - temp;
        }

Avec tmp une matrice contenant tout mes float. valeur étant un float également. i un indice fixé par une précédente boucle for

Au final je dois remplir une autre matrice avec le résultat de ce calcul. Les imprécisions sont assez gênantes et j'ai pas trop de tests à faire dessus (en référence à ton premier lien).

C'est la première fois que je vois un tel problème et pourtant les langages j'en ai utilisé pas mal

faire ceci ne va pas me renvoyer un entier ? En tout cas c'est ce qui me semble et c'est pas ce que je veux

Code :

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

abs(f3 - 1.0f)

[babar63]

Pour ce qui est des autres langages je n'ai aucune idée mais par contre les matrices en float je n'utilise que ça à longueur de journée , je n'ai jamais eu réellement de problèmes avec les imprécisions, il me semble avoir vu seulement un cas d'analyse/traitement d'image qui posait problème avec ces imprécisions (boucle imbriquée à n'en plus finir avec des calculs monstrueux... ). Je ne pense pas avoir suffisamment d'expérience pour en dire plus mais ces imprécisions pose vraiment problèmes? Travailler avec des doubles ne réglerait pas le problème?

faire ceci ne va pas me renvoyer un entier ? En tout cas c'est ce qui me semble et c'est pas ce que je veux

abs retourne bien un entier, il faut utiliser la fonction fabs

[JolyLoic]

A vrai dire voilà une partie de mon code :

Plus que du code, c'est de contexte d'utilisation dont j'ai besoin. A quoi sert ce code ?
Si c'est pour faire de la simulation numérique de modèle physique, en quoi une imprécision de 10e-8 est-elle gênante (et si c'est le cas, pourquoi ne pas calculer en double ? Quand je vois float dans un programme, je me méfie) ?
Si c'est pour faire de la comptabilité, il ne faut pas utiliser les virgules flottantes, car ce domaine a ses propres règles d'arrondi (par pays ?) qu'on est tenu de préciser.
Si c'est pour faire des maths niveau collège, peut-être se faire une classe de nombre en base 10 est-elle la solution.
Si c'est pour faire des maths niveau recherche, peut-être une classe à précision infinie (ou du moins réglable) est-elle la solution.
Si c'est un problème d'affichage moche à l'écran, peut-être baisser la précision de l'affichage est la solution.
Si c'est pour faire...

C'est la première fois que je vois un tel problème et pourtant les langages j'en ai utilisé pas mal

Mais as-tu fait du calcul numérique avec ces langages ? Certains proposent des classes pour gérer des nombres à plus forte précision, au prix d'un temps de calcul qui s'écroule, mais ce n'est pas le mode classique.

faire ceci ne va pas me renvoyer un entier ? En tout cas c'est ce qui me semble et c'est pas ce que je veux

Code :

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

abs(f3 - 1.0f)

La différence de floats est un float. La valeur absolue d'un float est un float, donc non.

Si tu veux convertir en entier, par défaut, c'est un cast qu'il te faut :

Code :

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

int i = static_cast<int>(f3-1.0);

Mais encore une fois, sans comprendre la problématique, difficile d'en dire plus...

[Kerod]

Pour être beaucoup plus précis c'est pour le développement mathématique en programmation linéaire sur un simplex.

En gros je dois réaliser un simplex dans le langage que je veux. Vu comment fonctionne le simplex il faut que j'ai au moins une bonne précision. C'est à dire si c'est 0 alors c'est 0 et non un -0.0000......

Je vais déjà tenter avec les solutions énoncées et je vous tiens au courant

[Kerod]

Je viens d'essayer avec abs, rien à faire. Déjà il me transforme toutes mes valeurs négatives en positives et pour finir il ne m'affiche pas 0 à la place de la valeur avec exposant.

Je ne peux pas caster en entier car ce sont des réels que je dois obtenir.

Ce que j'aimerais bien faire c'est avoir ma valeur correct. Ce qui est plus bizarre c'est j'ai d'autres soustractions qui me donne zéro (0) et il y 3 petits rebelles qui font qu'à leur tête.

[Garulfo]

[...]mais ces imprécisions pose vraiment problèmes? Travailler avec des doubles ne réglerait pas le problème?[...]

Oui énormément.
Dans des domaines où la précision recherchée peut être très grande (en physique par exemple), les erreurs d'arrondis obtenus par les représentations des réelles est un vrai problème. Plus généralement, les erreurs d'arrondis sont une plaie incroyable. Il y a eu quelque « catastrophe » comme le Vancouver Stock Exchange Index Story. Grosso modo, à cause d'erreur d'arrondi quasiment indétectable de manière isolée, l'indice a chuté de l'indice 1000 en 1982 au environ de l'indice 500 en 84. Le problème c'est que ce calcul était du à un problème de programme... Après correction on s'est rendu compte qu'il n'aurait pas du être à 574 mais à 1098... imagines les impacts économiques. Dans le genre catastrophe au conséquence incalculable, tu as le Patriot en 91 qui, à cause d'erreurs d'arrondi cumulées, rate sa cible: un scud. Conclusion 28 morts. L'erreur était de .34s après 100h d'activité. Ça semble idiot, mais le scud parcourait 500m pendant ce laps de temps. Ce qui fait que le Patriot était incapable de le rattraper. Fait amusant si tu effectues les moyennes de 10000 nombres en les sommant dans des ordres différents (avec un algorithme simple linéaire classique), tu n'auras le résultat exact (au maximum des capacités d'un float que 25% du temps. Dingue non ? Il existe des algorithmes en n.log n qui améliore ça.

Comme tu peux le voir, c'est un problème fondamental. Travailler avec des doubles peut limiter le problème mais pas le supprimer: c'est dû à la représentation interne binaire. Tu as de la chance qu'en analyse d'image tu n'ai jamais eu le problème. Mes collègues en infographie ou en imagerie m'en parle régulièrement.

----

Au passage voici un autre article sérieux sur les problèmes reliés aux float: http://www.cs.berkeley.edu/~demmel/c...lecture21.html

[Jean-Marc.Bourguet]

Dans des domaines où la précision recherchée peut être très grande (en physique par exemple), les erreurs d'arrondis obtenus par les représentations des réelles est un vrai problème.

Il faudrait commencer par arreter d'utiliser "reels" pour designer les flottants :-)

Plus généralement, les erreurs d'arrondis sont une plaie incroyable.

Le plus incroyable c'est a quel point les gens sont ignorants des caracteristiques des flottants.

Fait amusant si tu effectues les moyennes de 10000 nombres en les sommant dans des ordres différents (avec un algorithme simple linéaire classique), tu n'auras le résultat exact (au maximum des capacités d'un float que 25% du temps. Dingue non ? Il existe des algorithmes en n.log n qui améliore ça.

Il y a surtout un algo en N qui donne le resultat exact (cad le flottant le plus proche de la somme exacte).

Comme tu peux le voir, c'est un problème fondamental. Travailler avec des doubles peut limiter le problème mais pas le supprimer: c'est dû à la représentation interne binaire.

Le probleme n'est pas du a une representation binaire mais a une representation finie. La representation binaire introduit un probleme supplementaire parce qu'elle est incapable de representer des nombres qui paraissent simples comme 0.1 et sur lesquels on ne s'attends pas a des problemes.

Au passage voici un autre article sérieux sur les problèmes reliés aux float: http://www.cs.berkeley.edu/~demmel/c...lecture21.html

Je laisse la reference.

[babar63]

Tu as de la chance qu'en analyse d'image tu n'ai jamais eu le problème. Mes collègues en infographie ou en imagerie m'en parle régulièrement

Non non je ne suis qu'un humble étudiant spécialisé dans la programmation graphique (simulation, temps réel et rendu) mais pas suffisamment poussé pour rencontrer encore ce genre de problème, j'ai seulement étudié l'analyse d'image mais sans plus c'est pour ça que j'ai dit :

Je ne pense pas avoir suffisamment d'expérience pour en dire plus

En tout cas merci pour ces précisions c'est toujours intéressant à savoir ...

Je viens d'essayer avec abs, rien à faire. Déjà il me transforme toutes mes valeurs négatives en positives et pour finir il ne m'affiche pas 0 à la place de la valeur avec exposant

La fonction abs travaille avec des entiers alors que fabs permet justement de travailler avec des flottants...

[corrector]

La fonction abs travaille avec des entiers alors que fabs permet justement de travailler avec des flottants...

Non, abs est surchargée en C++ :

In addition to the int versions of certain math functions in <cstdlib>, C++ adds long and long long overloaded
versions of these functions, with the same semantics.
8 The added signatures are:
long abs(long); // labs()
long long abs(long long); // llabs()
[...]
9 In addition to the double versions of the math functions in <cmath>, C++ adds float and long double overloaded
versions of these functions, with the same semantics.
10 The added signatures are:
float abs(float);
[...]
double abs(double); // fabs()
[...]
long double abs(long double);

C'est donc <cmath> et pas <cstdlib> qu'il faut inclure pour les fonctions abs sur les flottants. (Bien sûr on peut inclure les deux aussi.)

[smashy]

petite illustration des erreurs d arrondi

Code :

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

1
2
3
4
5
6
float a = 0.0f;
 
while (a != a + 1.0f){
 
  a = a + 1.0f;
}

--> Ce code n'est pas une boucle infinie !!!

[corrector]

Si tu veux convertir en entier, par défaut, c'est un cast qu'il te faut :

Code :

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

int i = static_cast<int>(f3-1.0);

Est-ce qu'on a souvent besoin de la partie entière d'un flottant?

D'autant plus que int(1.-epsilon) vaudra 0

[JolyLoic]

Non, probablement pas. Je lui indiquais juste comment faire si c'est vraiment ce qu'il voulait. D'autant plus que je ne vois pas quelle est la différence dans son problème entre -1.49012e-08 et 0, ni pourquoi des floats sont utilisés.
Et j'ai bien précisé par défaut, en opposition à par excès ou à par arrondi.

[ac_wingless]

Ces problèmes sont archi connus dans certains domaines (par exemple la géométrie numérique), et ignorés probablement à juste titre dans d'autres domaines.

Ce qu'on peut dire en résumé:
- cela n'a rien à voir avec un langage particulier, mais avec le stockage des données.
- il y a une littérature immense sur le sujet (cette discussion est bourrée de liens, et en les déroulant on doit couvrir des millions de pages. Voir aussi les liens d'une discussion passée). C'est un sujet fondamental et important!
- les solutions ne sont pas triviales: elles sont soit générales mais lourdes (GMP, NTL , etc.), soit fines et adaptables mais complexes à utiliser (CGAL), soit optimales mais étroites (Shewchuck).

Pour indication, les devis que nous faisons sur des problèmes industriels de ce type explosent à 1300 euros/j, à cause de l'énorme compétence nécessaire, et du fait qu'il n'y a toujours pas d'approche générale et systématique face aux problèmes industriels de ce genre (je parle de choses bien plus difficiles que celles listées ci-dessus).

En effet, tant qu'on s'autorise le changement de classe stockage au fur et à mesure qu'on accumule les opérations, on peut avoir une approche systématique. Par contre, lorsqu'on veut effectuer des opérations à stockage constant (par exemple lorsque les algorithmes sont itératifs) et garder la cohérence sur certaines propriétés géométriques, on se heurte à une difficulté fondamentale, et chaque problème doit être abordé différemment.

En ce qui me concerne, CGAL m'a "sauvé la peau" une fois, et je la recommande. C'est une librairie vivace et qui n'est pas fermée aux utilisations commerciales (via GeometryFactory).

[Kerod]

Bon je vais modifier tous mes float en double et voir ce que ça donne.

@JolyLoic : Concernant la différence entre -4.87645e-6 ou 4.6543e-6 et 0 c'est 0 est nulle. Je m'explique si j'ai une différence entre ne serait-ce que minime entre 0 et 4.6543e-6 alors ça fausse toute la résolution et surtout ça me donne une jolie boucle infinie alors qu'il devrait pas en avoir. Petit précision, si j'ai 0 j'arrête ma boucle et si supérieur à 0 je continue. J'espère que tu vois le problème. C'est pourquoi je veux obligatoirement avoir le 0 que je dois obtenir

Le coup du static_cast je vais également voir ce que ça donne. En gros je vous tiens au courant.

[corrector]

Bon je vais modifier tous mes float en double et voir ce que ça donne.

D'après ce que tu dis, ça ne va pas résoudre le problème.

@JolyLoic : Concernant la différence entre -4.87645e-6 ou 4.6543e-6 et 0 c'est 0 est nulle.

J'ai relu cette phrase plusieurs fois... difficile à comprendre.

Je m'explique si j'ai une différence entre ne serait-ce que minime entre 0 et 4.6543e-6 alors ça fausse toute la résolution

Peux-tu préciser STP?

et surtout ça me donne une jolie boucle infinie alors qu'il devrait pas en avoir. Petit précision, si j'ai 0 j'arrête ma boucle et si supérieur à 0 je continue. J'espère que tu vois le problème. C'est pourquoi je veux obligatoirement avoir le 0 que je dois obtenir

(Là c'est plus clair.)

Justement, ce que les différents intervenants de cette discussion essaient de t'expliquer, c'est que tu ne peux pas être sûr de tomber exactement sur 0, à cause des erreurs d'arrondis.