C Math fmod() Function

What You’ll Learn

The fmod() function computes the floating-point remainder after division—like % for integers, but for double values. The result keeps the sign of the dividend and is essential for wrapping angles, cyclic timers, and texture coordinates.

Definition and Usage

fmod(x, y) answers: “After dividing x by y, what is left over?” Mathematically, x = n × y + fmod(x, y) for some integer multiple n, where the remainder has the same sign as x.

Example: 10.5 ÷ 3.2 = 3 with remainder 0.9, because 3 × 3.2 = 9.6 and 10.5 − 9.6 = 0.9. So fmod(10.5, 3.2) is 0.9.

📝 Syntax

Standard C declaration:

double fmod(double x, double y);

Related variants

float fmodf(float x, float y);           /* <math.h> */
long double fmodl(long double x, long double y); /* <math.h> */

Parameters

• x — dividend (numerator).
• y — divisor (denominator); must not be zero.

Return Value

• Remainder of x / y with the sign of x.
• |fmod(x, y)| is less than |y| (unless y is zero or x is infinite).
• y == 0 returns NaN; may set errno to EDOM.

Headers and linking

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

Examples Gallery

Compile every example with gcc file.c -std=c11 -o out -lm. Remainder math shows up in graphics, physics, and scheduling code.

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

int main(void) {
    double dividend = 10.5;
    double divisor = 3.2;
    double remainder = fmod(dividend, divisor);

    printf("%.2f / %.2f -> remainder %.2f\n",
           dividend, divisor, remainder);

    return 0;
}

10.50 / 3.20 -> remainder 0.90

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

int main(void) {
    double y = 3.2;

    printf("fmod( 10.5, %.1f) = %5.1f\n", y, fmod( 10.5, y));
    printf("fmod(-10.5, %.1f) = %5.1f\n", y, fmod(-10.5, y));
    printf("fmod( 10.5, %.1f) = %5.1f\n", -y, fmod( 10.5, -y));

    return 0;
}

fmod( 10.5, 3.2) =   0.9
fmod(-10.5, 3.2) =  -0.9
fmod( 10.5, -3.2) =   0.9

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

int main(void) {
    double angles[] = { 370.0, -45.0, 720.0 };
    size_t i;

    for (i = 0; i < 3; i++) {
        double a = angles[i];
        double wrapped = fmod(a, 360.0);
        if (wrapped < 0.0)
            wrapped += 360.0;

        printf("%6.0f deg -> %6.1f deg (0-360)\n", a, wrapped);
    }

    return 0;
}

   370 deg ->   10.0 deg (0-360)
   -45 deg ->  315.0 deg (0-360)
   720 deg ->    0.0 deg (0-360)

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

int main(void) {
    double x = 10.5;
    double y = 3.2;
    double r = fmod(x, y);
    double quotient_part = x - r;
    double check = quotient_part / y;

    printf("x = %.1f, y = %.1f\n", x, y);
    printf("remainder r = %.1f\n", r);
    printf("x - r = %.1f\n", quotient_part);
    printf("(x - r) / y = %.1f  (whole number multiple)\n", check);

    return 0;
}

x = 10.5, y = 3.2
remainder r = 0.9
x - r = 9.6
(x - r) / y = 3.0  (whole number multiple)

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

int main(void) {
    /* Integer % truncates operands first if you cast */
    int a = 10;
    int b = 3;

    printf("Integer:  %d %% %d = %d\n", a, b, a % b);
    printf("Float:    fmod(%.1f, %.1f) = %.1f\n",
           10.5, 3.2, fmod(10.5, 3.2));
    printf("Wrong:    (int)10.5 %% (int)3.2 = %d  (truncated!)\n",
           (int)10.5 % (int)3.2);

    return 0;
}

Integer:  10 % 3 = 1
Float:    fmod(10.5, 3.2) = 0.9
Wrong:    (int)10.5 % (int)3.2 = 1  (truncated!)

🚀 Common Use Cases

• Angle wrapping — keep rotations in [0, 360) or [−π, π).
• Texture tiling — repeat UV coordinates across a surface.
• Cyclic timers — elapsed time within a repeating period.
• Grid snapping — offset within one cell of a lattice.
• Physics — position along a periodic path or wave phase.

📝 Notes

• Result sign matches x (dividend), not y.
• y == 0 → NaN; check divisor before calling.
• Either argument NaN → result NaN.
• Infinite x with finite y → NaN.
• Not the same as modf() or integer %.
• Link with -lm on GCC/Clang Unix-like builds.

⚡ Optimization

fmod() is slower than integer % because it handles IEEE-754 edge cases. For power-of-two divisors in performance-critical graphics code, bit masks may suffice for integers—but for true floating divisors like 3.2, stick with fmod.

💡 Best Practices