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

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

0
ajouté édité
Vues: 27
vous avez vraiment besoin de cela après 10 ans impair? lol
ajouté l'auteur L_Church, source
pourquoi après 10 ans y a-t-il une prime? il y a déjà beaucoup de réponses. Y at-il quelque chose qui me manque ici?
ajouté l'auteur Puddle, source
par exemple. Math.Floor (5.4) = 5 Math.Truncate (5.4) = 5
ajouté l'auteur subramani, source

8 Réponses

Math.Floor rounds down, Math.Ceiling rounds up, and Math.Truncate rounds towards zero. Thus, Math.Truncate is like Math.Floor for positive numbers, and like Math.Ceiling for negative numbers. Here's the reference.

For completeness, Math.Round rounds to the nearest integer. If the number is exactly midway between two integers, then it rounds towards the even one. Reference.

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

0
ajouté
Qu'est-ce que (int) equal à dans la classe Math?
ajouté l'auteur Lei Yang, source
Quand est-ce que (int) myDouble diffère de (int) Math.Truncate (myDouble) ?
ajouté l'auteur mpen, source
@Chris, je vous suggère de corriger votre description de Round, il y a deux façons d'arrondir (AwayFromZero et ToEven) et elle ne tourne pas au entier le plus proche car elle peut aussi faire des arrondis fractionnaires.
ajouté l'auteur paxdiablo, source
Donc, juste un petit ajout à la question d'origine - quelle est la différence entre Math.Truncate et juste de couler une décimale ou double à int? ne serait-ce pas aussi juste vers zéro?
ajouté l'auteur Noam Gal, source

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
0
ajouté

Suivez ces liens pour les descriptions MSDN de:

  • Math.Floor, which rounds down towards negative infinity.
  • Math.Ceiling, which rounds up towards positive infinity.
  • Math.Truncate, which rounds up or down towards zero.
  • Math.Round, which rounds to the nearest integer or specified number of decimal places. You can specify the behavior if it's exactly equidistant between two possibilities, such as rounding so that the final digit is even ("Round(2.5,MidpointRounding.ToEven)" becoming 2) or so that it's further away from zero ("Round(2.5,MidpointRounding.AwayFromZero)" becoming 3).

Le diagramme et la table suivants peuvent 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 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 à 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 / 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
0
ajouté
Merci, @dtroy, je n'ai jamais eu besoin d'utiliser ce mode et, bien que je l'ai documenté correctement si le texte, j'ai totalement mal compris les exemples. J'espère que c'est corrigé maintenant.
ajouté l'auteur paxdiablo, source
@Richiban, pensez à even comme une propriété du chiffre final dans le nombre arrondi, pas comme si le nombre entier doit être un multiple de deux. Soit dit en passant, désolé, il a fallu si longtemps pour vous revenir, j'espère que vous n'étiez pas simplement assis en train d'attendre ma réponse :-)
ajouté l'auteur paxdiablo, source
Pax, je pense que vous avez une erreur avec: Round (AwayFromZero) -3 -2 1 2 3 Math.Round (-1,2, MidpointRounding.AwayFromZero) == -1 Math.Round (0,3, MidpointRounding.AwayFromZero) == 0.0 etc.
ajouté l'auteur dtroy, source
Désolé de commenter une question aussi ancienne mais je dois demander: Comment pouvez-vous arrondir "ToEven" à deux décimales? Sûrement étrange et même ne s'applique qu'aux entiers?
ajouté l'auteur Richiban, source

Math.Floor() rounds toward negative infinity

Math.Truncate rounds up or down towards zero.

Par exemple:

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

tandis que

Math.Floor(3.4)     = 3
Math.Truncate(3.4)  = 3
0
ajouté

Math.floor sliiiide to the left...
Math.ceil sliiiide to the right...
Math.truncate criiiiss crooooss (floor/ceil always towards 0)
Math.round cha cha, real smooth... (go to closest side)

Allons au travail! (?? _?)

To the left... Math.floor
Take it back now y'all... --
Two hops this time... -=2

Tout le monde tape des mains?

Jusqu'où peux-tu aller? Pouvez-vous descendre bas? Jusqu'au floor ?

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

Math.truncate(x) is also the same as int(x).
by removing a positive or negative fraction, you're always heading towards 0.

0
ajouté

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(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 addition 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
0
ajouté

Math.Floor(): Returns the largest integer less than or equal to the specified double-precision floating-point number.

Math.Round(): Rounds a value to the nearest integer or to the specified number of fractional digits.

0
ajouté
L'OP a posé une question sur la différence entre Floor() et Truncate() , pas Floor() et Round() </ code >.
ajouté l'auteur Robert Columbia, source

Ils sont fonctionnellement équivalents avec des nombres positifs. La différence réside dans la manière 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

MSDN links: - Math.Floor Method - Math.Truncate Method

P.S. Méfiez-vous de Math.Round il ne peut pas être 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
0
ajouté