Mathematical Functions¶
This chapter describes basic mathematical functions. Some of these functions are present in system libraries, but the alternative versions given here can be used as a substitute when the system functions are not available.
The functions and macros described in this chapter are defined in the
header file gsl_math.h
.
Mathematical Constants¶
The library ensures that the standard BSD mathematical constants are defined. For reference, here is a list of the constants:

The base of exponentials, 

The base2 logarithm of , 

The base10 logarithm of , 

The square root of two, 

The square root of onehalf, 

The square root of three, 

The constant pi, 

Pi divided by two, 

Pi divided by four, 

The square root of pi, 

Two divided by the square root of pi, 

The reciprocal of pi, 

Twice the reciprocal of pi, 

The natural logarithm of ten, 

The natural logarithm of two, 

The natural logarithm of pi, 

Euler’s constant, 
Infinities and Notanumber¶

GSL_POSINF¶
This macro contains the IEEE representation of positive infinity, . It is computed from the expression
+1.0/0.0
.

GSL_NEGINF¶
This macro contains the IEEE representation of negative infinity, . It is computed from the expression
1.0/0.0
.

GSL_NAN¶
This macro contains the IEEE representation of the NotaNumber symbol,
NaN
. It is computed from the ratio0.0/0.0
.
Elementary Functions¶
The following routines provide portable implementations of functions
found in the BSD math library. When native versions are not available
the functions described here can be used instead. The substitution can
be made automatically if you use autoconf
to compile your
application (see Portability functions).

double gsl_log1p(const double x)¶
This function computes the value of in a way that is accurate for small
x
. It provides an alternative to the BSD math functionlog1p(x)
.

double gsl_expm1(const double x)¶
This function computes the value of in a way that is accurate for small
x
. It provides an alternative to the BSD math functionexpm1(x)
.

double gsl_hypot(const double x, const double y)¶
This function computes the value of in a way that avoids overflow. It provides an alternative to the BSD math function
hypot(x,y)
.

double gsl_hypot3(const double x, const double y, const double z)¶
This function computes the value of in a way that avoids overflow.

double gsl_acosh(const double x)¶
This function computes the value of . It provides an alternative to the standard math function
acosh(x)
.

double gsl_asinh(const double x)¶
This function computes the value of . It provides an alternative to the standard math function
asinh(x)
.

double gsl_atanh(const double x)¶
This function computes the value of . It provides an alternative to the standard math function
atanh(x)
.

double gsl_ldexp(double x, int e)¶
This function computes the value of . It provides an alternative to the standard math function
ldexp(x,e)
.
Small integer powers¶
A common complaint about the standard C library is its lack of a function for calculating (small) integer powers. GSL provides some simple functions to fill this gap. For reasons of efficiency, these functions do not check for overflow or underflow conditions.

double gsl_pow_int(double x, int n)¶

double gsl_pow_uint(double x, unsigned int n)¶
These routines computes the power for integer
n
. The power is computed efficiently—for example, is computed as , requiring only 3 multiplications. A version of this function which also computes the numerical error in the result is available asgsl_sf_pow_int_e()
.

double gsl_pow_2(const double x)¶

double gsl_pow_3(const double x)¶

double gsl_pow_4(const double x)¶

double gsl_pow_5(const double x)¶

double gsl_pow_6(const double x)¶

double gsl_pow_7(const double x)¶

double gsl_pow_8(const double x)¶

double gsl_pow_9(const double x)¶
These functions can be used to compute small integer powers , , etc. efficiently. The functions will be inlined when
HAVE_INLINE
is defined, so that use of these functions should be as efficient as explicitly writing the corresponding product expression:#include <gsl/gsl_math.h> double y = gsl_pow_4 (3.141) /* compute 3.141**4 */
Testing the Sign of Numbers¶

GSL_SIGN(x)¶
This macro returns the sign of
x
. It is defined as((x) >= 0 ? 1 : 1)
. Note that with this definition the sign of zero is positive (regardless of its IEEE sign bit).
Testing for Odd and Even Numbers¶

GSL_IS_ODD(n)¶
This macro evaluates to 1 if
n
is odd and 0 ifn
is even. The argumentn
must be of integer type.

GSL_IS_EVEN(n)¶
This macro is the opposite of
GSL_IS_ODD
. It evaluates to 1 ifn
is even and 0 ifn
is odd. The argumentn
must be of integer type.
Maximum and Minimum functions¶
Note that the following macros perform multiple evaluations of their arguments, so they should not be used with arguments that have side effects (such as a call to a random number generator).

GSL_MAX(a, b)¶
This macro returns the maximum of
a
andb
. It is defined as((a) > (b) ? (a):(b))
.

GSL_MIN(a, b)¶
This macro returns the minimum of
a
andb
. It is defined as((a) < (b) ? (a):(b))
.

extern inline double GSL_MAX_DBL(double a, double b)¶
This function returns the maximum of the double precision numbers
a
andb
using an inline function. The use of a function allows for type checking of the arguments as an extra safety feature. On platforms where inline functions are not available the macroGSL_MAX
will be automatically substituted.

extern inline double GSL_MIN_DBL(double a, double b)¶
This function returns the minimum of the double precision numbers
a
andb
using an inline function. The use of a function allows for type checking of the arguments as an extra safety feature. On platforms where inline functions are not available the macroGSL_MIN
will be automatically substituted.

extern inline int GSL_MAX_INT(int a, int b)¶

extern inline int GSL_MIN_INT(int a, int b)¶
These functions return the maximum or minimum of the integers
a
andb
using an inline function. On platforms where inline functions are not available the macrosGSL_MAX
orGSL_MIN
will be automatically substituted.

extern inline long double GSL_MAX_LDBL(long double a, long double b)¶

extern inline long double GSL_MIN_LDBL(long double a, long double b)¶
These functions return the maximum or minimum of the long doubles
a
andb
using an inline function. On platforms where inline functions are not available the macrosGSL_MAX
orGSL_MIN
will be automatically substituted.
Approximate Comparison of Floating Point Numbers¶
It is sometimes useful to be able to compare two floating point numbers approximately, to allow for rounding and truncation errors. The following function implements the approximate floatingpoint comparison algorithm proposed by D.E. Knuth in Section 4.2.2 of “Seminumerical Algorithms” (3rd edition).

int gsl_fcmp(double x, double y, double epsilon)¶
This function determines whether
x
andy
are approximately equal to a relative accuracyepsilon
.The relative accuracy is measured using an interval of size , where and is the maximum base2 exponent of and as computed by the function
frexp()
.If and lie within this interval, they are considered approximately equal and the function returns 0. Otherwise if , the function returns , or if , the function returns .
Note that and are compared to relative accuracy, so this function is not suitable for testing whether a value is approximately zero.
The implementation is based on the package
fcmp
by T.C. Belding.
Footnotes
 1
Note that the C99 standard only requires the system
isinf()
function to return a nonzero value, without the sign of the infinity. The implementation in some earlier versions of GSL used the systemisinf()
function and may have this behavior on some platforms. Therefore, it is advisable to test the sign ofx
separately, if needed, rather than relying the sign of the return value fromgsl_isinf()
.