Unterschied zwischen Math.Floor () und Math.Truncate ()

Was ist der Unterschied zwischen Math.Floor()und Math.Truncate()in .NET?

Math.Floorrundet ab, Math.Ceilingrundet auf und Math.Truncaterundet gegen Null. Also Math.Truncateist wie Math.Floorfür positive Zahlen und wie Math.Ceilingfür negative Zahlen. Hier ist die Referenz .

Der Vollständigkeit Math.Roundhalber wird auf die nächste Ganzzahl gerundet. Wenn die Zahl genau in der Mitte zwischen zwei ganzen Zahlen liegt, rundet sie auf die gerade Zahl. Referenz.

Siehe auch: Pax Diablos Antwort . Sehr empfehlenswert!

Folgen Sie diesen Links für die MSDN-Beschreibungen von:

• Math.Floor, die in Richtung negative Unendlichkeit abrundet.
• Math.Ceiling, was sich in Richtung positive Unendlichkeit aufrundet.
• Math.Truncate, die gegen Null auf- oder abrundet.
• Math.Round, die auf die nächste Ganzzahl oder die angegebene Anzahl von Dezimalstellen rundet. Sie können das Verhalten angeben, wenn es zwischen zwei Möglichkeiten genau gleich weit entfernt ist, z. B. gerundet, damit die letzte Ziffer gerade ist (" Round(2.5,MidpointRounding.ToEven)" 2 wird) oder weiter von Null entfernt ist (" Round(2.5,MidpointRounding.AwayFromZero)" 3 wird).

Das folgende Diagramm und die folgende Tabelle können hilfreich sein:

-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

Beachten Sie, dass dies Roundviel leistungsfähiger ist, als es scheint, einfach weil es auf eine bestimmte Anzahl von Dezimalstellen gerundet werden kann. Alle anderen runden immer auf null Dezimalstellen. Zum Beispiel:

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

Bei den anderen Funktionen müssen Sie Multiplikations- / Divisions-Tricks verwenden, um den gleichen Effekt zu erzielen:

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

Math.Floor() Runden in Richtung negative Unendlichkeit

Math.Truncate rundet auf oder ab gegen Null.

Zum Beispiel:

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

während

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

Einige Beispiele:

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 nach links ...
Math.ceilSliiiide nach rechts ...
Math.truncateCriiiiss Crooooss (Boden / Decke immer in Richtung 0)
Math.round cha cha, echt glatt ... (zur nächsten Seite gehen)

Gehen wir an die Arbeit! (⌐ □ _ □)

Links ... Math.floor
Nimm es jetzt zurück, ihr alle ... --
Diesmal zwei Sprünge ...-=2

Alle klatschen in die Hände ✋✋

Wie tief kann man gehen? Kannst du tief runter gehen? Den ganzen Weg zum floor?

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

Math.truncate(x)ist auch das gleiche wie int(x).
Wenn Sie einen positiven oder negativen Bruch entfernen, bewegen Sie sich immer in Richtung 0.

Sie sind funktional äquivalent zu positiven Zahlen. Der Unterschied besteht darin, wie sie mit negativen Zahlen umgehen.

Zum Beispiel:

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

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

MSDN-Links: - Math.Floor-Methode - Math.Truncate-Methode

PS Vorsicht vor Mathe. Runde ist möglicherweise nicht das, was Sie erwarten.

Um das "Standard" -Rundungsergebnis zu erhalten, verwenden Sie:

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

Versuchen Sie dies, Beispiele:

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

Auch 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()

Gibt die größte Ganzzahl zurück, die kleiner oder gleich der angegebenen Zahl ist. MSDN system.math.floor

math.truncate()

Berechnet den integralen Teil einer Zahl. MSDN system.math.truncate

Math.Floor()Runden "in Richtung negative Unendlichkeit" gemäß IEEE Standard 754 Abschnitt 4.

Math.Truncate() rundet "auf die nächste ganze Zahl gegen Null".

Math.Floor(): Gibt die größte Ganzzahl zurück, die kleiner oder gleich der angegebenen Gleitkommazahl mit doppelter Genauigkeit ist.

Math.Round(): Rundet einen Wert auf die nächste Ganzzahl oder auf die angegebene Anzahl von Bruchstellen.

Math.floor()wird immer abrunden, dh es wird WENIGER Ganzzahl zurückgegeben. While round()gibt die NEAREST-Ganzzahl zurück

math.floor ()

Gibt die größte Ganzzahl zurück, die kleiner oder gleich der angegebenen Zahl ist.

math.truncate ()

Berechnet den integralen Teil einer Zahl.

Beim Abschneiden wird die Dezimalstelle **** gelöscht