C Math log() Function

What You’ll Learn

The log() function computes the natural logarithm ln(x)—logarithm to base e (Euler’s number, ≈ 2.718). It is the inverse of exp() and appears in growth, decay, entropy, and machine-learning formulas.

Definition and Usage

The natural logarithm answers: “To what power must e be raised to get x?” If et = x, then log(x) = t. That is why log(exp(t)) = t.

In C, log(x) requires x > 0. log(1) = 0 because e&sup0; = 1. log(e) = 1 because e¹ = e.

📝 Syntax

Standard C declaration:

double log(double x);

Related variants

float logf(float x);           /* <math.h> */
long double logl(long double x); /* <math.h> */

Parameters

• x — positive value; domain is x > 0.

Return Value

• Natural logarithm ln(x) as double.
• log(2.0) returns about 0.693147.
• log(0) returns −∞; log(negative) returns NaN.

Headers and linking

• #include <math.h>
• Compile: gcc log.c -std=c11 -o log -lm
• M_E gives the value of e on most platforms.

Examples Gallery

Compile every example with gcc file.c -std=c11 -o out -lm. Natural logs model continuous growth and appear throughout science and engineering.

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

int main(void) {
    double result = log(2.0);

    printf("ln(2.0) = %.6f\n", result);

    return 0;
}

ln(2.0) = 0.693147

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

int main(void) {
    printf("log(1)   = %.1f  (e^0 = 1)\n", log(1.0));
    printf("log(M_E) = %.1f  (e^1 = e)\n", log(M_E));

    return 0;
}

log(1)   = 0.0  (e^0 = 1)
log(M_E) = 1.0  (e^1 = e)

#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

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

int main(void) {
    double principal = 1000.0;
    double target = 2000.0;
    double rate = 0.05;
  /* target = principal * e^(rate * t)  =>  t = log(target/principal) / rate */
    double years = log(target / principal) / rate;

    printf("Grow $%.0f to $%.0f at %.0f%% continuous\n",
           principal, target, rate * 100);
    printf("Time needed: %.1f years\n", years);

    return 0;
}

Grow $1000 to $2000 at 5% continuous
Time needed: 13.9 years

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

int main(void) {
    double x = 100.0;

    printf("x = %.0f\n", x);
    printf("log(x)   = %.4f  (base e)\n", log(x));
    printf("log10(x) = %.4f  (base 10)\n", log10(x));

    return 0;
}

x = 100
log(x)   = 4.6052  (base e)
log10(x) = 2.0000  (base 10)

🚀 Common Use Cases

• Continuous growth/decay — solve for time with log.
• Machine learning — cross-entropy and log-softmax.
• Information theory — entropy uses natural log (nats) or log₂.
• Signal processing — decibel and log-scale conversions.
• Inverse of exp() — undo exponential transforms.

📝 Notes

• Natural log uses base e ≈ 2.71828, not base 10.
• Domain: x > 0 only. Zero and negatives are errors.
• log(1) = 0; log(e) = 1.
• Inverse of exp() for positive values.
• For base-10 logarithm, use log10(), not log().
• Link with -lm on GCC/Clang Unix-like builds.

⚡ Optimization

log() is implemented in the platform math library. In hot loops computing many logarithms, profile first—often the algorithm structure matters more than micro-optimizing individual log calls. Use logf when float precision suffices.

💡 Best Practices