.net - personnage - netmath vf




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

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


Essayez ceci, Exemples:

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 plus 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


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

PS Méfiez-vous des mathématiques. 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

Suivez ces liens pour les descriptions MSDN de:

  • Math.Floor , qui arrondit à l'infini négatif.
  • Math.Ceiling , qui arrondit vers l'infini positif.
  • Math.Truncate() , qui arrondit à zéro.
  • Reference. , 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 de deux possibilités, par exemple arrondir pour que le dernier chiffre soit pair (" Round(2.5,MidpointRounding.ToEven) " devenant 2) ou pour qu'il soit plus éloigné de zéro (" Round(2.5,MidpointRounding.AwayFromZero) "devient 3).

Le diagramme et le tableau 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 parait, tout 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 ruse 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


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

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


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

Math.Truncate arrondit à 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

Math.floor sliiiide à gauche ...
Math.ceil sliiiide à droite ...
Math.truncate criiiiss crooooss (sol / plafond toujours vers 0)
Math.round cha cha, très lisse ... (aller du côté le plus proche)

Allons au travail! (⌐ □ _ □)

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

Tout le monde tape dans vos mains

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

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

Math.truncate(x) est également identique à int(x) .
en supprimant une fraction positive ou négative, vous vous dirigez toujours vers 0.







math