Différence entre les Mathématiques.Floor() et Math.Tronquer()

Math.Floor tours", 151910920" tours de, et les Math.Truncate tours vers zéro. Ainsi, Math.Truncate est comme Math.Floor pour les nombres positifs, et comme Math.Ceiling pour les nombres négatifs. Voici le référence .

pour être complet, Math.Round arrondit à l'entier le plus proche. Si le nombre est exactement à mi-chemin entre deux entiers, alors il arrondit vers le même. référence.

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

suivez ces liens pour les descriptions MSDN de:

• Math.Floor , qui se dirige vers l'infini négatif.
• Math.Ceiling , qui s'approche de l'infini positif.
• Math.Truncate , qui tourne vers le haut ou vers le bas vers zéro.
• Math.Round , qui arrondit au nombre 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 l'arrondi 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 être utiles:

-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 Round est beaucoup plus puissant qu'il n'y paraît, tout simplement parce qu'il peut arrondir à un nombre de décimales. Tous les autres autour de zéro décimales toujours. 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() tours vers l'infini négatif

Math.Truncate s'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

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

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: - "151970920 des Mathématiques".Méthode Du Plancher - "151990920 des Mathématiques".Méthode Tronquée

P. S. Méfiez-vous des Maths.Autour de lui il ne peut pas être ce que vous attendez.

pour obtenir le résultat d'arrondissement" standard "utiliser:

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

Math.Floor() visites "toward negative infinity "en conformité avec IEEE Standard 754 section 4.

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

math.floor()

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

MSDN system.mathématique.plancher

math.truncate()

calcule la partie intégrante d'un nombre.

MSDN system.mathématique.tronqué

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

In outre "1519250920 des Mathématiques".Rond ()

   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 nombre entier inférieur ou égal au nombre de virgule flottante de double précision spécifié.

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

Math.floor sliiiide à gauche...

Math.ceil sliiiide à droite...

Math.truncate criiiiss crooooss (plancher/plafond toujours vers 0)

Math.round cha cha, très fluide... (aller au côté le plus proche)

au travail!

à gauche... Math.floor

Le reprendre maintenant, y'all... --

Deux sauts cette fois... -=2

tout le monde tape des mains

jusqu'où peut-on aller? Pouvez-vous descendre plus bas? Jusqu'au floor ?

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

Math.truncate(x) est aussi le même que int(x) .

en enlevant une fraction positive ou négative, vous vous dirigez toujours vers 0.

Mat.floor() sera toujours arrondi à l'inférieur ie., il renvoie un nombre entier inférieur. Tandis que round() retournera l'entier le plus proche