C Math floor() Function

What You’ll Learn

The floor() function returns the largest integer that is less than or equal to a floating-point value. It always rounds toward negative infinity—the practical “round down” for positive numbers.

Definition and Usage

Mathematically, floor(x) is the largest integer n such that n ≤ x. On the number line, you move left (toward −∞) until you hit an integer.

For positive fractions like 5.78, that feels like “round down” to 5. For negatives, remember: floor(-2.3) is −3, not −2, because −3 is less than −2.3.

📝 Syntax

Standard C declaration:

double floor(double x);

Related variants

float floorf(float x);           /* <math.h> */
long double floorl(long double x); /* <math.h> */

Parameters

• x — any floating-point value.

Return Value

• Largest integer ≤ x, returned as double.
• floor(5.78) returns 5.0; floor(5.0) returns 5.0.

Headers and linking

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

Examples Gallery

Compile every example with gcc file.c -std=c11 -o out -lm. Rounding functions are common in UI layout, pricing, and game grids.

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

int main(void) {
    double number = 5.78;
    double rounded_down = floor(number);

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

    return 0;
}

Original number: 5.78
Rounded down:    5.00

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

int main(void) {
    double x = 5.0;

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

    return 0;
}

floor(5.0) = 5.0

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

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

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

    return 0;
}

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

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

int main(void) {
    int total_items = 47;
    int per_batch = 10;
    int full_batches = (int)floor((double)total_items / per_batch);
    int remainder = total_items % per_batch;

    printf("%d items, %d per batch\n", total_items, per_batch);
    printf("Full batches: %d\n", full_batches);
    printf("Left over:    %d items\n", remainder);

    return 0;
}

47 items, 10 per batch
Full batches: 4
Left over:    7 items

#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     floor  ceil  round  trunc\n");
    for (i = 0; i < 5; i++) {
        double x = vals[i];
        printf("%5.1f  %5.1f  %5.1f  %5.1f  %5.1f\n",
               x, floor(x), ceil(x), round(x), trunc(x));
    }

    return 0;
}

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

🚀 Common Use Cases

• Conservative billing — charge only for complete units.
• Grid indexing — map pixel position to tile row/column.
• Inventory — count how many full crates fit in stock.
• Time buckets — complete hours/minutes elapsed.
• Pair with ceil() — bracket a value: floor(x) ≤ x ≤ ceil(x).

📝 Notes

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

⚡ Optimization

floor() is implemented in the platform math library. For positive values only, some code uses (int)x when truncation toward zero equals floor—but that breaks for negatives. Prefer floor unless profiling shows a hot path that needs micro-optimization.

💡 Best Practices