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

Question

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

Answer 1

Math.Floor Runden ab, Math.Ceiling rundet auf, und Math.Truncate rundet gegen Null. Also, Math.Truncate ist wie Math.Floor für positive Zahlen, und wie Math.Ceiling für negative Zahlen. Hier ist die Referenz .

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

Siehe auch: Antwort von Pax Diablo . Äußerst empfehlenswert!

Answer 2

Folgen Sie diesen Links, um die MSDN-Beschreibungen zu erhalten:

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

Das folgende Diagramm und die Tabelle können Ihnen dabei helfen:

-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 Round ist viel leistungsfähiger, als es den Anschein hat, weil es auf eine bestimmte Anzahl von Dezimalstellen runden kann. Alle anderen runden immer auf null Nachkommastellen. 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 muss man mit Multiplikation/Division tricksen, um denselben Effekt zu erzielen:

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

Answer 3

Math.Floor() rundet gegen die negative Unendlichkeit

Math.Truncate rundet gegen Null auf oder ab.

Zum Beispiel:

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

während

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

Answer 4

Math.floor nach links abrutschen...
Math.ceil nach rechts abrutschen...
Math.truncate criiiiss crooooss (Boden/Decke immer gegen 0)
Math.round cha cha, real smooth... (geht auf die nächste Seite)

Los geht's an die Arbeit! (_)

Auf der linken Seite... Math.floor
Nehmt es jetzt zurück, ihr alle... --
Diesmal zwei Hopfen... -=2

Alle klatschen in die Hände

Wie tief können Sie gehen? Kannst du tief hinuntergehen? Bis ganz nach unten floor ?

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

Math.truncate(x) ist auch dasselbe wie int(x) .
Durch das Entfernen eines positiven oder negativen Bruches geht man immer gegen 0.

Answer 5

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