Puissance de 10 négative en python

by **Krit** » 12 Oct 2019, 18:42

Bonjour à tous,
quand j'exécute

print(35 * 10**-5)

en python, je trouve

0.00035000000000000005

Je suis perplexe.

by **critor** » 12 Oct 2019, 18:54

Bonjour.

Le Python ne travaille pas en base 10/décimale, et ne gère qu'un minuscule sous-ensemble des nombres réels.

Les nombres non entiers sont représentés en Python en virgule flottante binaire, soit au format suivant :

$mathjax$\pm M\times 2^{E-E_{min}}$mathjax$

avec

$mathjax$M\in [1;2[$mathjax$

La mantisse

M

est codée sur 53 bits

(plus 1 bit de signe)

.

Bref, quand on demande un calcul en Python il y a une double conversion derrière :

saisie décimale → virgule flottante binaire
puis le calcul est effectué en binaire
puis enfin résultat → décimal pour l'affichage

Il n'est pas rare donc que cela introduise des erreurs d'approximation sur les toutes dernières décimales.
Surtout quand il n'y a pas d'équivalent exact entre ces deux bases.

by **Krit** » 12 Oct 2019, 19:01

Merci Critor pour l'explication.
On est quand même loin d'un nombre fabuleusement grand ou petit.

by **critor** » 12 Oct 2019, 19:14

Ce n'est pas une histoire de grand petit.

La question pour la conversion d'une mantisse

M

telle que

$mathjax$M\in[1;2[$mathjax$

en binaire, c'est est-ce qu'il en existe développement binaire vérifiant

$mathjax$\sum\limits_{k=0}^{53}a_k\times2^{-k}=M$mathjax$

.

(ce qui prendrait 54 bits en fait, mais si je me souviens bien le

$mathjax$1\times 2^0=1$mathjax$

obligatoire n'est pas codé donc c'est bon)

by **critor** » 12 Oct 2019, 19:19

Prenons par exemple 11 en virgule flottante.
La plus grande puissance de 2 inférieure est

$mathjax$2^3=8$mathjax$

On écrit donc en virgule flottante binaire

$mathjax$11=1,375\times 2^3$mathjax$

Question, 1,375 dispose-t-il d'un développement binaire ?
Ici, la réponse est oui :

$mathjax$1,375=1+\frac{1}{4}+\frac{1}{8}$mathjax$

by **cent20** » 12 Oct 2019, 19:24

critor wrote:Bonjour.

Le Python ne travaille pas en base 10/décimale, et ne gère qu'un minuscule sous-ensemble des nombres réels.

Les nombres non entiers sont représentés en Python en virgule flottante binaire, soit au format suivant :
$mathjax$\pm M\times 2^{E-E_{min}}$mathjax$
avec
$mathjax$M\in [1;2[$mathjax$

La mantisse
M
est codée sur 53 bits
(plus 1 bit de signe)
.

Bref, quand on demande un calcul en Python il y a une double conversion derrière :
saisie décimale → virgule flottante binaire
puis le calcul est effectué en binaire
puis enfin résultat → décimal pour l'affichage
Il n'est pas rare donc que cela introduise des erreurs d'approximation sur les toutes dernières décimales.
Surtout quand il n'y a pas d'équivalent exact entre ces deux bases.

C'était l'info que je cherchais ... Je viens de finir mon DS de seconde et j'ai ajouté une question, en gros un 0.1+0.2 pour faire échouer les algorithmes qu'on a fait en classe et leur apprendre que la calculatrice ne sait pas tout et qu'elle se trompe... J'ai fabriqué mon exemple au hasard maintenant je sais comment m'y prendre (je devais trouver ça pdt les vacances...)

Merci