I could've swore I've seen and even implemented this before, but is there a mathematical way to find the ceiling of a number (without equality symbols)? This is the best I could come up with:

Include math.h and use ceil. Don't forget to link to the math library

Why do you not want to use equality?
The macro you have looks okay, for positive numbers but I think that it will give you floor for negative numbers. Since, if I recall correctly, ceiling is defined as the next integer away from zero.

I definitely won't be dealing with negatives. It's a performance sensitive program so I figured something without an equality would be faster. Also, I can't guarantee I'll have the math library available.

In which case you may want to hold (int)X in a temporary variable and save having to do the conversion twice.
I'm not certain about the performance implications of a temp var against the type conversion but I suspect that will be quicker, just because the internal format of a float is quite complex. You could profile it (or look at the assembler generated) and make a decision.

Same argument goes for the performance of equality against greater than.

What graemf is politely telling you: unless you have profiling to tell you that your current incarnation of your macro saves a lot of execution time, then you are wasting your efforts. Algorithms are the heart of the beast - consider looking at changing to more efficient algorithm design, before going to the level of == vs > compares.

Yes > is faster than == in most implementations, but no user will ever see the difference unless the code in question is a true bottleneck in logic flow.

Sorry for a bump on a really old thread, but I can see TastyWheat's rationale for wanting to macro the ceiling function. I'm also working on a performance-sensitive program (embedded system), and as long as the macro is called only with constants, a good compiler should be able to make light work of it at compile-time, removing all the performance implications.

That said, I Google-Fu'd my way here for this macro and improved upon it to handle negative numbers (well, kind of):

// NOTE: These macros return the "Excel-like" interpretation of the ceiling function.
// This only matters with negative numbers: CEILING(-2.5) will return -3.
#define CEILING_POS(X) ((X-(int)(X)) > 0 ? (int)(X+1) : (int)(X))
#define CEILING_NEG(X) ((X-(int)(X)) < 0 ? (int)(X-1) : (int)(X))
#define CEILING(X) ( ((X) > 0) ? CEILING_POS(X) : CEILING_NEG(X) )

Test Cases:

CEILING(11.1)
--> CEILING_POS(11.1) = 11.1 - 11 (=0.1)
--> --> 0.1 > 0 = TRUE, return (int)(11.1 + 1) = 12

CEILING(-3.5)
--> CEILING_NEG(-3.5) = -3.5 - -3 (=-0.5)
--> --> -0.5 < 0 = TRUE, return (int)(-3.5 - 1) = -4

CEILING(5)
--> CEILING_POS(5) = 5 - 5 (=0)
--> --> 0 > 0 = FALSE, return (int)(5) = 5

CEILING(-5)
--> CEILING_NEG(-5) = -5 - -5 (=0)
--> --> 0 < 0 = FALSE, return (int)(-5) = -5

CEILING(0)
--> CEILING_NEG(0) = 0 - 0 (=0)
--> --> 0 < 0 = FALSE, return (int)(0) = 0

I'm sorry for digging this up from the grave, but it's a high hit on google for this question and there are no other answers.

This is what I came up, it works for both positive and negative numbers:

But do these solutions work for big numbers? What (int)1e20 is, for example?

@mtytel,
your solution doesn't work for any real number in (-1, 0) range.

Welcome to LQ dizcza!

You have replied to a 5 year old post, itself a reply to a 9 year old thread with little activity.

If you have a question or would like to contribute your own approach to a similar task, please consider opening your own thread to get better exposure.

2 members found this post helpful.