how to convert Math.Ceiling result to int?

From C++ practices, I would use the following. It's guaranteed to get the correct result even when ceiling returns 99.99999...8 or 100.000000...1

var result = (int)(Math.Ceiling(value) + 0.5);

The code below should work too if you trust its implementation

var result = Convert.ToInt32(value);

If you are sure that you do not cross the capacity of int, it should be perfectly safe to do

int myInt = (int)Math.Ceiling(...);

If you are not sure about the bound, you could go with long instead of int.


If it's all about speed, then Math.Ceiling for Int inputs and output is quite slow. The fastest is an inline expression. 2.4 seconds vs 33 ms.

Warning: Only for positive value and divisor values.

A) Modulus

Here's one I came up with, that has obviously also been found by C/C++ developers before:

var ceilingResult = (value / divisor) + (value % divisor == 0 ? 0 : 1);

From my own benchmark of 10M iterations, Math.Ceiling takes ~2.4 seconds. Calling this expression inside a named function takes ~380 ms and having it as a direct inline expression takes ~33ms.

B) Simple arithmetic only

Also consider using the suggestion from @mafu

var ceilingResult = (value + divisor - 1) / divisor;

See this 470x upvoted C++ answer for reference and validation. Also https://stackoverflow.com/a/4175152/887092.

C) DivRem

While looking at this answer, https://stackoverflow.com/a/14878734/887092, I noticed the comment that reminded me about DivRem CPU instructions. See https://docs.microsoft.com/en-us/dotnet/api/system.math.divrem?view=netframework-4.8. Math.DivRem should get resolved down to such a CPU instruction.

var quotient = Math.DivRem(value, divisor, out long remainder);
var ceilingResult = quotient + (remainder == 0 ? 0 : 1);

[I have not tested this]. See https://stackoverflow.com/a/924160/887092, for potential edge cases (Where negative Int numbers are used)

Further optimisations might be possible for this - maybe with casting. In this answer, https://stackoverflow.com/a/924160/887092, an if-conditional statement is used - they are about the same.

Performance of the 3:

  • Modulus: Has two operations that are added, but also a conditional branch.
  • Arithmetic: Has some additional mathematical operations in a sequence.
  • DivRem: Builds on the Modulus approach. If C# does resolve Math.DivRem to a single CPU instruction, this might be faster. Further optimisations might also be possible.

I'm not sure how the two would perform on various architectures. But now you have options to explore.

If you would like Math.Floor for Int inputs and Output, it's even easier:

var floorResult = (value / divisor);

Tags:

C#

Recent Posts