Разница между Math.Floor() и Math.Truncate()

Math.Floor()округляет «в сторону отрицательной бесконечности» в соответствии с разделом 4 стандарта IEEE 754 .

Math.Truncate() округляет «до ближайшего целого числа к нулю».

Они функционально эквивалентны положительным числам. Разница в том, как они обрабатывают отрицательные числа.

Например:

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

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

MSDN ссылки: - Math.Floor метод - Math.Truncate метод

PS Остерегайтесь Math.Round, возможно, это не то, что вы ожидаете.

Чтобы получить "стандартный" результат округления, используйте:

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

Math.Floor() : Возвращает наибольшее целое число, меньшее или равное указанному числу с плавающей запятой двойной точности.

Math.Round() : Округляет значение до ближайшего целого числа или до указанного количества дробных знаков.

Попробуйте это, Примеры:

Math.Floor() против 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

Также 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()

Возвращает наибольшее целое число, меньшее или равное указанному числу. MSDN system.math.floor

math.truncate()

Вычисляет целую часть числа. MSDN system.math.truncate

Math.floor()всегда будет округлять в меньшую сторону, т. е. возвращает МЕНЬШЕ целого числа. Пока round()вернет БЛИЖАЙШЕЕ целое число

math.floor ()

Возвращает наибольшее целое число, меньшее или равное указанному числу.

math.truncate ()

Вычисляет целую часть числа.

Math.Floor():

Он дает наибольшее целое число, меньшее или равное заданному числу.

    Math.Floor(3.45) =3
    Math.Floor(-3.45) =-4

Math.Truncate():

Удаляет десятичные знаки числа и заменяет их на ноль.

Math.Truncate(3.45)=3
 Math.Truncate(-3.45)=-3

Также из приведенных выше примеров мы видим, что пол и усечение одинаковы для положительных чисел.

Следуя математическому определению пола, то есть «наибольшее целое число, меньшее или равное числу», это совершенно однозначно, тогда как Truncate просто удаляет дробную часть, что эквивалентно округлению до 0.

Math.Floor округляет в меньшую, Math.Ceiling большую и Math.Truncate большую сторону до нуля. Таким образом, Math.Truncate как Math.Floor для положительных чисел, так и Math.Ceiling для отрицательных чисел. Вот ссылка .

Для полноты Math.Round округляется до ближайшего целого числа. Если число находится точно посередине между двумя целыми числами, оно округляется до четного. Ссылка.

См. Также: ответ Пакса Диабло . Настоятельно рекомендуется!

Truncate удаляет десятичную точку.

Некоторые примеры:

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

Перейдите по этим ссылкам, чтобы просмотреть описания MSDN:

• Math.Floor, который округляется до отрицательной бесконечности.
• Math.Ceiling, который округляется до положительной бесконечности.
• Math.Truncate, который округляется до нуля в большую или меньшую сторону.
• 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).

The following diagram and table may help:

-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

Note that Round is a lot more powerful than it seems, simply because it can round to a specific number of decimal places. All the others round to zero decimals always. For example:

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

With the other functions, you have to use multiply/divide trickery to achieve the same effect:

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

Math.Floor() округляется до отрицательной бесконечности

Math.Truncate округляет в большую или меньшую сторону до нуля.

Например:

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

в то время как

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

Math.floor sloiiide слева ...
Math.ceil sloiiide справа ...
Math.truncate criiiiss crooooss (пол / потолок всегда в направлении 0)
Math.round ча-ча, очень гладко ... (перейти к ближайшей стороне)

За работу! (⌐ □ _ □)

Слева ... Math.floor
Верните его сейчас же ... На --
этот раз два прыжка ... -=2

Все хлопают в ладоши ✋✋

Как низко ты можешь пасть? Можете ли вы спуститься низко? Вплоть до floor?

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

Math.truncate(x) тоже то же самое, что и int(x) .
удаляя положительную или отрицательную дробь, вы всегда приближаетесь к нулю.