C Math exp() Function

What You’ll Learn

The exp() function computes e^x—Euler’s number e (about 2.718) raised to a power. It models continuous growth and decay, powers hyperbolic functions like cosh(), and pairs with log() as its inverse.

Definition and Usage

The natural exponential function is written ex in mathematics. In C, exp(x) computes this value, where e ≈ 2.718281828 is Euler’s number—the unique base where the slope of the curve ex at zero equals 1.

Positive x gives growth (values rise quickly). Negative x gives decay (values shrink toward zero). At x = 0, any number to the power 0 is 1, so exp(0) = 1.

📝 Syntax

Standard C declaration:

double exp(double x);

Related variants

float expf(float x);           /* <math.h> */
long double expl(long double x); /* <math.h> */

Parameters

• x — the exponent; any real number.

Return Value

• ex as a double.
• exp(0) returns 1.0.
• exp(1) returns e (about 2.71828).
• Very large x may return INFINITY; very negative x may underflow to 0.0.

Headers and linking

• #include <math.h>
• Compile: gcc exp.c -std=c11 -o exp -lm
• M_E (value of e) is available in <math.h> on most platforms.

Examples Gallery

Compile every example with gcc file.c -std=c11 -o out -lm. The exponential function appears in finance, physics, and probability.

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

int main(void) {
    double x = 2.0;
    double result = exp(x);

    printf("e^%.2f = %.4f\n", x, result);

    return 0;
}

e^2.00 = 7.3891

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

int main(void) {
    printf("exp(0) = %.1f\n", exp(0.0));
    printf("exp(1) = %.5f  (this is e)\n", exp(1.0));

    return 0;
}

exp(0) = 1.0
exp(1) = 2.71828  (this is e)

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

int main(void) {
    double x = 1.0;

    printf("exp(%.1f)  = %.5f  (growth)\n",  x, exp(x));
    printf("exp(%.1f) = %.5f  (decay, 1/e)\n", -x, exp(-x));

    return 0;
}

exp(1.0)  = 2.71828  (growth)
exp(-1.0) = 0.36788  (decay, 1/e)

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

int main(void) {
    double principal = 1000.0;
    double rate = 0.05;   /* 5% annual */
    double years = 10.0;
    double future = principal * exp(rate * years);

    printf("Principal: $%.2f\n", principal);
    printf("Rate:      %.1f%% for %.0f years\n", rate * 100, years);
    printf("Future:    $%.2f\n", future);

    return 0;
}

Principal: $1000.00
Rate:      5.0% for 10 years
Future:    $1648.72

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

int main(void) {
    double values[] = { 0.0, 1.0, 2.5, -1.5 };
    size_t i;

    printf("   x     exp(x)    log(exp(x))\n");
    for (i = 0; i < 4; i++) {
        double x = values[i];
        printf("%5.1f  %8.4f  %12.4f\n", x, exp(x), log(exp(x)));
    }

    return 0;
}

   x     exp(x)    log(exp(x))
  0.0    1.0000        0.0000
  1.0    2.7183        1.0000
  2.5   12.1825        2.5000
 -1.5    0.2231       -1.5000

🚀 Common Use Cases

• Finance — continuous compound interest and discounting.
• Physics — radioactive decay, capacitor charging, population growth.
• Probability — softmax, Poisson distribution, entropy calculations.
• Machine learning — sigmoid and log-softmax use exp internally.
• Hyperbolic functions — cosh(x) and sinh(x) are built from exp.

📝 Notes

• Computes ex, not 10x (use pow(10, x) or exp(x * log(10)) for base 10).
• exp(0) = 1; exp(1) = e.
• Result is always positive; exp(x) > 0 for all finite x.
• Large positive x → overflow (INFINITY); large negative x → underflow (0).
• Prefer exp(x) over pow(M_E, x) for accuracy and speed.
• Inverse: log(exp(x)) == x for finite x.

⚡ Optimization

exp() is heavily optimized in modern math libraries. If you call it repeatedly with the same exponent in a loop, cache the result in a variable. For softmax-style code summing many exponentials, use the log-sum-exp trick to avoid overflow—subtract the maximum value before calling exp.

💡 Best Practices