C mathematical functions

Short description: C standard library header file

C standard library

General topics

* Data types
* Character classification
* Strings
* Mathematics
* File input/output
* Date/time
* Localization
* Memory allocation
* Process control
* Signals
* Alternative tokens

Miscellaneous headers

* <assert.h>
* <errno.h>
* <setjmp.h>
* <stdarg.h>

* v
* t
* e

C mathematical operations are a group of functions in the standard library of the C programming language implementing basic mathematical functions.[1][2] 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

* 1 Overview of functions
* 1.1 Floating-point environment
* 1.2 Complex numbers
* 1.3 Type-generic functions
* 1.4 Random-number generation
* 1.5 Special functions
* 2 Implementations
* 3 See also
* 4 References
* 5 External links

## Overview of functions

Most of the mathematical functions, which use floating-point numbers, 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 NaN (not-a-number)
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 argument has finite value
`isinf` | checks if the argument is infinite
`isnan` | checks if the argument is NaN
`isnormal` | checks if the argument is normal
`signbit` | checks if the sign of the argument 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; only available if the `<complex.h>` header is included) 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 the `<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.

### Special functions

Beginning in C++17, C++ introduces special functions into the `<cmath>` header.

Function  | Description

|

`assoc_laguerre` | computes associated Laguerre polynomials
`assoc_legendre` | computes associated Legendre polynomials
`beta` | computes beta function
`comp_ellint_1` | computes complete elliptic integral of the first kind
`comp_ellint_2` | computes complete elliptic integral of the second kind
`comp_ellint_3` | computes complete elliptic integral of the third kind
`cyl_bessel_i` | computes regular modified cylindrical Bessel functions
`cyl_bessel_j` | computes cylindrical Bessel functions of the first kind
`cyl_bessel_k` | computes irregular modified cylindrical Bessel functions
`cyl_neumann` | computes cylindrical Neumann functions
`ellint_1` | computes incomplete elliptic integral of the first kind
`ellint_2` | computes incomplete elliptic integral of the second kind
`ellint_3` | computes incomplete elliptic integral of the third kind
`expint` | computes exponential integral
`hermite` | computes Hermite polynomials
`legendre` | computes Legendre polynomials
`laguerre` | computes Laguerre polynomials
`riemann_zeta` | computes Riemann zeta function
`sph_bessel` | computes spherical Bessel functions of the first kind
`sph_legendre` | computes spherical associated Legendre functions
`sph_neumann` | computes spherical Neumann functions

## Implementations

Under POSIX systems like 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, github, used almost as is by Windows
* Intel C++ Compiler libm
* Red Hat's libm (Newlib)
* 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
* musl's libm, based on the BSD `libms` and other projects like Arm
* LLVM's libm, which is correctly rounded (i.e. errors from the mathematically correct result are lower than 0.5 unit in the last place)[7]
* Arénaire project's CRlibm (correctly rounded libm), and its successor MetaLibm, which uses Remez algorithm to automatically generate approximations that are formally proven.
* Rutger's RLIBM, which provides correctly rounded functions in single precision.[8]

Implementations not necessarily under a name of `libm` include:

* Arm's on GitHub
* on GitHub is a version of C/C++ math functions written for C++ `constexpr` (compile-time calculation)
* CORE-MATH, correctly rounded for single and double precision.
* SIMD (vectorized) math libraries include SLEEF, Yeppp! , and Agner Fog's VCL, plus a few closed-source ones like SVML and DirectXMath.[9]

## See also

* C99 floating-point support

## References

1. ↑ 1.0 1.1 ISO/IEC 9899:1999 specification. p. 212, § 7.12. https://www.open-std.org/jtc1/sc22/wg14/www/docs/n1124.pdf.
2. ↑ 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.
3. ↑ 3.0 3.1 Prata, Stephen (2004). C primer plus. Sams Publishing. Appendix B, Section VIII: C99 Numeric Computational Enhancements. ISBN 0-672-32696-5.
4. ↑ 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).
5. ↑ man cerf(3), man cerfc(3), see e.g. https://linux.die.net/man/3/cerf.
6. ↑ "The GNU C Library – ISO Random". https://www.gnu.org/software/libc/manual/html_node/ISO-Random.html.
7. ↑ "Math Functions — The LLVM C Library". https://libc.llvm.org/math/index.html.
8. ↑ "RLibm: Rutgers Architecture and Programming Languages Lab's Correctly Rounded Libm". https://people.cs.rutgers.edu/~sn349/rlibm/.
9. ↑ Cordes, Peter. "intel - Where is Clang's '_mm256_pow_ps' intrinsic?". https://stackoverflow.com/a/36637424.

## External links

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

|

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

* v
* t
* e

C programming language

* ANSI C
* C89 and C90
* C99
* C11
* C18
* C2x
* Embedded C
* MISRA C

Features|

* Functions
* Header files
* Libraries
* Operators
* String
* Syntax
* Preprocessor
* Data types

Standard library
functions|

* Char (ctype.h)
* File I/O (stdio.h)
* Math (math.h)
* Dynamic memory (stdlib.h)
* String (string.h)
* Time (time.h)
* Variadic (stdarg.h)
* POSIX

Standard
libraries|

* Bionic
* libhybris
* dietlibc
* EGLIBC
* glibc
* klibc
* Microsoft Run-time Library
* musl
* Newlib
* uClibc
* BSD libc

Compilers|

* Comparison of compilers
* ACK
* Borland Turbo C
* Clang
* GCC
* ICC
* LCC
* PCC
* SDCC
* TCC
* Microsoft Visual Studio / Express / C++
* Watcom C/C++

IDEs|

* Comparison of IDEs
* Anjuta
* Code
* CodeLite
* Eclipse
* Geany
* Microsoft Visual Studio
* NetBeans

Comparison with
other languages|

* Compatibility of C and C++
* Comparison with Embedded C
* Comparison with Pascal
* Comparison of programming languages

Descendant
languages|

* C++
* C#
* D
* Objective-C
* Alef
* Limbo
* Go
* Vala

* Category

0.00

(0 votes)

Original source: https://en.wikipedia.org/wiki/C mathematical functions. Read more

|

Retrieved from "https://handwiki.org/wiki/index.php?title=Software:C_mathematical_functions&oldid=4293349"
*[v]: View this template
*[t]: Discuss this template
*[e]: Edit this template