C Math trunc() Function

What You’ll Learn

The trunc() function removes the fractional part of a floating-point number by rounding toward zero. It keeps the integer portion without rounding up or down to the nearest whole number.

Definition and Usage

Truncation means discarding everything after the decimal point by moving toward zero on the number line. trunc(3.75) becomes 3.0; trunc(-2.3) becomes -2.0—not −3.

This is different from round(), which picks the nearest integer, and from floor(), which moves toward negative infinity. Use trunc when you literally want to chop off decimals without changing the sign’s magnitude beyond that.

📝 Syntax

Standard C declaration:

double trunc(double x);

Related variants

float truncf(float x);           /* <math.h> */
long double truncl(long double x); /* <math.h> */

Parameters

• x — any floating-point value.

Return Value

• Integral part of x toward zero, returned as double.
• trunc(3.75) returns 3.0; trunc(-2.3) returns -2.0.
• If x is already an integer, NaN, or infinity, the result equals x.

Headers and linking

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

Examples Gallery

Compile every example with gcc file.c -std=c11 -o out -lm. Truncation is common in display formatting, game coordinates, and splitting dollars from cents.

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

int main(void) {
    double original = 3.75;
    double truncated = trunc(original);

    printf("Original number:  %.2f\n", original);
    printf("Truncated number: %.2f\n", truncated);

    return 0;
}

Original number:  3.75
Truncated number: 3.00

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

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

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

    return 0;
}

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

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

int main(void) {
    double x = 5.0;

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

    return 0;
}

trunc(5.0) = 5.0

#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

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

int main(void) {
    double price = 19.99;
    double whole;
    double fraction = modf(price, &whole);

    printf("Price:     $%.2f\n", price);
    printf("trunc():   $%.0f (whole dollars)\n", trunc(price));
    printf("modf whole:$%.0f, fraction: $%.2f\n", whole, fraction);

    return 0;
}

Price:     $19.99
trunc():   $19 (whole dollars)
modf whole:$19, fraction: $0.99

🚀 Common Use Cases

• Display formatting — show integer part of a measurement without rounding up.
• Game coordinates — snap to tile index by truncating pixel position.
• Signal processing — extract integer cycles from a phase value.
• Type conversion — safer than raw (int)x when you need explicit truncation semantics.
• Pair with modf() — when you need both whole and fractional parts.

📝 Notes

• Rounds toward zero—not toward negative infinity like floor.
• Returns double, not int—cast explicitly when needed.
• trunc(-2.3) is −2; do not assume “floor behavior” on negatives.
• Does not round to nearest—trunc(2.9) is 2, not 3.
• NaN and infinity pass through unchanged.
• Link with -lm when using GCC/Clang on Unix-like systems.

⚡ Optimization

trunc() is implemented in the platform math library. For positive values in a known-safe range, some code uses (int)x as a fast path—but that only matches trunc semantics for values that fit in int and when truncation toward zero is intended. Prefer trunc for clarity and correct negative handling.

💡 Best Practices