1.1 Arrondissement des nombres flottants
Les nombres flottants (fractionnaires) en anglais s'appellent floating point number – des nombres à virgule flottante : aux États-Unis, un point est utilisé pour séparer la partie entière de la partie fractionnaire du nombre. D'où le nom float.
Comme nous l'avons déjà vu, lors de la conversion d'un nombre flottant (float) en entier (int), il est toujours arrondi vers le bas jusqu'à l'entier - sa partie fractionnaire est simplement supprimée. Pourtant, il est facile d'imaginer une situation où un nombre fractionnaire doit être arrondi simplement à l'entier le plus proche, ou même vers le haut. Que faire ?
Pour ce cas, JavaScript a une fonction intégrée round(). Elle a été inventée avant la création de la bibliothèque Math, elle n'en fait donc pas partie. Les fonctions pour arrondir vers le bas et vers le haut se trouvent dans la bibliothèque math.
Fonction Math.round()
La fonction Math.round() arrondit un nombre à l'entier le plus proche :
Math.round(nombre_flottant)
Cette fonction renverra l'entier le plus proche du nombre flottant passé en paramètre.
Exemples :
| Commande | Résultat |
|---|---|
let x = Math.round(4.1); |
4 |
let x = Math.round(4.5); |
5 |
let x = Math.round(4.9); |
5 |
Fonction Math.ceil()
La fonction Math.ceil() arrondit un nombre à l'entier supérieur :
| Commande | Résultat |
|---|---|
let x = Math.ceil(4.1); |
5 |
let x = Math.ceil(4.5); |
5 |
let x = Math.ceil(4.9); |
5 |
Fonction Math.floor()
La fonction Math.floor() arrondit un nombre à l'entier inférieur :
| Commande | Résultat |
|---|---|
let x = Math.floor(4.1); |
4 |
let x = Math.floor(4.5); |
4 |
let x = Math.floor(4.9); |
4 |
Si vous avez du mal à retenir ces commandes, une petite leçon d'anglais peut vous aider :
- math — mathématiques
- round — cercle/arrondir
- ceiling — plafond
- floor — sol
1.2 Structure des nombres à virgule flottante
Le type number en JavaScript peut stocker des valeurs dans la plage de -1.7*10308 à +1.7*10308. Un tel éventail gigantesque de valeurs s'explique par le fait que le type number est structuré tout à fait différemment des types entiers. Chaque variable de type number contient deux nombres : le premier est appelé mantisse, et le second exposant.
Supposons que nous ayons le nombre 123456789, et que nous l'avons enregistré dans une variable de type number. Le nombre sera alors converti sous la forme 1.23456789*108, et dans le type number, les nombres 1.23456789 et 8 seront stockés. En rouge, la « partie significative du nombre » (mantisse), en bleu - l'exposant.
Cette approche permet de stocker à la fois des nombres très grands et très petits. Mais puisque la taille du nombre est limitée à 8 octets (64 bits) et qu'une partie de ces bits est utilisée pour stocker l'exposant (ainsi que le signe du nombre et le signe de l'exposant), la longueur maximale de la mantisse est limitée à 15 chiffres.
Ceci est une description très simplifiée de la structure des nombres flottants : une description plus complète peut être trouvée en suivant ce lien.
1.3 Perte de précision lors du traitement des nombres flottants
Lors du traitement des nombres flottants, il faut toujours garder à l'esprit que les nombres flottants sont imprécis. Il y aura toujours des erreurs d'arrondi, des erreurs de conversion du système décimal au binaire et enfin, le plus souvent, une perte de précision lors de l'addition/soustraction de nombres de tailles très différentes.
Ce dernier cas est la situation la plus inattendue pour les débutants en programmation.
Si vous soustrayez 1/109 du nombre 109, vous obtiendrez à nouveau 109.
| Soustraction de nombres de tailles très différentes | Explication |
|---|---|
| 1000000000.000000000 - 0.000000001 1000000000.000000000 |
Le deuxième nombre est trop petit et sa partie significative est ignorée (en gris). En rouge, 15 chiffres significatifs. |
Que dire de plus, la programmation ce n’est pas des maths.
1.4 Danger de comparer des nombres flottants
Un autre danger guette les programmeurs lors de la comparaison de nombres flottants. Comme des erreurs d'arrondi peuvent s'accumuler lors du traitement de ces nombres, il est possible que des nombres flottants censés être égaux ne le soient pas. Et inversement : des nombres censés ne pas être égaux le sont.
Exemple :
| Commande | Explication |
|---|---|
let a = 1000000000.0let b = 0.000000001let c = a – b |
La variable a contiendra la valeur 1000000000.0.La variable c contiendra la valeur 1000000000.0(le nombre de la variable b est trop petit). |
Dans l'exemple ci-dessus, a et c ne devraient pas être égaux, mais ils le sont.
Ou prenons un autre exemple :
| Commande | Explication |
|---|---|
let a = 1.00000000000000001let b = 1.00000000000000002 |
La variable a contiendra la valeur 1.0.La variable b contiendra la valeur 1.0. |
En pratique, les nombres flottants sont comparés de cette façon :
Si la différence entre les nombres (en valeur absolue) est inférieure à un très petit nombre, ils sont considérés comme égaux.
Exemple :
let a = 0.00000000012;
let b = 0.000000000011;
if (Math.abs(a - b) < 0.00001) {
console.log("égaux");
} else {
console.log("pas égaux");
}
GO TO FULL VERSION