# C mathematical functions

C mathematical operations are a group of functions in the standard library of the C programming language implementing basic mathematical functions.[1][2] All functions use floating-point numbers in one manner or another. Different C standards provide different, albeit backwards-compatible, sets of functions. Most of these functions are also available in the C++ standard library, though in different headers (the C headers are included as well, but only as a deprecated compatibility feature).

## Overview of functions

Most of the mathematical functions are defined in `<math.h>` (`<cmath>` header in C++). The functions that operate on integers, such as `abs`, `labs`, `div`, and `ldiv`, are instead defined in the `<stdlib.h>` header (`<cstdlib>` header in C++).

Any functions that operate on angles use radians as the unit of angle.[1]

Not all of these functions are available in the C89 version of the standard. For those that are, the functions accept only type `double` for the floating-point arguments, leading to expensive type conversions in code that otherwise used single-precision `float` values. In C99, this shortcoming was fixed by introducing new sets of functions that work on `float` and `long double` arguments. Those functions are identified by `f` and `l` suffixes respectively.[3]

Function Description
`abs`
`labs`
`llabs`
computes absolute value of an integer value
`fabs` computes absolute value of a floating-point value
`div`
`ldiv`
`lldiv`
computes the quotient and remainder of integer division
`fmod` remainder of the floating-point division operation
`remainder` signed remainder of the division operation
`remquo` signed remainder as well as the three last bits of the division operation
`fma` fused multiply-add operation
`fmax` larger of two floating-point values
`fmin` smaller of two floating-point values
`fdim` positive difference of two floating-point values
`nan`
`nanf`
`nanl`
returns a not-a-number (NaN)
Exponential
functions
`exp` returns e raised to the given power
`exp2` returns 2 raised to the given power
`expm1` returns e raised to the given power, minus one
`log` computes natural logarithm (to base e)
`log2` computes binary logarithm (to base 2)
`log10` computes common logarithm (to base 10)
`log1p` computes natural logarithm (to base e) of 1 plus the given number
`ilogb` extracts exponent of the number
`logb` extracts exponent of the number
Power
functions
`sqrt` computes square root
`cbrt` computes cubic root
`hypot` computes square root of the sum of the squares of two given numbers
`pow` raises a number to the given power[4]
Trigonometric
functions
`sin` computes sine
`cos` computes cosine
`tan` computes tangent
`asin` computes arc sine
`acos` computes arc cosine
`atan` computes arc tangent
`atan2` computes arc tangent, using signs to determine quadrants
Hyperbolic
functions
`sinh` computes hyperbolic sine
`cosh` computes hyperbolic cosine
`tanh` computes hyperbolic tangent
`asinh` computes hyperbolic arc sine
`acosh` computes hyperbolic arc cosine
`atanh` computes hyperbolic arc tangent
Error and
gamma
functions
`erf` computes error function
`erfc` computes complementary error function
`lgamma` computes natural logarithm of the absolute value of the gamma function
`tgamma` computes gamma function
Nearest
integer
floating-
point
operations
`ceil` returns the nearest integer not less than the given value
`floor` returns the nearest integer not greater than the given value
`trunc` returns the nearest integer not greater in magnitude than the given value
`round`
`lround`
`llround`
returns the nearest integer, rounding away from zero in halfway cases
`nearbyint` returns the nearest integer using current rounding mode
`rint`
`lrint`
`llrint`
returns the nearest integer using current rounding mode with exception if the result differs
Floating-
point
manipulation
functions
`frexp` decomposes a number into significand and a power of 2
`ldexp` multiplies a number by 2 raised to a power
`modf` decomposes a number into integer and fractional parts
`scalbn`
`scalbln`
multiplies a number by FLT_RADIX raised to a power
`nextafter`
`nexttoward`
returns next representable floating-point value towards the given value
`copysign` copies the sign of a floating-point value
Classification `fpclassify` categorizes the given floating-point value
`isfinite` checks if the given number has finite value
`isinf` checks if the given number is infinite
`isnan` checks if the given number is NaN
`isnormal` checks if the given number is normal
`signbit` checks if the given number is negative

### Floating-point environment

C99 adds several functions and types for fine-grained control of floating-point environment.[3] These functions can be used to control a variety of settings that affect floating-point computations, for example, the rounding mode, on what conditions exceptions occur, when numbers are flushed to zero, etc. The floating-point environment functions and types are defined in `<fenv.h>` header (`<cfenv>` in C++).

Function Description
`feclearexcept` clears exceptions (C99)
`fegetenv` stores current floating-point environment (C99)
`fegetexceptflag` stores current status flags (C99)
`fegetround` retrieves current rounding direction (C99)
`feholdexcept` saves current floating-point environment and clears all exceptions (C99)
`feraiseexcept` raises a floating-point exception (C99)
`fesetenv` sets current floating-point environment (C99)
`fesetexceptflag` sets current status flags (C99)
`fesetround` sets current rounding direction (C99)
`fetestexcept` tests whether certain exceptions have been raised (C99)
`feupdateenv` restores floating-point environment, but keeps current exceptions (C99)

### Complex numbers

C99 adds a new `_Complex` keyword (and `complex` convenience macro) that provides support for complex numbers. Any floating-point type can be modified with `complex`, and is then defined as a pair of floating-point numbers. Note that C99 and C++ do not implement complex numbers in a code-compatible way – the latter instead provides the class `std::complex`.

All operations on complex numbers are defined in `<complex.h>` header. As with the real-valued functions, an `f` or `l` suffix denotes the `float complex` or `long double complex` variant of the function.

Function Description
Basic
operations
`cabs` computes absolute value (C99)
`carg` computes argument of a complex number (C99)
`cimag` computes imaginary part of a complex number (C99)
`creal` computes real part of a complex number (C99)
`conj` computes complex conjugate (C99)
`cproj` computes complex projection into the Riemann sphere (C99)
Exponentiation
operations
`cexp` computes complex exponential (C99)
`clog` computes complex logarithm (C99)
`csqrt` computes complex square root (C99)
`cpow` computes complex power (C99)
Trigonometric
operations
`csin` computes complex sine (C99)
`ccos` computes complex cosine (C99)
`ctan` computes complex tangent (C99)
`casin` computes complex arc sine (C99)
`cacos` computes complex arc cosine (C99)
`catan` computes complex arc tangent (C99)
Hyperbolic
operations
`csinh` computes complex hyperbolic sine (C99)
`ccosh` computes complex hyperbolic cosine (C99)
`ctanh` computes complex hyperbolic tangent (C99)
`casinh` computes complex hyperbolic arc sine (C99)
`cacosh` computes complex hyperbolic arc cosine (C99)
`catanh` computes complex hyperbolic arc tangent (C99)

A few more complex functions are "reserved for future use in C99".[5] Implementations are provided by open-source projects that are not part of the standard library.

Function Description
Error functions `cerf` computes the complex error function (C99)
`cerfc` computes the complex complementary error function (C99)

### Type-generic functions

The header `<tgmath.h>` defines a type-generic macro for each mathematical function defined in `<math.h>` and `<complex.h>`. This adds a limited support for function overloading of the mathematical functions: the same function name can be used with different types of parameters; the actual function will be selected at compile time according to the types of the parameters.

Each type-generic macro that corresponds to a function that is defined for both real and complex numbers encapsulates a total of 6 different functions: `float`, `double` and `long double`, and their `complex` variants. The type-generic macros that correspond to a function that is defined for only real numbers encapsulates a total of 3 different functions: `float`, `double` and `long double` variants of the function.

The C++ language includes native support for function overloading and thus does not provide the `<tgmath.h>` header even as a compatibility feature.

### Random number generation

The header `<stdlib.h>` (`<cstdlib>` in C++) defines several functions that can be used for statistically random number generation.[6]

Function Description
`rand` generates a pseudo-random number between 0 and `RAND_MAX`, inclusive.
`srand` initializes a pseudo-random number generator
`arc4random` generates a pseudo-random number between 0 and `UINT32_MAX`, usually using a better algorithm than `rand`
`arc4random_uniform` generates a pseudo-random number between 0 and a maximum value.
`arc4random_buf` fill a buffer with a pseudo-random bitstream.
`arc4random_stir` initializes a pseudo-random number generator.

The `arc4random` family of random number functions are not defined in POSIX standard, but is found in some common `libc` implementations. It used to refer to the keystream generator of a leaked version of RC4 cipher (hence "alleged RC4"), but different algorithms, usually from other ciphers like ChaCha20, have been implemented since using the same name.

The quality of randomness from `rand` are usually too weak to be even considered statistically random, and it requires explicit seeding. It is usually advised to use `arc4random` instead of `rand` when possible. Some C libraries implement `rand` using `arc4random_uniform` internally.

## libm

Under Linux and BSD, the mathematical functions (as declared in `<math.h>`) are bundled separately in the mathematical library `libm`. Therefore, if any of those functions are used, the linker must be given the directive `-lm`.

There are various `libm` implementations, including: