Różnica między Math.Floor () a Math.Truncate ()

Jaka jest różnica między .NET Math.Floor()a Math.Truncate().NET?

Math.Floorzaokrągla w dół, Math.Ceilingzaokrągla w górę i Math.Truncatezaokrągla w kierunku zera. Tak Math.Truncatejest jak Math.Floordla liczb dodatnich i jak Math.Ceilingdla liczb ujemnych. Oto odniesienie .

Dla kompletności, Math.Roundzaokrągla do najbliższej liczby całkowitej. Jeśli liczba jest dokładnie w połowie odległości między dwiema liczbami całkowitymi, to zaokrągla się w kierunku parzystej. Odniesienie.

Zobacz także: odpowiedź Paxa Diablo . Wysoce polecany!

Skorzystaj z tych linków, aby uzyskać opisy MSDN:

• Math.Floor, który zaokrągla w dół w kierunku ujemnej nieskończoności.
• Math.Ceiling, który zaokrągla w górę w kierunku dodatniej nieskończoności.
• Math.Truncate, który zaokrągla w górę lub w dół w kierunku zera.
• Math.Round, który zaokrągla do najbliższej liczby całkowitej lub określonej liczby miejsc dziesiętnych. Możesz określić zachowanie, jeśli jest dokładnie w jednakowej odległości między dwiema możliwościami, takimi jak zaokrąglanie, tak aby ostatnia cyfra była parzysta („ Round(2.5,MidpointRounding.ToEven)” staje się 2) lub tak, że jest dalej od zera („ Round(2.5,MidpointRounding.AwayFromZero)” staje się 3).

Poniższy schemat i tabela mogą pomóc:

-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

Zauważ, że Roundjest o wiele potężniejszy niż się wydaje, po prostu dlatego, że może zaokrąglać do określonej liczby miejsc po przecinku. Wszystkie pozostałe zawsze zaokrąglają do dziesiętnych. Na przykład:

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

W przypadku innych funkcji musisz użyć funkcji zwielokrotniania / dzielenia, aby osiągnąć ten sam efekt:

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

Math.Floor() zaokrągla w kierunku ujemnej nieskończoności

Math.Truncate zaokrągla w górę lub w dół w kierunku zera.

Na przykład:

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

podczas

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

Kilka przykładów:

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

Math.floorsliiiide w lewo ...
Math.ceilsliiiide w prawo ...
Math.truncatecriiiiss crooooss (podłoga / sufit zawsze w kierunku 0)
Math.roundcha cha, naprawdę gładka ... (przejdź do najbliższej strony)

Chodźmy do pracy! (⌐ □ _ □)

Po lewej ... Math.floor
Zabierzcie to teraz wszyscy ... --
Tym razem dwa przeskoki ...-=2

Wszyscy klaszczą w dłonie ✋✋

Jak nisko możesz zejść? Czy możesz zejść nisko? Aż do floor?

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

Math.truncate(x)jest również taki sam jak int(x).
usuwając dodatnią lub ujemną frakcję, zawsze zmierzasz w kierunku 0.

Są funkcjonalnie równoważne z liczbami dodatnimi. Różnica polega na tym, jak radzą sobie z liczbami ujemnymi.

Na przykład:

Math.Floor(2.5) = 2
Math.Truncate(2.5) = 2

Math.Floor(-2.5) = -3
Math.Truncate(-2.5) = -2

Linki MSDN: - Metoda Math.Floor - Metoda Math.Truncate

PS Uważaj na matematykę. Może nie być to, czego oczekujesz.

Aby uzyskać „standardowy” wynik zaokrąglania, użyj:

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

Spróbuj tego, Przykłady:

Math.Floor () vs 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

Również 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()

Zwraca największą liczbę całkowitą mniejszą lub równą podanej liczbie. MSDN system.math.floor

math.truncate()

Oblicza integralną część liczby. MSDN system.math.truncate

Math.Floor()zaokrągla „w kierunku ujemnej nieskończoności” zgodnie z normą IEEE 754 sekcja 4.

Math.Truncate() zaokrągla „do najbliższej liczby całkowitej w kierunku zera”.

Math.Floor(): Zwraca największą liczbę całkowitą mniejszą lub równą podanej liczbie zmiennoprzecinkowej podwójnej precyzji.

Math.Round(): Zaokrągla wartość do najbliższej liczby całkowitej lub do określonej liczby cyfr ułamkowych.

Math.floor()zawsze będzie zaokrąglać w dół, tzn. zwraca MNIEJSZĄ liczbę całkowitą. Podczas gdy round()zwróci NAJBLIŻSZĄ liczbę całkowitą

math.floor ()

Zwraca największą liczbę całkowitą mniejszą lub równą podanej liczbie.

math.truncate ()

Oblicza integralną część liczby.

Obcięcie upuszcza dziesiętne ****