Egalité entre flottants

Bonjour,

Je me pose quelques questions sur les calculs et comparaisons de flottants et sur l'emploi de la macro :

Code:

---

#define FLOAT_EQ(_x, _y, _epsi) ((((_y) - (_epsi)) < (_x)) && ((_x) < ((_y) + (_epsi))))

---

avec _epsi généralement égal à à FLT_EPSILON qui est défini dans float.h :

Code:

---

#define FLT_EPSILON 1.192092896e-07F /* smallest such that 1.0+FLT_EPSILON != 1.0 */

---

Or, d'après moi, des que x devient un peu grand, le flottant x-FLT_EPSILON (resp x+FLT_EPSILON) est égal à x. Dans le code suivant, a==x

Code:

---

1 2 3

float x = 3; float a = x - FLT_EPSILON;

---

pourtant, quand on compare directement x - FLT_EPSILON et x, il sont bien differents :

Code:

---

1 2	bool eq1 = x - FLT_EPSILON < x;

---

et FLOAT_EQ(x, 3, FLT_EPSILON) vaut bien true.

J'ai ma petite idée sur la raison mais j'aimerais en être sûr.
Le c++ prévoit-il que tous les calculs et comparaisons de flottans (float, double,...) soient réalisés sur des réels (10 bytes) ou bien est-ce dû à l'implémentation de mon compilo(VC8)?

Et vous, comment testez vous l'égalité entre deux flottants?

Merci pour vos réponses

Hello,

Les égalités entres flottants, ça toujours été un sujet délicat.

Citation:

---

Envoyé par damiengif

Or, d'après moi, des que x devient un peu grand, le flottant x-FLT_EPSILON (resp x+FLT_EPSILON) est égal à x. Dans le code suivant, a==x

---

C'est "normal", plus le nombre est grand plus la précision diminue, pour tout nombre >= 2, x + FLT_EPSILON == x et x == x - FLT_EPSILON.

Il n'y à pas de solutions miracle, soit le comportement te convient, soit tu aggrandi epsilon (mais dans ce cas de petits nombres pourront être considérés comme égaux alors qu'ils ne le sont pas).

Note que la STL propose cet epsilon, pas besoin de le redéfinir.

Code:

---

std::numeric_limits<float>::epsilon();

---

FLT_EPSILON est l'écart entre 1 et la première valeur flottante suivante.
avec 3, la précision n'est déjà plus la même.

Plutôt que FLT_EPSILON, je suggère d'utiliser std::numeric_limits<float>::epsilon() (dans <limits>)

Regarde cette référence pour une explication et un exemple d'usage.

En gros, il faut multiplier l'epsilon par le plus grand des nombres à comparer. (et un petit détail de plus, regarde l'exemple)

Citation:

---

Envoyé par Iradrille

pour tout nombre >= 2, x + FLT_EPSILON == x et x == x - FLT_EPSILON.[/code]

---

Pas tout à fait :

Code:

---

1 2 3 4 5 6

float x = 3.; float y = x + std::numeric_limits<float>::epsilon(); bool eq1 = ( x == x + std::numeric_limits<float>::epsilon() ); // faux bool eq2 = ( x == y ); // vrai bool eq3 = ( y == x + std::numeric_limits<float>::epsilon() ); // faux

---

Bonjour,
Personnellement, je traite ce problème de la façon suivante:
Soit les valeurs traitées ont des dimensions homogènes, par exemple des données du type géographique, alors j'ai adopté le type long, c'est à dire que je dispose de 9 chiffres significatifs, et je me fixe une unité de base, 3 par exemple, et la position de la virgule est une donnée de ma base de données. Autrement dit, dans le cas général, je ne compare pas des flottants mais des entiers.
Il peut arriver que j'ai effectivement à comparer des flottants, alors, je compare la valeur absolue de leur différence avec un epsilon.
Il ne me viendrait pas à l'idée d'ajouter (ou de soustraire) un epsilon à un nombre dont un ne connait pas l'ordre de grandeur.