Mathematics

This chapter contains information about functions for performing mathematical computations, such as trigonometric functions. Most of these functions have prototypes declared in the header file `math.h'. The complex-valued functions are defined in `complex.h'.

All mathematical functions which take a floating-point argument have three variants, one each for double, float, and long double arguments. The double versions are mostly defined in ISO C89. The float and long double versions are from the numeric extensions to C included in ISO C99.

Which of the three versions of a function should be used depends on the situation. For most calculations, the float functions are the fastest. On the other hand, the long double functions have the highest precision. double is somewhere in between. It is usually wise to pick the narrowest type that can accommodate your data. Not all machines have a distinct long double type; it may be the same as double.

Predefined Mathematical Constants

The header `math.h' defines several useful mathematical constants. All values are defined as preprocessor macros starting with M_. The values provided are:

M_E

The base of natural logarithms.

M_LOG2E

The logarithm to base 2 of M_E.

M_LOG10E

The logarithm to base 10 of M_E.

M_LN2

The natural logarithm of 2.

M_LN10

The natural logarithm of 10.

M_PI

Pi, the ratio of a circle's circumference to its diameter.

M_PI_2

Pi divided by two.

M_PI_4

Pi divided by four.

M_1_PI

The reciprocal of pi (1/pi)

M_2_PI

Two times the reciprocal of pi.

M_2_SQRTPI

Two times the reciprocal of the square root of pi.

M_SQRT2

The square root of two.

M_SQRT1_2

The reciprocal of the square root of two (also the square root of 1/2).

These constants come from the Unix98 standard and were also available in 4.4BSD; therefore they are only defined if _BSD_SOURCE or _XOPEN_SOURCE=500, or a more general feature select macro, is defined. The default set of features includes these constants. See section Feature Test Macros.

All values are of type double. As an extension, the GNU C library also defines these constants with type long double. The long double macros have a lowercase `l' appended to their names: M_El, M_PIl, and so forth. These are only available if _GNU_SOURCE is defined.

Note: Some programs use a constant named PI which has the same value as M_PI. This constant is not standard; it may have appeared in some old AT&T headers, and is mentioned in Stroustrup's book on C++. It infringes on the user's name space, so the GNU C library does not define it. Fixing programs written to expect it is simple: replace PI with M_PI throughout, or put `-DPI=M_PI' on the compiler command line.

Trigonometric Functions

These are the familiar sin, cos, and tan functions. The arguments to all of these functions are in units of radians; recall that pi radians equals 180 degrees.

The math library normally defines M_PI to a double approximation of pi. If strict ISO and/or POSIX compliance are requested this constant is not defined, but you can easily define it yourself:

#define M_PI 3.14159265358979323846264338327

You can also compute the value of pi with the expression acos (-1.0).

Function: double sin (double x)

Function: float sinf (float x)

Function: long double sinl (long double x)

These functions return the sine of x, where x is given in radians. The return value is in the range -1 to 1.

Function: double cos (double x)

Function: float cosf (float x)

Function: long double cosl (long double x)

These functions return the cosine of x, where x is given in radians. The return value is in the range -1 to 1.

Function: double tan (double x)

Function: float tanf (float x)

Function: long double tanl (long double x)

These functions return the tangent of x, where x is given in radians.

Mathematically, the tangent function has singularities at odd multiples of pi/2. If the argument x is too close to one of these singularities, tan will signal overflow.

In many applications where sin and cos are used, the sine and cosine of the same angle are needed at the same time. It is more efficient to compute them simultaneously, so the library provides a function to do that.

Function: void sincos (double x, double *sinx, double *cosx)

Function: void sincosf (float x, float *sinx, float *cosx)

Function: void sincosl (long double x, long double *sinx, long double *cosx)

These functions return the sine of x in *sinx and the cosine of x in *cos, where x is given in radians. Both values, *sinx and *cosx, are in the range of -1 to 1.

This function is a GNU extension. Portable programs should be prepared to cope with its absence.

ISO C99 defines variants of the trig functions which work on complex numbers. The GNU C library provides these functions, but they are only useful if your compiler supports the new complex types defined by the standard. (As of this writing GCC supports complex numbers, but there are bugs in the implementation.)

Function: complex double csin (complex double z)

Function: complex float csinf (complex float z)

Function: complex long double csinl (complex long double z)

These functions return the complex sine of z. The mathematical definition of the complex sine is

@ifnottex @math{sin (z) = 1/(2*i) * (exp (z*i) - exp (-z*i))}.

Function: complex double ccos (complex double z)

Function: complex float ccosf (complex float z)

Function: complex long double ccosl (complex long double z)

These functions return the complex cosine of z. The mathematical definition of the complex cosine is

@ifnottex @math{cos (z) = 1/2 * (exp (z*i) + exp (-z*i))}

Function: complex double ctan (complex double z)

Function: complex float ctanf (complex float z)

Function: complex long double ctanl (complex long double z)

These functions return the complex tangent of z. The mathematical definition of the complex tangent is

@ifnottex @math{tan (z) = -i * (exp (z*i) - exp (-z*i)) / (exp (z*i) + exp (-z*i))}

The complex tangent has poles at @math{pi/2 + 2n}, where @math{n} is an integer. ctan may signal overflow if z is too close to a pole.

Inverse Trigonometric Functions

These are the usual arc sine, arc cosine and arc tangent functions, which are the inverses of the sine, cosine and tangent functions respectively.

Function: double asin (double x)

Function: float asinf (float x)

Function: long double asinl (long double x)

These functions compute the arc sine of x---that is, the value whose sine is x. The value is in units of radians. Mathematically, there are infinitely many such values; the one actually returned is the one between -pi/2 and pi/2 (inclusive).

The arc sine function is defined mathematically only over the domain -1 to 1. If x is outside the domain, asin signals a domain error.

Function: double acos (double x)

Function: float acosf (float x)

Function: long double acosl (long double x)

These functions compute the arc cosine of x---that is, the value whose cosine is x. The value is in units of radians. Mathematically, there are infinitely many such values; the one actually returned is the one between 0 and pi (inclusive).

The arc cosine function is defined mathematically only over the domain -1 to 1. If x is outside the domain, acos signals a domain error.

Function: double atan (double x)

Function: float atanf (float x)

Function: long double atanl (long double x)

These functions compute the arc tangent of x---that is, the value whose tangent is x. The value is in units of radians. Mathematically, there are infinitely many such values; the one actually returned is the one between -pi/2 and pi/2 (inclusive).

Function: double atan2 (double y, double x)

Function: float atan2f (float y, float x)

Function: long double atan2l (long double y, long double x)

This function computes the arc tangent of y/x, but the signs of both arguments are used to determine the quadrant of the result, and x is permitted to be zero. The return value is given in radians and is in the range -pi to pi, inclusive.

If x and y are coordinates of a point in the plane, atan2 returns the signed angle between the line from the origin to that point and the x-axis. Thus, atan2 is useful for converting Cartesian coordinates to polar coordinates. (To compute the radial coordinate, use hypot; see section Exponentiation and Logarithms.)

If both x and y are zero, atan2 returns zero.

ISO C99 defines complex versions of the inverse trig functions.

Function: complex double casin (complex double z)

Function: complex float casinf (complex float z)

Function: complex long double casinl (complex long double z)

These functions compute the complex arc sine of z---that is, the value whose sine is z. The value returned is in radians.

Unlike the real-valued functions, casin is defined for all values of z.

Function: complex double cacos (complex double z)

Function: complex float cacosf (complex float z)

Function: complex long double cacosl (complex long double z)

These functions compute the complex arc cosine of z---that is, the value whose cosine is z. The value returned is in radians.

Unlike the real-valued functions, cacos is defined for all values of z.

Function: complex double catan (complex double z)

Function: complex float catanf (complex float z)

Function: complex long double catanl (complex long double z)

These functions compute the complex arc tangent of z---that is, the value whose tangent is z. The value is in units of radians.

Exponentiation and Logarithms

Function: double exp (double x)

Function: float expf (float x)

Function: long double expl (long double x)

These functions compute e (the base of natural logarithms) raised to the power x.

If the magnitude of the result is too large to be representable, exp signals overflow.

Function: double exp2 (double x)

Function: float exp2f (float x)

Function: long double exp2l (long double x)

These functions compute 2 raised to the power x. Mathematically, exp2 (x) is the same as exp (x * log (2)).

Function: double exp10 (double x)

Function: float exp10f (float x)

Function: long double exp10l (long double x)

Function: double pow10 (double x)

Function: float pow10f (float x)

Function: long double pow10l (long double x)

These functions compute 10 raised to the power x. Mathematically, exp10 (x) is the same as exp (x * log (10)).

These functions are GNU extensions. The name exp10 is preferred, since it is analogous to exp and exp2.

Function: double log (double x)

Function: float logf (float x)

Function: long double logl (long double x)

These functions compute the natural logarithm of x. exp (log (x)) equals x, exactly in mathematics and approximately in C.

If x is negative, log signals a domain error. If x is zero, it returns negative infinity; if x is too close to zero, it may signal overflow.

Function: double log10 (double x)

Function: float log10f (float x)

Function: long double log10l (long double x)

These functions return the base-10 logarithm of x. log10 (x) equals log (x) / log (10).

Function: double log2 (double x)

Function: float log2f (float x)

Function: long double log2l (long double x)

These functions return the base-2 logarithm of x. log2 (x) equals log (x) / log (2).

Function: double logb (double x)

Function: float logbf (float x)

Function: long double logbl (long double x)

These functions extract the exponent of x and return it as a floating-point value. If FLT_RADIX is two, logb is equal to floor (log2 (x)), except it's probably faster.

If x is de-normalized, logb returns the exponent x would have if it were normalized. If x is infinity (positive or negative), logb returns @math{@infinity{}}. If x is zero, logb returns @math{@infinity{}}. It does not signal.

Function: int ilogb (double x)

Function: int ilogbf (float x)

Function: int ilogbl (long double x)

These functions are equivalent to the corresponding logb functions except that they return signed integer values.

Since integers cannot represent infinity and NaN, ilogb instead returns an integer that can't be the exponent of a normal floating-point number. `math.h' defines constants so you can check for this.

Macro: int FP_ILOGB0

ilogb returns this value if its argument is 0. The numeric value is either INT_MIN or -INT_MAX.

This macro is defined in ISO C99.

Macro: int FP_ILOGBNAN

ilogb returns this value if its argument is NaN. The numeric value is either INT_MIN or INT_MAX.

This macro is defined in ISO C99.

These values are system specific. They might even be the same. The proper way to test the result of ilogb is as follows:

i = ilogb (f);
if (i == FP_ILOGB0 || i == FP_ILOGBNAN)
  {
    if (isnan (f))
      {
        /* Handle NaN.  */
      }
    else if (f  == 0.0)
      {
        /* Handle 0.0.  */
      }
    else
      {
        /* Some other value with large exponent,
           perhaps +Inf.  */
      }
  }

Function: double pow (double base, double power)

Function: float powf (float base, float power)

Function: long double powl (long double base, long double power)

These are general exponentiation functions, returning base raised to power.

Mathematically, pow would return a complex number when base is negative and power is not an integral value. pow can't do that, so instead it signals a domain error. pow may also underflow or overflow the destination type.

Function: double sqrt (double x)

Function: float sqrtf (float x)

Function: long double sqrtl (long double x)

These functions return the nonnegative square root of x.

If x is negative, sqrt signals a domain error. Mathematically, it should return a complex number.

Function: double cbrt (double x)

Function: float cbrtf (float x)

Function: long double cbrtl (long double x)

These functions return the cube root of x. They cannot fail; every representable real value has a representable real cube root.

Function: double hypot (double x, double y)

Function: float hypotf (float x, float y)

Function: long double hypotl (long double x, long double y)

These functions return sqrt (x*x + y*y). This is the length of the hypotenuse of a right triangle with sides of length x and y, or the distance of the point (x, y) from the origin. Using this function instead of the direct formula is wise, since the error is much smaller. See also the function cabs in section Absolute Value.

Function: double expm1 (double x)

Function: float expm1f (float x)

Function: long double expm1l (long double x)

These functions return a value equivalent to exp (x) - 1. They are computed in a way that is accurate even if x is near zero--a case where exp (x) - 1 would be inaccurate owing to subtraction of two numbers that are nearly equal.

Function: double log1p (double x)

Function: float log1pf (float x)

Function: long double log1pl (long double x)

These functions returns a value equivalent to log (1 + x). They are computed in a way that is accurate even if x is near zero.

ISO C99 defines complex variants of some of the exponentiation and logarithm functions.

Function: complex double cexp (complex double z)

Function: complex float cexpf (complex float z)

Function: complex long double cexpl (complex long double z)

These functions return e (the base of natural logarithms) raised to the power of z. Mathematically, this corresponds to the value

@ifnottex @math{exp (z) = exp (creal (z)) * (cos (cimag (z)) + I * sin (cimag (z)))}

Function: complex double clog (complex double z)

Function: complex float clogf (complex float z)

Function: complex long double clogl (complex long double z)

These functions return the natural logarithm of z. Mathematically, this corresponds to the value

@ifnottex @math{log (z) = log (cabs (z)) + I * carg (z)}

clog has a pole at 0, and will signal overflow if z equals or is very close to 0. It is well-defined for all other values of z.

Function: complex double clog10 (complex double z)

Function: complex float clog10f (complex float z)

Function: complex long double clog10l (complex long double z)

These functions return the base 10 logarithm of the complex value z. Mathematically, this corresponds to the value

@ifnottex @math{log (z) = log10 (cabs (z)) + I * carg (z)}

These functions are GNU extensions.

Function: complex double csqrt (complex double z)

Function: complex float csqrtf (complex float z)

Function: complex long double csqrtl (complex long double z)

These functions return the complex square root of the argument z. Unlike the real-valued functions, they are defined for all values of z.

Function: complex double cpow (complex double base, complex double power)

Function: complex float cpowf (complex float base, complex float power)

Function: complex long double cpowl (complex long double base, complex long double power)

These functions return base raised to the power of power. This is equivalent to cexp (y * clog (x))

Hyperbolic Functions

The functions in this section are related to the exponential functions; see section Exponentiation and Logarithms.

Function: double sinh (double x)

Function: float sinhf (float x)

Function: long double sinhl (long double x)

These functions return the hyperbolic sine of x, defined mathematically as (exp (x) - exp (-x)) / 2. They may signal overflow if x is too large.

Function: double cosh (double x)

Function: float coshf (float x)

Function: long double coshl (long double x)

These function return the hyperbolic cosine of x, defined mathematically as (exp (x) + exp (-x)) / 2. They may signal overflow if x is too large.

Function: double tanh (double x)

Function: float tanhf (float x)

Function: long double tanhl (long double x)

These functions return the hyperbolic tangent of x, defined mathematically as sinh (x) / cosh (x). They may signal overflow if x is too large.

There are counterparts for the hyperbolic functions which take complex arguments.

Function: complex double csinh (complex double z)

Function: complex float csinhf (complex float z)

Function: complex long double csinhl (complex long double z)

These functions return the complex hyperbolic sine of z, defined mathematically as (exp (z) - exp (-z)) / 2.

Function: complex double ccosh (complex double z)

Function: complex float ccoshf (complex float z)

Function: complex long double ccoshl (complex long double z)

These functions return the complex hyperbolic cosine of z, defined mathematically as (exp (z) + exp (-z)) / 2.

Function: complex double ctanh (complex double z)

Function: complex float ctanhf (complex float z)

Function: complex long double ctanhl (complex long double z)

These functions return the complex hyperbolic tangent of z, defined mathematically as csinh (z) / ccosh (z).

Function: double asinh (double x)

Function: float asinhf (float x)

Function: long double asinhl (long double x)

These functions return the inverse hyperbolic sine of x---the value whose hyperbolic sine is x.

Function: double acosh (double x)

Function: float acoshf (float x)

Function: long double acoshl (long double x)

These functions return the inverse hyperbolic cosine of x---the value whose hyperbolic cosine is x. If x is less than 1, acosh signals a domain error.

Function: double atanh (double x)

Function: float atanhf (float x)

Function: long double atanhl (long double x)

These functions return the inverse hyperbolic tangent of x---the value whose hyperbolic tangent is x. If the absolute value of x is greater than 1, atanh signals a domain error; if it is equal to 1, atanh returns infinity.

Function: complex double casinh (complex double z)

Function: complex float casinhf (complex float z)

Function: complex long double casinhl (complex long double z)

These functions return the inverse complex hyperbolic sine of z---the value whose complex hyperbolic sine is z.

Function: complex double cacosh (complex double z)

Function: complex float cacoshf (complex float z)

Function: complex long double cacoshl (complex long double z)

These functions return the inverse complex hyperbolic cosine of z---the value whose complex hyperbolic cosine is z. Unlike the real-valued functions, there are no restrictions on the value of z.

Function: complex double catanh (complex double z)

Function: complex float catanhf (complex float z)

Function: complex long double catanhl (complex long double z)

These functions return the inverse complex hyperbolic tangent of z---the value whose complex hyperbolic tangent is z. Unlike the real-valued functions, there are no restrictions on the value of z.

Special Functions

These are some more exotic mathematical functions which are sometimes useful. Currently they only have real-valued versions.

Function: double erf (double x)

Function: float erff (float x)

Function: long double erfl (long double x)

erf returns the error function of x. The error function is defined as @ifnottex

erf (x) = 2/sqrt(pi) * integral from 0 to x of exp(-t^2) dt

Function: double erfc (double x)

Function: float erfcf (float x)

Function: long double erfcl (long double x)

erfc returns 1.0 - erf(x), but computed in a fashion that avoids round-off error when x is large.

Function: double lgamma (double x)

Function: float lgammaf (float x)

Function: long double lgammal (long double x)

lgamma returns the natural logarithm of the absolute value of the gamma function of x. The gamma function is defined as @ifnottex

gamma (x) = integral from 0 to @infinity{} of t^(x-1) e^-t dt

The sign of the gamma function is stored in the global variable signgam, which is declared in `math.h'. It is 1 if the intermediate result was positive or zero, or -1 if it was negative.

To compute the real gamma function you can use the tgamma function or you can compute the values as follows:

lgam = lgamma(x);
gam  = signgam*exp(lgam);

The gamma function has singularities at the non-positive integers. lgamma will raise the zero divide exception if evaluated at a singularity.

Function: double lgamma_r (double x, int *signp)

Function: float lgammaf_r (float x, int *signp)

Function: long double lgammal_r (long double x, int *signp)

lgamma_r is just like lgamma, but it stores the sign of the intermediate result in the variable pointed to by signp instead of in the signgam global. This means it is reentrant.

Function: double gamma (double x)

Function: float gammaf (float x)

Function: long double gammal (long double x)

These functions exist for compatibility reasons. They are equivalent to lgamma etc. It is better to use lgamma since for one the name reflects better the actual computation, moreover lgamma is standardized in ISO C99 while gamma is not.

Function: double tgamma (double x)

Function: float tgammaf (float x)

Function: long double tgammal (long double x)

tgamma applies the gamma function to x. The gamma function is defined as @ifnottex

gamma (x) = integral from 0 to @infinity{} of t^(x-1) e^-t dt

This function was introduced in ISO C99.

Function: double j0 (double x)

Function: float j0f (float x)

Function: long double j0l (long double x)

j0 returns the Bessel function of the first kind of order 0 of x. It may signal underflow if x is too large.

Function: double j1 (double x)

Function: float j1f (float x)

Function: long double j1l (long double x)

j1 returns the Bessel function of the first kind of order 1 of x. It may signal underflow if x is too large.

Function: double jn (int n, double x)

Function: float jnf (int n, float x)

Function: long double jnl (int n, long double x)

jn returns the Bessel function of the first kind of order n of x. It may signal underflow if x is too large.

Function: double y0 (double x)

Function: float y0f (float x)

Function: long double y0l (long double x)

y0 returns the Bessel function of the second kind of order 0 of x. It may signal underflow if x is too large. If x is negative, y0 signals a domain error; if it is zero, y0 signals overflow and returns @math{-@infinity}.

Function: double y1 (double x)

Function: float y1f (float x)

Function: long double y1l (long double x)

y1 returns the Bessel function of the second kind of order 1 of x. It may signal underflow if x is too large. If x is negative, y1 signals a domain error; if it is zero, y1 signals overflow and returns @math{-@infinity}.

Function: double yn (int n, double x)

Function: float ynf (int n, float x)

Function: long double ynl (int n, long double x)

yn returns the Bessel function of the second kind of order n of x. It may signal underflow if x is too large. If x is negative, yn signals a domain error; if it is zero, yn signals overflow and returns @math{-@infinity}.

Known Maximum Errors in Math Functions

This section lists the known errors of the functions in the math library. Errors are measured in "units of the last place". This is a measure for the relative error. For a number @math{z} with the representation @math{d.d...d@mul{}2^e} (we assume IEEE floating-point numbers with base 2) the ULP is represented by

@ifnottex

|d.d...d - (z / 2^e)| / 2^(p - 1)

where @math{p} is the number of bits in the mantissa of the floating-point number representation. Ideally the error for all functions is always less than 0.5ulps. Using rounding bits this is also possible and normally implemented for the basic operations. To achieve the same for the complex math functions requires a lot more work and this was not spend so far.

Therefore many of the functions in the math library have errors. The table lists the maximum error for each function which is exposed by one of the existing tests in the test suite. It is tried to cover as much as possible and really list the maximum error (or at least a ballpark figure) but this is often not achieved due to the large search space.

The table lists the ULP values for different architectures. Different architectures have different results since their hardware support for floating-point operations varies and also the existing hardware support is different.

@multitable {nexttowardf} {1000 + i 1000} {1000 + i 1000} {1000 + i 1000} {1000 + i 1000} {1000 + i 1000} {1000 + i 1000} {1000 + i 1000} {1000 + i 1000} {1000 + i 1000} {1000 + i 1000} {1000 + i 1000} {1000 + i 1000}

Y = (a * X + c) mod m

a = 0x5DEECE66D = 25214903917
c = 0xb = 11

memset (buffer, '\0', sizeof (struct drand48_data));