Math library

Question

You guys have a question. I’m giving a study in the library Math. What’s the difference between: Ceil, floor and trunc??

The idea is to take the floating part of the number. Hug!

Answer 1

Although this reply be based on Microsoft . net it is well didactic, translated via google Translate:

Follow these links to get the MSDN descriptions on:

1. Math.Floor, rounded to negative infinity.
2. Math.Ceiling, which rounds to positive infinity.
3. Math.Truncate, rounded up or down in the direction of zero.
4. Math.Round, rounded to the nearest integer or to the nearest specified number of decimals.

You can specify the behavior if it is exactly equidistant between two possibilities, such as rounding, so that the final digit is even ("Round(2.5,Midpointrounding. Toeven)" if making 2) or staying further 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 much more powerful than it looks, simply because can round to a specific number of decimal places. All others round to zero decimal 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 the trick multiply / split to get the same effect:

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

*Tachado added for parts not applicable in Python

I advise reading this reply, more precisely on the part of Extra information

Answer 2

Fábio, all are functions that return only the whole part.

• trunc = Returns only the entire part of the number, ignoring the decimals

• Ceil = Returns only the whole part of the number, rounding up

• floor = Returns only the whole part of the number, rounded down

In practice, taking as input the value 1.9:

• trunc = Returns 1, because it ignores the decimal part
• Ceil = Returns 2, for rounded up
• floor = Returns 1, 'cause it’s rounded down

Code:

import math

teste = 1.9

print(math.trunc(teste))
print(math.floor(teste))
print(math.ceil(teste))

Answer 3

In this code shows the trunc, Ceil and floor methods:

import math    
  
print(math.floor(23.91));
print(math.ceil(23.91));
print(math.trunc(23.91)); 

On the console shows the result: 23,24,23

Floor: returns the smallest integer among the number "x".

Ceil: returns the smallest integer greater than or equal to "x"

Trunc: Remove decimals from value.

More information:

https://www.geeksforgeeks.org/floor-ceil-function-python/

https://www.geeksforgeeks.org/g-fact-35-truncate-in-python/