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

Question

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

Answer 1

Math.Floor arrondit vers le bas, Math.Ceiling arrondit, et Math.Truncate arrondit vers zéro.Ainsi, Math.Truncate est comme Math.Floor pour les nombres positifs, et comme Math.Ceiling pour les nombres négatifs.Ici se trouve le référence.

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

Voir également: La réponse de Pax Diablo.Hautement recommandé!

Answer 2

Suivez ces liens pour les descriptions MSDN de :

• Math.Floor, qui arrondit vers moins l’infini.
• 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 équidistant entre deux possibilités, comme arrondir pour que le chiffre final soit pair ("Round(2.5,MidpointRounding.ToEven)" devenant 2) ou pour 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

Noter que Round 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 de la multiplication/division pour obtenir le même effet :

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

Answer 3

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

alors que

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

Answer 4

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

Answer 5

Ils sont fonctionnellement équivalents avec des nombres positifs.La différence réside dans la façon dont ils gèrent 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 - Méthode Math.Truncate

P.S.Méfiez-vous de Math.Round, ce n'est peut-être pas ce à quoi vous 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

Answer 6

Math.Floor() tourne "vers l'infini négatif" en conformité Norme IEEE 754 Section 4.

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

Answer 7

math.floor()

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

MSDN système.math.floor

math.truncate()

Calcule la partie entière d'un nombre.

MSDN système.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

En outre 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

Answer 8

Math.floor glissez vers la gauche...
Math.ceil glissez vers la droite...
Math.truncate criiiiss crooooss (sol/plafond toujours vers 0)
Math.round cha cha, vraiment doux...(aller du côté le plus proche)

Allons au travail!(⌐□_□)

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

Tout le monde applaudit ✋✋

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.

Answer 9

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.

Answer 10

Mat.floor() sera toujours arrondi à l'inférieur, c'est-à-dire qu'il renvoie un entier MOINDRE.Alors que round() renverra l'entier LE PLUS PROCHE