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

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

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

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

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

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, который округляется до ближайшего целого числа или указанного количества десятичных знаков. Вы можете указать поведение, если оно точно равноудалено между двумя вариантами, например округление, чтобы последняя цифра была четной («Round(2.5,MidpointRounding.ToEven)» становится 2) или так, чтобы она дальше от нуля («Round(2.5,MidpointRounding.AwayFromZero)» становилась 3).

Следующая диаграмма и таблица могут помочь:

-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

Обратите внимание, что Round намного мощнее, чем кажется, просто потому, что он может округлять до определенного количества десятичных знаков. Все остальные числа всегда округляются до нуля. Например:

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

С другими функциями вы должны использовать уловку умножения / деления для достижения того же эффекта:

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() патронов «в сторону отрицательной бесконечности» в соответствии с разделом 4 Стандарт IEEE 754.

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

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

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

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

Например:

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

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

Ссылки MSDN: - Математический метод пола - Math.Truncate Метод

P.S. Остерегайтесь математики - это может быть не то, что вы ожидаете.

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

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.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(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 Sliiide влево ...
Math.ceil направо ...
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).
удаляя положительную или отрицательную дробь, вы всегда приближаетесь к нулю.

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

math.floor ()

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

math.truncate ()

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

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.