C Math ldexp() Function

What You’ll Learn

The ldexp() function computes x × 2^exp—scale a number up or down by powers of two. It is the inverse of frexp() and a fast alternative to pow(2, exp) * x in graphics and numeric code.

Definition and Usage

ldexp(x, exp) multiplies x by 2 raised to exp. Positive exp scales up (like shifting the binary point left); negative exp scales down.

Example from the reference: ldexp(5.25, 3) = 5.25 × 2³ = 5.25 × 8 = 42. If frexp splits a number apart, ldexp puts mantissa and exponent back together.

📝 Syntax

Standard C declaration:

double ldexp(double x, int exp);

Related variants

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

Parameters

• x — the mantissa or base value to scale.
• exp — integer exponent for the power of two.

Return Value

• x × 2exp as a double.
• ldexp(5.25, 3) returns 42.0.
• ldexp(0, exp) returns 0 for any exp.

Headers and linking

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

Examples Gallery

Compile every example with gcc file.c -std=c11 -o out -lm. Power-of-two scaling shows up in float reconstruction and fast multiply/divide by 2.

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

int main(void) {
    double x = 5.25;
    int exponent = 3;
    double result = ldexp(x, exponent);

    printf("x = %.2f, exp = %d\n", x, exponent);
    printf("ldexp(x, exp) = %.2f\n", result);

    return 0;
}

x = 5.25, exp = 3
ldexp(x, exp) = 42.00

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

int main(void) {
    printf("ldexp(8,  2) = %.1f  (8 * 4)\n", ldexp(8.0,  2));
    printf("ldexp(8, -2) = %.1f  (8 / 4)\n", ldexp(8.0, -2));
    printf("ldexp(8,  0) = %.1f  (unchanged)\n", ldexp(8.0,  0));

    return 0;
}

ldexp(8,  2) = 32.0  (8 * 4)
ldexp(8, -2) = 2.0  (8 / 4)
ldexp(8,  0) = 8.0  (unchanged)

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

int main(void) {
    double original = 123.45;
    int exp;
    double mantissa = frexp(original, &exp);
    double rebuilt = ldexp(mantissa, exp);

    printf("original = %.2f\n", original);
    printf("mantissa = %.6f, exp = %d\n", mantissa, exp);
    printf("rebuilt  = %.2f\n", rebuilt);

    return 0;
}

original = 123.45
mantissa = 0.964453, exp = 7
rebuilt  = 123.45

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

int main(void) {
    double brightness = 1.0;
    size_t i;

    printf("Start: %.4f\n", brightness);
    for (i = 0; i < 3; i++) {
        brightness = ldexp(brightness, -1);
        printf("After halve %zu: %.4f\n", i + 1, brightness);
    }

    return 0;
}

Start: 1.0000
After halve 1: 0.5000
After halve 2: 0.2500
After halve 3: 0.1250

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

int main(void) {
    double x = 5.25;
    int exp = 3;
    double via_ldexp = ldexp(x, exp);
    double via_pow = x * pow(2.0, exp);

    printf("ldexp(x, %d)     = %.6f\n", exp, via_ldexp);
    printf("x * pow(2, %d)   = %.6f\n", exp, via_pow);

    return 0;
}

ldexp(x, 3)     = 42.000000
x * pow(2, 3)   = 42.000000

🚀 Common Use Cases

• Reconstruct floats — after frexp mantissa/exponent split.
• Fast multiply/divide by 2 — ldexp(x, n) or ldexp(x, -n).
• Graphics — brightness halving, mip-map level scaling.
• Audio — gain changes in powers of two.
• Custom float math — build values from mantissa and exponent parts.

📝 Notes

• Computes x × 2exp, not x × 10exp.
• ldexp(0, exp) is 0 for any exp.
• exp = 0 returns x unchanged.
• Large exp may overflow; very negative exp may underflow to 0.
• Inverse of frexp() on the decomposed parts.
• Link with -lm on GCC/Clang Unix-like builds.

⚡ Optimization

ldexp() is typically faster than pow(2, exp) * x because it can adjust the IEEE-754 exponent directly. For integer powers of two, always prefer ldexp over general exponentiation.

💡 Best Practices