0

As you may know, if you do:

>>> 11/2
# 5

And

>>> 11/2.0
# 5.5

I'd like to get 6 in this case. I tried with:

>>> 11//2
# 5

And

>>> 11//2.0
# 5.0

The last one gives the prev integer. I'd like to get the next integer. Even is the result is like x.1 I'd like to get (x+1).

How can I do this?

Remi Guan
  • 20,142
  • 17
  • 60
  • 81
Gocht
  • 9,328
  • 3
  • 37
  • 76
  • @user2357112 - Why did you reopen this? It's a clear duplicate. – TigerhawkT3 Dec 10 '15 at 23:30
  • 2
    @TigerhawkT3: That question is about rounding numbers that are already floating-point, but introducing floating-point numbers at all for a purely-integer operation like this may not be a good idea. – user2357112 Dec 10 '15 at 23:32
  • 1
    It's obvious that a floating-point number will be introduced automatically when necessary. Any floating-point number of `n.0` is equal to the integer `n`. The answers on that question are perfectly applicable. – TigerhawkT3 Dec 10 '15 at 23:35
  • @TigerhawkT3 I think that an _applicable answer_ does not mean _the same question_ – Gocht Dec 10 '15 at 23:36
  • @TigerhawkT3: `555555555555555555.0 != 555555555555555555`. Using floating-point for this just seems like asking for subtle rounding bugs down the line. – user2357112 Dec 10 '15 at 23:38
  • 1
    And "why does function foo not run unless I call it" isn't the same question as "why does function main not run unless I call it" isn't the same question, but it is the same answer. – TigerhawkT3 Dec 10 '15 at 23:38
  • Does this answer your question? [Is there a ceiling equivalent of // operator in Python?](https://stackoverflow.com/questions/14822184/is-there-a-ceiling-equivalent-of-operator-in-python) – endolith May 19 '20 at 03:19

3 Answers3

2

Generally more efficient than doing both modulus and division work, it's easy to convert floor division:

x // y

into ceil division (and unlike using math.ceil, it runs no risk of getting incorrect results due to floating point imprecision for large values):

(x + y - 1) // y

If x is exactly divisible by y, then adding y - 1 changes nothing; the floor division makes the end result unchanged. If it's not evenly divisible, this increases it above the next multiple, getting you ceil division with only a single division operation instead of two (division is expensive; doing it twice is doubly expensive), and no floating point precision issues.

ShadowRanger
  • 124,179
  • 11
  • 158
  • 228
  • 1
    This almost works, but it does the wrong thing when `y` is negative. For example, when `x` is 5 and `y` is -2, `(x + y - 1) // y` is -1, but the correct ceiling division result would have been -2. – user2357112 May 19 '20 at 03:39
1

Use math.ceil

>>> import math
>>> math.ceil(11/2.0)
6.0
>>>
letsc
  • 2,442
  • 3
  • 30
  • 52
1
rounded_up = x // y + bool(x % y)

We add 1 if the division produces a nonzero remainder. This has the benefit of not introducing floating-point imprecision, so it'll be correct in extreme cases where math.ceil produces the wrong answer.

We can also perform the operation with floor division and two negations:

rounded_up = -(-x // y)

The floor of -x/y is the negative of the ceiling of x/y, so negating again produces the ceiling of x/y. Again, we avoid floating-point rounding error by performing all operations in integer arithmetic.

user2357112
  • 235,058
  • 25
  • 372
  • 444