# std::abs(float), std::fabs, std::fabsf, std::fabsl

From cppreference.com
< cpp‎ | numeric‎ | math

Defined in header `<cmath>` |  |
Defined in header `<cstdlib>` |  | (since C++17)
float abs( float arg ); | (1) |
double abs( double arg ); | (2) |
long double abs( long double arg ); | (3) |
Defined in header `<cmath>` |  |
| (4) |
float fabs ( float arg ); |  |
float fabsf( float arg ); |  | (since C++11)
double fabs ( double arg ); | (5) |
| (6) |
long double fabs ( long double arg ); |  |
long double fabsl( long double arg ); |  | (since C++11)
double fabs ( IntegralType arg ); | (7) | (since C++11)

1-6) Computes the absolute value of a floating point value `arg`.
7) A set of overloads or a function template accepting an argument of any integral type. Equivalent to (5) (the argument is cast to double).

For integral arguments, the integral overloads of `std::abs` are likely better matches. If `std::abs` is called with an argument of type `X` such that std::is_unsigned<X>::value is `true` and `X` cannot be converted to int by integral promotion, the program is ill-formed. | (since C++17)

### Parameters

arg | - | Value of a floating-point or Integral type

### Return value

If successful, returns the absolute value of `arg` (`|arg|`). The value returned is exact and does not depend on any rounding modes.

### Error handling

This function is not subject to any of the error conditions specified in math_errhandling.

If the implementation supports IEEE floating-point arithmetic (IEC 60559),

- If the argument is ±0, +0 is returned
- If the argument is ±∞, +∞ is returned
- If the argument is NaN, NaN is returned

### Example

Run this code

    #include <iostream>
    #include <cmath>

    int main()
    {
        std::cout << "abs(+3.0) = " << std::abs(+3.0) << '\n'
                  << "abs(-3.0) = " << std::abs(-3.0) << '\n';
        // special values
        std::cout << "abs(-0.0) = " << std::abs(-0.0) << '\n'
                  << "abs(-Inf) = " << std::abs(-INFINITY) << '\n';
    }

Possible output:

    abs(+3.0) = 3
    abs(-3.0) = 3
    abs(-0.0) = 0
    abs(-Inf) = inf

### Defect reports

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

DR | Applied to | Behavior as published | Correct behavior
--- | --- | --- | ---
LWG 2735 | C++11 | `std::abs` was erroneously required to have overloads for integer types returning double | removed the requirement

### See also

abs(int)labs llabs (C++11) | computes absolute value of an integral value (|x|) (function)
copysign copysignf copysignl (C++11)(C++11)(C++11) | copies the sign of a floating point value (function)
signbit (C++11) | checks if the given number is negative (function)
abs(std::complex) | returns the magnitude of a complex number (function template)
abs(std::valarray) | applies the function std::abs to each element of valarray (function template)

Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/numeric/math/fabs&oldid=108183"