Discussion :

[damiengif]

Bonjour,

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

Code :

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

#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 :

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

#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 :

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

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 :

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

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

[Iradrille]

Hello,

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

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 :

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

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

[damiengif]

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

Pas tout à fait :

Code :

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

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

[Invité]

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.

[ternel]

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)