Fonction et nombre flottant déconseillé

Version imprimable

31/12/2020, 17h02
sam01

Fonction et nombre flottant déconseillé
Bonjour,

j'ai la fonction suivante :
Code:

1 2 3 4 5 6 def f(x,y,z): if x+y == z: return True else: return False
Apparemment, il est déconseillé d'utiliser des nombres flottants, mais je ne comprends a pourquoi car
les entiers sont autorisés, les chaînes de caractères aussi et aussi les listes.

merci d'avance pour votre aide.
31/12/2020, 17h25
lg_53

Dans votre terminal, tapez

Code:

0.1+0.1+0.1==0.3

Vous observerez que le résultat est False. Voilà pourquoi votre fonction, écrite comme elle est, n'est pas recommandée pour les flottants. C'est un exemple avec 3 termes, mais il en existe aussi avec 2 termes c'est certain, je n'en ai juste pas sous la main.

Donc ceci répond à votre question "pourquoi n'est ce pas conseillé pour les flottants". Maintenant ça vous amène forcément à une nouvelle question : pourquoi 0.1+0.1+0.1 n'est pas égal à 0.3 ? Ceci est dû à la représentation mémoire en binaire des nombres flottants. En tapant ces mots clés, vous allez trouvez plein de choses (il y en a sur ce site), dont des explications détaillées du célèbre exemple que je vous ai fourni.
31/12/2020, 18h49
sam01

Merci!
Du coup comment faudrait-il écrir la fonction pour que ce soit toujours vrai avec des nombres flottants ?
31/12/2020, 19h46
tyrtamos
Bonjour

L'erreur relative commise à cause du stockage des nombres flottants en mémoire est très faible, en général inférieure à 10e-15, c'est à dire 0.00000000000001.

Selon le programme, on peut donc se fixer une limite de précision acceptable.
Par exemple, remplacer la condition A==B par:

Code:

abs((A-B)/B)<10e-15

Exemple pour reprendre le cas :
Code:

1 2 print(0.1+0.1+0.1==0.3) False
On peut faire:
Code:

1 2 print(abs((0.3-(0.1+0.1+0.1))/0.3)<10e-15) True
Ceci dans le cas général, mais selon les nombres en question, on peut simplifier. Par exemple, si on est sûr que A est toujours supérieur à B, on peut se passer de abs(...). Toujours selon les cas, on peut comparer directement A-B à 10e-15. Etc...
31/12/2020, 21h16
sam01

Merci!
01/01/2021, 00h59
manzeki
Python stocke les nombres en virgule flottante sous forme de fraction en base 2
0.125 devient 1/10 + 2/100 + 5/1000
Ainsi la précision de pi est différente d'un sytème à un autre;

Avec les nombres en virgule flottante, on doit tenir compte de leur précision.
Cela n'a aucun sens de dire qu'ils sont déconseillés ou pas.
Tout est question de l'usage qu'on en fait
En général, on va les utiliser pour faire un calcul numérique qui demande une certaine précision.

Calculez
- La distance entre x+y et z
- Ou la valeur absolue de la différence
- Puis testez si elle est proche de 0
Code:

1 2 3 4 5 6 def f(x,y,z): e = 0.0000001; if math.sqrt( (x+y-z)**2 ) < e: return True else: return False

Bonjour

pour bien enfoncer le clou ... et "dédouaner" python.

Ce n'est pas inhérent à python mais à la représentation des réels en machine (selon la norme IEEE 754).

Le même "problème" en C en traduisant la fonction f présentée dans les posts précédents de deux façons :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
 
#define EPSILON 1e-15
 
int f_strict(double x, double y, double z)
{
    if ((x + y) == z)
        return 1;
    else
        return 0;
}
 
int f_epsilon(double x, double y, double z)
{
    if (fabs((x + y) - z) < EPSILON)    
        return 1;
    else
        return 0;
}
 
 
int main(int argc, char *argv[])
{
    double x = atof(argv[1]);   
    double y = atof(argv[2]);   
    double z = atof(argv[3]);   
 
 
    fprintf(stdout, "fonction f_strict : %d\n", f_strict(x, y, z));
    fprintf(stdout, "fonction f_epsilon: %d\n", f_epsilon(x, y, z));
}

à l'exécution (0 pour False, 1 pour True):

Code:

1
2
3
prompt> flottant.exe .1 .2 .3
fonction f_strict : 0
fonction f_epsilon: 1

01/01/2021, 10h17
danielhagnoul
Citation:

Envoyé par plxpy

Bonjour

pour bien enfoncer le clou ... et "dédouaner" python.

Ce n'est pas inhérent à python mais à la représentation des réels en machine (selon la norme IEEE 754).
Code:

1 2 3 # En Julia, on n'utile pas un égal mais un ≈ créé par \approx + TAB @show 0.1 + 0.1 + 0.1 ≈ 0.3 # 0.1 + 0.1 + 0.1 ≈ 0.3 = true
Le codage Julia du site DVP le traite mal, en PRE :
```
@show 0.1 + 0.1 + 0.1 ≈ 0.3 # 0.1 + 0.1 + 0.1 ≈ 0.3 = true
```
01/01/2021, 11h24
wiztricks
Citation:
Envoyé par danielhagnoul

Code:

1 2 3 # En Julia, on n'utile pas un égal mais un ≈ créé par \approx + TAB @show 0.1 + 0.1 + 0.1 ≈ 0.3 # 0.1 + 0.1 + 0.1 ≈ 0.3 = true

Le codage Julia du site DVP le traite mal, en PRE :

@show 0.1 + 0.1 + 0.1 ≈ 0.3 # 0.1 + 0.1 + 0.1 ≈ 0.3 = true
Ça veut juste dire que Julia introduit une fonction "almost equal" qui peut s'écrire ≈.
La fonction Python équivalente est math.isclose mais il n'y a pas d'équivalent syntaxique à ≈.

Mais çà ne change rien au problème de départ, si on écrit:
Code:

1 2 3 4 5 def f(x,y,z): if x+y == z: return True else: return False
on ne sait pas plus tester l'égalité pour des nombres flottants....
Si on veut que cette fonction s'applique aussi à ces nombres là, il va falloir tester le type des arguments et appliquer l'opérateur qui va bien.

- W