C Math fabs() Function

What You’ll Learn

The fabs() function returns the absolute value of a floating-point number—its distance from zero, without the sign. The name stands for floating-point absolute. Use it for distances, errors, and any time only magnitude matters.

Definition and Usage

The absolute value of a number is its magnitude without a sign. On the number line, fabs(-12.34) and fabs(12.34) both equal 12.34—the distance from zero.

fabs works on double values. For int, use abs() from <stdlib.h>. For float and long double, use fabsf() and fabsl().

📝 Syntax

Standard C declaration:

double fabs(double x);

Related variants

float fabsf(float x);           /* <math.h> */
long double fabsl(long double x); /* <math.h> */

Parameters

• x — any floating-point value (double).

Return Value

• Non-negative magnitude of x, returned as double.
• fabs(-12.34) returns 12.34; fabs(0.0) returns 0.0.
• fabs(-0.0) returns positive zero. fabs(NaN) returns NaN.

Headers and linking

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

Examples Gallery

Compile every example with gcc file.c -std=c11 -o out -lm. Absolute value is one of the most common math helpers in real programs.

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

int main(void) {
    double num = -12.34;
    double absolute = fabs(num);

    printf("Input:  %f\n", num);
    printf("|x| =   %f\n", absolute);

    return 0;
}

Input:  -12.340000
|x| =   12.340000

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

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

    for (i = 0; i < 3; i++) {
        printf("fabs(%5.1f) = %5.1f\n", values[i], fabs(values[i]));
    }

    return 0;
}

fabs(  5.0) =   5.0
fabs( -5.0) =   5.0
fabs(  0.0) =   0.0

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

int main(void) {
    double a = 10.5;
    double b = 3.2;
    double distance = fabs(a - b);

    printf("Point A: %.1f\n", a);
    printf("Point B: %.1f\n", b);
    printf("Distance: %.1f\n", distance);

    return 0;
}

Point A: 10.5
Point B: 3.2
Distance: 7.3

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

int main(void) {
    double expected = 0.1 + 0.2;
    double actual = 0.3;
    double epsilon = 1e-9;
    int close;

    close = fabs(expected - actual) < epsilon;

    printf("expected = %.17f\n", expected);
    printf("actual   = %.17f\n", actual);
    printf("Close?    %s\n", close ? "yes" : "no");

    return 0;
}

expected = 0.30000000000000004
actual   = 0.30000000000000004
Close?    yes

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

int main(void) {
    double x = -12.34;

    printf("x = %.2f\n", x);
    printf("fabs(x) = %.2f  (correct for double)\n", fabs(x));
    printf("abs(x)  = %d     (wrong: truncates to int first)\n", abs((int)x));

    return 0;
}

x = -12.34
fabs(x) = 12.34  (correct for double)
abs(x)  = 12     (wrong: truncates to int first)

🚀 Common Use Cases

• Distance — fabs(a - b) on a line; hypot in 2D.
• Error measurement — fabs(measured - expected).
• Floating-point equality — tolerance checks with epsilon.
• Graphics — magnitude of velocity, force, or offset components.
• Signal processing — envelope detection, amplitude without phase sign.

📝 Notes

• Declared in <math.h>, not <stdlib.h>.
• For int, use abs(); for long, labs(); for long long, llabs().
• fabs(-0.0) returns +0.0.
• fabs(NaN) returns NaN; fabs(±INFINITY) returns INFINITY.
• Link with -lm on GCC/Clang Unix-like builds.
• Macro fabs may exist in some headers—including math.h gives the function.

⚡ Optimization

fabs() is typically a single instruction or inlined bit operation on modern CPUs. It is faster and clearer than manual if (x < 0) x = -x. Do not micro-optimize further unless profiling shows it in a critical hot path.

💡 Best Practices