Nombres réels et erreurs d'arrondi

Les nombres flottants (réels)

Attention

Le problème de base est de pouvoir représenter une infinité de nombres, les nombres réels, avec une notation binaire sur un nombre de bits fini (32 bits ou 64 bits en général), les nombres à virgule.

Faire rentrer un ensemble infini dans un ensemble fini mène nécessairement à des approximations.

Les erreurs d’arrondi

Les erreurs d’arrondi sont un phénomène courant en programmation. Elles surviennent principalement en raison de la manière dont les nombres à virgule sont représentés en mémoire. Voici une explication détaillée :

Représentation des nombres à virgule :
- En Python, et dans tous les langages de programmation, les nombres flottants sont représentés en binaire (série de 1 et de 0).
- Certains nombres décimaux ne peuvent pas être représentés exactement en binaire, ce qui entraîne des approximations.
Exemple d’erreur d’arrondi :
- Considérez l’exemple suivant :
```
print(0.1 + 0.2)
```
- On pourrait s’attendre à ce que le résultat soit 0.3, mais en réalité, il affiche quelque chose comme 0.30000000000000004. Cela est dû à l’approximation binaire de 0.1 et 0.2.
Conséquences des erreurs d’arrondi :
- Les erreurs d’arrondi peuvent entraîner des résultats inattendus dans les calculs, surtout lorsqu’ils sont accumulés sur de nombreuses opérations.
- Elles peuvent également poser des problèmes dans les comparaisons de flottants. Par exemple :
```
# Est-ce que 0.1 + 0.2 est égal à 0.3?
print(0.1 + 0.2 == 0.3)   # Affiche False (faux)
```

Technique simple pour gérer les erreurs d’arrondi

Utiliser la fonction round() :

Vous pouvez utiliser la fonction round() pour arrondir les nombres à un certain nombre de décimales.

print(round(0.1 + 0.2, 1))  # Affiche 0.3

Note

La bibliothèque NumPy fourni d’autres méthodes permettant de contrer les erreurs d’arrondi avec les nombres flottants. Nous les verrons lors du cours de la semaine 13.

Notation scientifique

On peut écrire des nombres très grands ou très petits avec des puissances de 10 en utilisant le symbole e :

nombre1 = 1e6 # 1000000.0
nombre2 = 3.12e-3 # 0.00312

Attention

En Python, c’est le point qui est utilisé comme séparateur décimal. Ainsi, 3.14 est un nombre reconnu comme un flottant (réel), alors que 3,14 ne l’est pas.

Comment tester les floats

Évitez la comparaison directe : Ne comparez pas directement deux floats avec == car cela peut échouer à cause des petites erreurs.
```
a = 0.1 + 0.2
print(a == 0.3)  # Cela peut retourner False
```

Utilisez une tolérance : Vérifiez si les nombres sont “assez proches” en utilisant une tolérance.

# On importe le paquet des fonctions mathématiques
import math

a = 0.1 + 0.2
b = 0.3
print(math.isclose(a, b, rel_tol=1e-9))  # Cela retourne True

Explication:

Voici comment cela fonctionne :

a et b : Les deux valeurs que vous comparez.
rel_tol : La tolérance relative, qui est le maximum de différence autorisée entre a et b, relative à la magnitude des valeurs. Par défaut, cette tolérance est de 1e-9.