C standard library |
---|

General topics |

Miscellaneous headers |

**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).

## Contents

## Overview of functions[edit]

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[edit]

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[edit]

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) | |

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[edit]

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[edit]

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 "**a**lleged **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[edit]

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:

- GNU libc's libm
- AMD's libm
- Red Hat's libm
- Sun's FDLIBM, which was used as the basis for FreeBSD's msun and OpenBSD's libm, both of which in turn were the basis of Julia's OpenLibm (usable by C language, while made for Julia language)
- Arénaire project's CRlibm (correctly rounded libm), and its successor MetaLibm

## See also[edit]

## References[edit]

- ^
^{a}^{b}*ISO/IEC 9899:1999 specification*(PDF). p. 212, § 7.12. **^**Prata, Stephen (2004).*C primer plus*. Sams Publishing. Appendix B, Section V: The Standard ANSI C Library with C99 Additions. ISBN 0-672-32696-5.- ^
^{a}^{b}Prata, Stephen (2004).*C primer plus*. Sams Publishing. Appendix B, Section VIII: C99 Numeric Computational Enhancements. ISBN 0-672-32696-5. **^**Notationally, it may seem convenient to use pow(*x*,2) or pow(*x*,3) to compute squares or cubes. However, this is not advisable in time-critical code. Unless an implementation takes special care of these cases at compile time,*x***x*or*x***x***x*will execute much faster. Also, sqrt(*x*) and cbrt(*x*) should be preferred over pow(*x*,.5) or pow(*x*,1./3).**^**man cerf(3), man cerfc(3), see e.g. http://linux.die.net/man/3/cerf.**^**"The GNU C Library – ISO Random". Retrieved 18 July 2018.

## External links[edit]

The Wikibook C Programming has a page on the topic of: C Programming/C Reference |

- The Single UNIX Specification, Issue 7 from The Open Group : mathematical declarations – Base Definitions Reference,
- C reference for math functions