Care-i diferența dintre Math.Floor() și Math.Truncate()?

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.

Vezi și: Răspunsul lui Pax Diablo . Foarte recomandat!

Cateva exemple:

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

Urmați aceste linkuri pentru descrierile MSDN ale:

• 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).

Diagrama și tabelul de mai jos vă pot ajuta:

-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

Rețineți că Round este mult mai puternic decât pare, pur și simplu pentru că poate rotunji la un anumit număr de zecimale. Toți ceilalți rotunjește la zero zecimale întotdeauna. De exemplu:

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

Cu celelalte funcții, trebuie să folosiți trickery multiplica / împărți pentru a obține același efect:

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

Math.Floor() rounds toward negative infinity

Math.Truncate rounds up or down towards zero.

De exemplu:

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

in timp ce

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

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)

Să mergem la treabă! (?? _?)

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

Toată lumea vă bate mâinile?

Cat de josnic poti sa fii? Poți să te duci jos? Până la 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.

Math.floor()

Returnează cel mai mare număr întreg mai mic sau egal cu numărul specificat.

MSDN system.math.floor

math.truncate()

Calculează partea integrală a unui număr.

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

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.

Ele sunt echivalente funcțional cu numere pozitive. Diferența este în modul în care gestionează numerele negative.

De exemplu:

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. Feriți-vă de Math.Round este posibil să nu fie ceea ce vă așteptați.

Pentru a obține rezultatul "standard" de rotunjire, utilizați:

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