Différence entre Math.Floor () et Math.Truncate ()

Quelle est la différence entre Math.Floor()et Math.Truncate()dans .NET?

Math.Floorarrondit vers le bas, Math.Ceilingarrondit vers le haut et Math.Truncatearrondit vers zéro. Ainsi, Math.Truncatec'est comme Math.Floorpour les nombres positifs et comme Math.Ceilingpour les nombres négatifs. Voici la référence .

Pour être complet, Math.Roundarrondit à l'entier le plus proche. Si le nombre est exactement à mi-chemin entre deux nombres entiers, alors il arrondit vers le pair. Référence.

Voir aussi: la réponse de Pax Diablo . Hautement recommandé!

Suivez ces liens pour les descriptions MSDN de:

• Math.Floor, qui arrondit vers l'infini négatif.
• Math.Ceiling, qui arrondit vers l'infini positif.
• Math.Truncate, qui arrondit vers le haut ou vers le bas vers zéro.
• Math.Round, qui arrondit à l'entier le plus proche ou au nombre spécifié de décimales. Vous pouvez spécifier le comportement s'il est exactement à égale distance entre deux possibilités, telles que l'arrondi de sorte que le dernier chiffre soit pair (" Round(2.5,MidpointRounding.ToEven)" devenant 2) ou qu'il soit plus éloigné de zéro (" Round(2.5,MidpointRounding.AwayFromZero)" devenant 3).

Le diagramme et le tableau suivants peuvent vous aider:

-3        -2        -1         0         1         2         3
 +--|------+---------+----|----+--|------+----|----+-------|-+
    a                     b       c           d            e

                       a=-2.7  b=-0.5  c=0.3  d=1.5  e=2.8
                       ======  ======  =====  =====  =====
Floor                    -3      -1      0      1      2
Ceiling                  -2       0      1      2      3
Truncate                 -2       0      0      1      2
Round (ToEven)           -3       0      0      2      3
Round (AwayFromZero)     -3      -1      0      2      3

Notez que Roundc'est beaucoup plus puissant qu'il n'y paraît, simplement parce qu'il peut arrondir à un nombre spécifique de décimales. Tous les autres arrondissent toujours à zéro décimale. Par exemple:

n = 3.145;
a = System.Math.Round (n, 2, MidpointRounding.ToEven);       // 3.14
b = System.Math.Round (n, 2, MidpointRounding.AwayFromZero); // 3.15

Avec les autres fonctions, vous devez utiliser la supercherie multiplier / diviser pour obtenir le même effet:

c = System.Math.Truncate (n * 100) / 100;                    // 3.14
d = System.Math.Ceiling (n * 100) / 100;                     // 3.15

Math.Floor() arrondit vers l'infini négatif

Math.Truncate arrondit vers le haut ou vers le bas vers zéro.

Par exemple:

Math.Floor(-3.4)     = -4
Math.Truncate(-3.4)  = -3

tandis que

Math.Floor(3.4)     = 3
Math.Truncate(3.4)  = 3

Quelques exemples:

Round(1.5) = 2
Round(2.5) = 2
Round(1.5, MidpointRounding.AwayFromZero) = 2
Round(2.5, MidpointRounding.AwayFromZero) = 3
Round(1.55, 1) = 1.6
Round(1.65, 1) = 1.6
Round(1.55, 1, MidpointRounding.AwayFromZero) = 1.6
Round(1.65, 1, MidpointRounding.AwayFromZero) = 1.7

Truncate(2.10) = 2
Truncate(2.00) = 2
Truncate(1.90) = 1
Truncate(1.80) = 1

Math.floorsliiiide à gauche ...
Math.ceilsliiiide à droite ...
Math.truncatecriiiiss crooooss (plancher / plafond toujours vers 0)
Math.roundcha cha, très lisse ... (aller du côté le plus proche)

Allons au travail! (⌐ □ _ □)

À gauche ... Math.floor
Reprenez maintenant, vous tous ... --
Deux sauts cette fois ...-=2

Tout le monde frappe des mains ✋✋

Jusqu'où pouvez-vous descendre? Pouvez-vous descendre bas? Jusqu'au floor?

if (this == "wrong")
    return "i don't wanna be right";

Math.truncate(x)est également le même que int(x).
en supprimant une fraction positive ou négative, vous vous dirigez toujours vers 0.

Ils sont fonctionnellement équivalents avec des nombres positifs. La différence réside dans la façon dont ils traitent les nombres négatifs.

Par exemple:

Math.Floor(2.5) = 2
Math.Truncate(2.5) = 2

Math.Floor(-2.5) = -3
Math.Truncate(-2.5) = -2

Liens MSDN: - Méthode Math.Floor - Math.Floor Méthode Math.Truncate

PS Méfiez-vous des mathématiques, mais ce n'est peut-être pas ce que vous attendez.

Pour obtenir le résultat d'arrondi "standard", utilisez:

float myFloat = 4.5;
Console.WriteLine( Math.Round(myFloat) ); // writes 4
Console.WriteLine( Math.Round(myFloat, 0, MidpointRounding.AwayFromZero) ) //writes 5
Console.WriteLine( myFloat.ToString("F0") ); // writes 5

Essayez ceci, Exemples:

Math.Floor () vs Math.Truncate ()

Math.Floor(2.56) = 2
Math.Floor(3.22) = 3
Math.Floor(-2.56) = -3
Math.Floor(-3.26) = -4

Math.Truncate(2.56) = 2
Math.Truncate(2.00) = 2
Math.Truncate(1.20) = 1
Math.Truncate(-3.26) = -3
Math.Truncate(-3.96) = -3

Aussi Math.Round ()

   Math.Round(1.6) = 2
   Math.Round(-8.56) = -9
   Math.Round(8.16) = 8
   Math.Round(8.50) = 8
   Math.Round(8.51) = 9

math.floor()

Renvoie le plus grand entier inférieur ou égal au nombre spécifié. MSDN system.math.floor

math.truncate()

Calcule la partie intégrale d'un nombre. MSDN system.math.truncate

Math.Floor()arrondit "vers l'infini négatif" conformément à la section 4 de la norme IEEE 754 .

Math.Truncate() arrondit "à l'entier le plus proche vers zéro".

Math.Floor(): Renvoie le plus grand entier inférieur ou égal au nombre à virgule flottante double précision spécifié.

Math.Round(): Arrondit une valeur à l'entier le plus proche ou au nombre spécifié de chiffres fractionnaires.

Math.floor()sera toujours arrondi vers le bas, c'est-à-dire qu'il renvoie moins d'entier. While round()renverra l'entier NEAREST

math.floor ()

Renvoie le plus grand entier inférieur ou égal au nombre spécifié.

math.truncate ()

Calcule la partie intégrale d'un nombre.

Tronquer laisse tomber la décimale ****