C Math ceil() Function

What You’ll Learn

The ceil() function (short for ceiling) returns the smallest integer that is greater than or equal to a floating-point value. It always rounds toward positive infinity—the practical “round up” for positive numbers.

Definition and Usage

Mathematically, ceil(x) is the smallest integer n such that n ≥ x. On the number line, you move right (toward +∞) until you hit an integer.

For positive fractions like 8.45, that feels like “round up” to 9. For negatives, remember: ceil(-2.3) is −2, not −3, because −2 is greater than −2.3.

📝 Syntax

Standard C declaration:

double ceil(double x);

Related variants

float ceilf(float x);           /* <math.h> */
long double ceill(long double x); /* <math.h> */

Parameters

• x — any floating-point value.

Return Value

• Smallest integer ≥ x, returned as double.
• ceil(8.45) returns 9.0; ceil(8.0) returns 8.0.

Headers and linking

• #include <math.h>
• Compile: gcc ceil.c -std=c11 -o ceil -lm

Examples Gallery

Compile every example with gcc file.c -std=c11 -o out -lm. Rounding functions are common in UI layout and billing code.

#include <stdio.h>
#include <math.h>

int main(void) {
    double number = 8.45;
    double rounded_up = ceil(number);

    printf("Original number: %.2f\n", number);
    printf("Rounded up:      %.2f\n", rounded_up);

    return 0;
}

Original number: 8.45
Rounded up:      9.00

#include <stdio.h>
#include <math.h>

int main(void) {
    double x = 5.0;

    printf("ceil(%.1f) = %.1f\n", x, ceil(x));

    return 0;
}

ceil(5.0) = 5.0

#include <stdio.h>
#include <math.h>

int main(void) {
    double x = -2.3;

    printf("x = %.1f\n", x);
    printf("ceil(x)  = %.1f  (toward +infinity)\n", ceil(x));
    printf("floor(x) = %.1f  (toward -infinity)\n", floor(x));

    return 0;
}

x = -2.3
ceil(x)  = -2.0  (toward +infinity)
floor(x) = -3.0  (toward -infinity)

#include <stdio.h>
#include <math.h>

int main(void) {
    int total_items = 47;
    int per_page = 10;
    int pages = (int)ceil((double)total_items / per_page);

    printf("%d items, %d per page -> %d pages\n",
           total_items, per_page, pages);

    return 0;
}

47 items, 10 per page -> 5 pages

#include <math.h>
#include <stdio.h>

int main(void) {
    double vals[] = { 2.3, 2.5, 2.8, -2.3, -2.5 };
    size_t i;

    printf("   x     ceil   floor  round\n");
    for (i = 0; i < 5; i++) {
        double x = vals[i];
        printf("%5.1f  %5.1f  %5.1f  %5.1f\n",
               x, ceil(x), floor(x), round(x));
    }

    return 0;
}

   x     ceil   floor  round
  2.3    3.0    2.0    2.0
  2.5    3.0    2.0    3.0
  2.8    3.0    2.0    3.0
 -2.3   -2.0   -3.0   -2.0
 -2.5   -2.0   -3.0   -3.0

🚀 Common Use Cases

• Pagination — compute pages from item count and page size.
• Billing — charge for full units when any fraction counts (e.g. storage blocks).
• Graphics layout — allocate enough rows/columns for fractional tile counts.
• Memory allocation — size buffers to fit fractional element counts.
• Pair with floor() — bracket a value between floor and ceil.

📝 Notes

• Returns double, not int—cast explicitly when needed.
• Rounds toward +infinity, not always “away from zero.”
• ceil(-2.3) is −2; do not assume “more negative.”
• Link with -lm when using GCC/Clang on Unix-like systems.
• Compare with floor(), round(), and trunc() for other rounding needs.

⚡ Optimization

ceil() is implemented in the platform math library. For positive values where you only need integers, some code uses (int)x + (x > (int)x) tricks—but ceil handles negatives and edge cases correctly. Prefer the library function unless profiling shows a hot path that needs micro-optimization.

💡 Best Practices