C Math frexp() Function

What You’ll Learn

The frexp() function splits a floating-point number into a mantissa (normalized fraction) and a binary exponent, so that x = mantissa × 2exp. It mirrors how computers store floats internally and pairs with ldexp() to rebuild the value.

Definition and Usage

Think of scientific notation in base 2: any nonzero number can be written as a fraction between 0.5 and 1 times a power of two. For 123.45, frexp returns mantissa ≈ 0.964 and exponent 7, because 0.964 × 27 ≈ 123.45.

The exponent is stored through a pointer parameter int *exp. The function returns the mantissa as a double. Reassemble with ldexp(mantissa, exponent).

📝 Syntax

Standard C declaration:

double frexp(double x, int *exp);

Related variants

float frexpf(float x, int *exp);           /* <math.h> */
long double frexpl(long double x, int *exp); /* <math.h> */

Parameters

• x — the value to decompose.
• exp — pointer to int where the binary exponent is stored.

Return Value

• Normalized mantissa m such that x = m × 2*exp.
• For nonzero x, |m| is in [0.5, 1).
• frexp(0, &exp) returns 0.0 and sets *exp to 0.

Headers and linking

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

Examples Gallery

Compile every example with gcc file.c -std=c11 -o out -lm. Mantissa/exponent decomposition appears in low-level numeric code and custom float parsers.

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

int main(void) {
    double x = 123.45;
    int exponent;
    double mantissa = frexp(x, &exponent);

    printf("x = %.2f\n", x);
    printf("mantissa = %.6f\n", mantissa);
    printf("exponent = %d\n", exponent);
    printf("check: %.2f * 2^%d = %.2f\n",
           mantissa, exponent, ldexp(mantissa, exponent));

    return 0;
}

x = 123.45
mantissa = 0.964453
exponent = 7
check: 0.96 * 2^7 = 123.45

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

int main(void) {
    int exp = -999;
    double m = frexp(0.0, &exp);

    printf("mantissa = %.1f\n", m);
    printf("exponent = %d\n", exp);

    return 0;
}

mantissa = 0.0
exponent = 0

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

int main(void) {
    double values[] = { 1.0, 42.0, 0.125, 1000.0 };
    size_t i;

    for (i = 0; i < 4; i++) {
        double x = values[i];
        int exp;
        double m = frexp(x, &exp);
        double rebuilt = ldexp(m, exp);

        printf("x=%8.3f  m=%.4f  e=%3d  -> %.3f\n",
               x, m, exp, rebuilt);
    }

    return 0;
}

x=   1.000  m=0.5000  e=  1  -> 1.000
x=  42.000  m=0.6562  e=  6  -> 42.000
x=   0.125  m=0.5000  e= -2  -> 0.125
x=1000.000  m=0.9766  e= 10  -> 1000.000

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

int main(void) {
    double x = 8.0;
    int exp;
    double m = frexp(x, &exp);

    printf("x = %.1f\n", x);
    printf("mantissa = %.1f  (because %.1f * 2^%d = %.1f)\n",
           m, m, exp, ldexp(m, exp));

    return 0;
}

x = 8.0
mantissa = 0.5  (because 0.5 * 2^4 = 8.0)

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

int main(void) {
    double x = -12.0;
    int exp;
    double m = frexp(x, &exp);

    printf("x = %.1f\n", x);
    printf("mantissa = %.4f\n", m);
    printf("exponent = %d\n", exp);
    printf("rebuilt = %.1f\n", ldexp(m, exp));

    return 0;
}

x = -12.0
mantissa = -0.7500
exponent = 4
rebuilt = -12.0

🚀 Common Use Cases

• IEEE-754 education — understand mantissa and exponent fields.
• Custom serialization — store floats in compact mantissa+exp form.
• Range analysis — inspect magnitude via exponent before overflow.
• Pair with ldexp() — scale values by powers of two efficiently.
• Numerical algorithms — normalize operands before precision-sensitive steps.

📝 Notes

• Identity: x = frexp(x,&e) × 2e (equivalently ldexp(frexp(...), e)).
• Nonzero mantissa magnitude is in [0.5, 1).
• exp must be a valid int *—not NULL.
• frexp(NaN, &e) returns NaN; frexp(±INF, &e) returns NaN.
• Not the same as modf() (decimal split) or logb() (exponent only).
• Link with -lm on GCC/Clang Unix-like builds.

⚡ Optimization

frexp() is a thin wrapper over bit-level float representation on most platforms. Use it when you need true IEEE decomposition; do not hand-roll mantissa extraction unless you fully understand float internals and edge cases.

💡 Best Practices