Arrondir les types à virgule flottante

1. Introduction

Dans la vraie vie, c’est rare qu’on paie de l’argent avec une précision de cent trillionièmes d’euro, ou qu’on mesure une pièce au centième de millimètre près. En programmation, c’est pareil : les résultats avec double ou float sont souvent “trop à virgule”.

Voilà un problème classique :

double result = 10.0 / 3.0;
Console.WriteLine(result); // 3.3333333333333335

Mais si on veut afficher ce nombre, par exemple, avec seulement deux chiffres après la virgule (pour ne pas “effrayer” l’utilisateur) ? C’est là qu’on a besoin d’arrondir.

2. Les méthodes principales d’arrondi en C#

C# propose plusieurs façons d’arrondir un nombre à virgule flottante. Et c’est là que ça devient fun : il y a plusieurs types d’arrondi ! On va voir les options principales et piger la différence.

1) La fonction Math.Round — l’arrondi classique

La méthode la plus populaire, c’est Math.Round. Elle arrondit le nombre à l’entier le plus proche (ou au nombre de décimales que tu veux).

Math.Round(nombre[, nb_chiffres[, MidpointRounding]])

• nombre — ce qu’on arrondit.
• nb_chiffres — combien de décimales garder (par défaut 0, donc à l’entier).
• MidpointRounding — la méthode d’arrondi des moitiés (on en parle juste après).

Exemples :

double x = 2.71828;

Console.WriteLine(Math.Round(x));         // 3
Console.WriteLine(Math.Round(x, 2));      // 2.72
Console.WriteLine(Math.Round(x, 3));      // 2.718

Visualisation :

Type du résultat :
Toutes les fonctions de cette leçon renvoient un double, donc si tu veux stocker le résultat de l’arrondi, tu peux avoir une erreur :

double result = 10.0 / 5.0;     // Résultat 2.0
int x = Math.Round(x);          // Erreur ! Impossible d’assigner un double à une variable int comme ça

Si tu veux mettre un double dans une variable int, il faut caster explicitement :

double result = 10.0 / 5.0;     // Résultat 2.0
int x = (int) Math.Round(x);    // Là, ça marche nickel !

2) Arrondir vers le haut ou vers le bas

C# ne fait pas que l’arrondi “classique”, il permet aussi d’arrondir de force vers le haut ou le bas.

Arrondi vers le bas (Math.Floor)

La méthode Math.Floor “coupe” juste la partie décimale (vers moins l’infini). Donc ça arrondit toujours vers le bas !

Console.WriteLine(Math.Floor(2.99));   // 2
Console.WriteLine(Math.Floor(-2.99));  // -3

Arrondi vers le haut (Math.Ceiling)

La méthode Math.Ceiling — c’est l’opposé de Floor : ça arrondit toujours vers le haut (vers plus l’infini).

Console.WriteLine(Math.Ceiling(2.01));   // 3
Console.WriteLine(Math.Ceiling(-2.01));  // -2

Schéma comparatif :

3) Truncate : juste couper la partie décimale

La méthode Math.Truncate — c’est le “chirurgien tranquille”. Elle enlève juste la partie décimale, sans se soucier de la correction mathématique de l’arrondi. Si x est positif — même résultat que Floor, si négatif — comme Ceiling.

Console.WriteLine(Math.Truncate(2.99));   // 2
Console.WriteLine(Math.Truncate(-2.99));  // -2

3. Comment fonctionne Math.Round pour les “moitiés” ? (MidpointRounding)

Imagine : tu as 2.5. Tu dois arrondir — mais vers où ? C’est pile entre 2 et 3. En maths, il y a deux approches populaires :

• Arrondir vers le haut (“au plus proche supérieur”)
• Arrondir vers le pair le plus proche (Banker's rounding)

C# utilise par défaut la deuxième méthode — arrondi vers le pair le plus proche (“banker's rounding”, ou “arrondi vers le pair”).

Console.WriteLine(Math.Round(2.5)); // 2
Console.WriteLine(Math.Round(3.5)); // 4

Pourquoi ? Parce qu’entre deux entiers équidistants, le pair “gagne”. C’est fait pour éviter une erreur systématique vers le haut ou le bas quand on fait plein d’arrondis. Super important, par exemple, pour les gros montants d’argent à la banque (d’où le nom).

Si tu veux toujours arrondir vers le haut, tu peux préciser le mode :

// Toujours arrondir "loin de zéro"
Console.WriteLine(Math.Round(2.5, 0, MidpointRounding.AwayFromZero)); // 3
Console.WriteLine(Math.Round(-2.5, 0, MidpointRounding.AwayFromZero)); // -3

Tableau des modes MidpointRounding :

4. Arrondir au nombre de décimales voulu : attention aux "huit" et aux "trois" !

Parfois, il faut arrondir non pas à l’entier, mais à deux décimales (genre pour afficher des sous ou des pourcentages).

double price = 149.9999;
double roundedPrice = Math.Round(price, 2);
Console.WriteLine(roundedPrice); // 150

Et si on veut juste “couper” les décimales en trop, sans arrondir ? Par exemple, transformer 123.4567 en 123.45.

On peut faire ça avec une petite astuce :

double num = 123.4567;
double result = Math.Floor(num * 100) / 100;
Console.WriteLine(result); // 123.45

On “décale” la virgule à la main, on coupe la partie décimale, puis on remet la virgule.

5. Formatage de l’affichage vs arrondi

Voilà un exemple où la différence peut être critique :

double value = 2.555;
Console.WriteLine($"{value:F2}"); // 2.56
Console.WriteLine(Math.Round(value, 2)); // 2.56

double stored = Math.Round(value, 2);
Console.WriteLine(stored); // 2.56

// Mais si tu affiches juste sans arrondir, mais avec un format...
Console.WriteLine($"{value:F2}"); // 2.56, mais en mémoire — 2.555

6. Erreurs classiques et subtilités

• N’utilise pas l’arrondi pour des calculs financiers précis avec double ! Pour l’argent, en .NET il y a le type spécial decimal — il ne “joue pas” avec la virgule flottante (plus de détails dans une prochaine leçon).
• Les fameuses “huit qui traînent” : à cause du stockage binaire, certains nombres ne s’arrondissent pas “logiquement” à l’œil. Par exemple, 0.1 + 0.2 n’est pas forcément 0.3.
• Ne confonds pas Math.Floor et Math.Round ! Le premier c’est toujours vers le bas, le second — comme le veut la mathématique.
• Accumulation incontrôlée d’erreur : si tu arrondis souvent les résultats en cours de calcul (genre dans une boucle), la valeur finale peut “dériver” sans prévenir. En général, mieux vaut arrondir seulement le résultat final, pas toutes les étapes intermédiaires.

7. Tableau final : qui fait quoi ?

8. Fun facts

• Un jour, la NASA a perdu une sonde spatiale à cause d’un arrondi pas strict des coordonnées et d’une confusion entre unités métriques/impériales. Moralité : arrondis avec conscience !
• Les banques sont passées depuis longtemps au “banker's rounding” pour ne pas perdre de centimes — avant, tout le monde arrondissait vers le haut, et les clients perdaient des fractions de cent à chaque virement.
• En C#, il y a même la méthode Math.Sign, qui renvoie le signe d’un nombre — parfois utile avant d’arrondir, pour choisir toi-même de quel côté “couper”.

2

Mission

C# SELF, niveau 6, leçon 4

Bloqué

Arrondir à un nombre de décimales donné

Arrondir à un nombre de décimales donné

Ouvrir

2

Mission

C# SELF, niveau 6, leçon 4

Bloqué

Utilisation de différentes méthodes d'arrondi

Utilisation de différentes méthodes d'arrondi

Ouvrir