For complex numbers, abs(z) = sqrt( z.re 2 + z.im 2 ) = hypot(z.re, z.im).
x | acos(x) | invalid? |
---|---|---|
>1.0 | NAN | yes |
<-1.0 | NAN | yes |
NAN | NAN | yes |
Mathematically, acosh(x) = log(x + sqrt( x*x - 1))
x | acosh(x) |
---|---|
NAN | NAN |
<1 | NAN |
1 | 0 |
+∞ | +∞ |
x | asin(x) | invalid? |
---|---|---|
±0.0 | ±0.0 | no |
>1.0 | NAN | yes |
<-1.0 | NAN | yes |
Mathematically,
x | asinh(x) |
---|---|
NAN | NAN |
±0 | ±0 |
±∞ | ±∞ |
x | atan(x) | invalid? |
---|---|---|
±0.0 | ±0.0 | no |
±∞ | NAN | yes |
y | x | atan(y, x) |
---|---|---|
NAN | anything | NAN |
anything | NAN | NAN |
±0.0 | >0.0 | ±0.0 |
±0.0 | +0.0 | ±0.0 |
±0.0 | <0.0 | ±π |
±0.0 | -0.0 | ±π |
>0.0 | ±0.0 | π/2 |
<0.0 | ±0.0 | -π/2 |
>0.0 | ∞ | ±0.0 |
±∞ | anything | ±π/2 |
>0.0 | -∞ | ±π |
±∞ | ∞ | ±π/4 |
±∞ | -∞ | ±3π/4 |
Mathematically, atanh(x) = log( (1+x)/(1-x) ) / 2
x | acosh(x) |
---|---|
NAN | NAN |
±0 | ±0 |
-∞ | -0 |
x | cbrt(x) | invalid? |
---|---|---|
±0.0 | ±0.0 | no |
NAN | NAN | yes |
±∞ | ±∞ | no |
conj(x + iy) = x - iy
Note that z * conj(z) = z.re 2 - z.im 2 is always a real number
x | cos(x) | invalid? |
---|---|---|
NAN | NAN | yes |
±∞ | NAN | yes |
x | cosh(x) | invalid? |
---|---|---|
±∞ | ±0.0 | no |
x | ex | +∞ | +∞ |
---|
x | exp2(x) | +∞ | +∞ | -∞ | +0.0 |
---|
On many CPUs (such as x86), this is a very efficient operation; almost twice as fast as calculating sin(y) and cos(y) separately, and is the preferred method when both are required.
For very small x, expm1(x) is more accurate than exp(x)-1.
x | ex-1 |
---|---|
±0.0 | ±0.0 | +∞ | +∞ |
x | fabs(x) |
---|---|
±0.0 | +0.0 |
±∞ | +∞ |
x, y | fdim(x, y) |
---|---|
x > y | x - y |
x <= y | +0.0 |
x | y | feqrel(x, y) |
---|---|---|
x | x | real.mant_dig |
x | >= 2*x | 0 |
x | <= x/2 | 0 |
NAN | any | 0 |
any | NAN | 0 |
value | returns | exp |
---|---|---|
±0.0 | ±0.0 | 0 |
+∞ | +∞ | int.max |
-∞ | -∞ | int.min |
±NAN | ±NAN | int.min |
sqrt( + )
Note that hypot(x, y), hypot(y, x) and hypot(x, -y) are equivalent.
x | y | hypot(x, y) | invalid? |
---|---|---|---|
x | ±0.0 | |x| | no |
±∞ | y | +∞ | no |
±∞ | NAN | +∞ | no |
If x is not a special value, the result is the same as .
x | ilogb(x) | Range error? |
---|---|---|
0 | FP_ILOGB0 | yes |
±∞ | int.max | no |
NAN | FP_ILOGBNAN | no |
Same as ==, except that positive and negative zero are not identical, and two NANs are identical if they have the same 'payload'.
Returns the base e (2.718...) logarithm of the absolute value of the gamma function of the argument.
For reals, lgamma is equivalent to log(fabs(gamma(x))).
x | lgamma(x) | invalid? |
---|---|---|
NAN | NAN | yes |
integer <= 0 | +∞ | yes |
±∞ | +∞ | no |
x | log(x) | divide by 0? | invalid? |
---|---|---|---|
±0.0 | -∞ | yes | no |
<0.0 | NAN | no | yes |
+∞ | +∞ | no | no |
x | log10(x) | divide by 0? | invalid? |
---|---|---|---|
±0.0 | -∞ | yes | no |
<0.0 | NAN | no | yes |
+∞ | +∞ | no | no |
For very small x, log1p(x) will be more accurate than log(1 + x).
x | log1p(x) | divide by 0? | invalid? |
---|---|---|---|
±0.0 | ±0.0 | no | no |
-1.0 | -∞ | yes | no |
<-1.0 | NAN | no | yes |
+∞ | -∞ | no | no |
x | log2(x) | divide by 0? | invalid? |
---|---|---|---|
±0.0 | -∞ | yes | no |
<0.0 | NAN | no | yes |
+∞ | +∞ | no | no |
If x is subnormal, it is treated as if it were normalized. For a positive, finite x:
1 <= x * FLT_RADIX-logb(x) < FLT_RADIX
x | logb(x) | divide by 0? |
---|---|---|
±∞ | +∞ | no |
±0.0 | -∞ | yes |
This is generally the fastest method to convert a floating-point number to an integer. Note that the results from this function depend on the rounding mode, if the fractional part of x is exactly 0.5. If using the default rounding mode (ties round to even integers) lrint(4.5) == 4, lrint(5.5)==6.
If the fractional part of x is exactly 0.5, the return value is rounded away from zero.
x | y | modf(x, y) | invalid? |
---|---|---|---|
±0.0 | not 0.0 | ±0.0 | no |
±∞ | anything | NAN | yes |
anything | ±0.0 | NAN | yes |
!=±∞ | ±∞ | x | no |
Unlike the rint functions, nearbyint does not raise the FE_INEXACT exception.
If y > x, the result will be the next largest floating-point value; if y < x, the result will be the next smallest value. If x == y, the result is y.
Return the greatest number less than x that is representable as a real; thus, it gives the previous point on the IEEE number line.
x | nextDown(x) |
---|---|
∞ | real.max |
±0.0 | -real.min*real.epsilon |
-real.max | -∞ |
-∞ | -∞ |
NAN | NAN |
Return the least number greater than x that is representable as a real; thus, it gives the next point on the IEEE number line.
x | nextUp(x) |
---|---|
-∞ | -real.max |
±0.0 | real.min*real.epsilon |
real.max | ∞ |
∞ | ∞ |
NAN | NAN |
Uses Horner's rule A(x) = a 0 + x(a 1 + x(a 2 + x(a 3 + ...)))
REM is the value of x - y * n, where n is the integer nearest the exact value of x / y. If |n - x / y| == 0.5, n is even. If the result is zero, it has the same sign as x. Otherwise, the sign of the result is the sign of x / y. Precision mode has no effect on the remainder functions.
remquo returns n in the parameter n.
x | y | remainder(x, y) | n | invalid? |
---|---|---|---|---|
±0.0 | not 0.0 | ±0.0 | 0.0 | no |
±∞ | anything | NAN | ? | yes |
anything | ±0.0 | NAN | ? | yes |
!= ±∞ | ±∞ | x | ? | no |
scalbn handles underflow and overflow in the same fashion as the basic arithmetic operators.
x | scalb(x) |
---|---|
±∞ | ±∞ |
±0.0 | ±0.0 |
x | sin(x) | invalid? |
---|---|---|
NAN | NAN | yes |
±0.0 | ±0.0 | no |
±∞ | NAN | yes |
x | sinh(x) | invalid? |
---|---|---|
±0.0 | ±0.0 | no |
±∞ | ±∞ | no |
x | sqrt(x) | invalid? |
---|---|---|
-0.0 | -0.0 | no |
<0.0 | NAN | yes |
+∞ | +∞ | no |
x | tan(x) | invalid? |
---|---|---|
NAN | NAN | yes |
±0.0 | ±0.0 | no |
±∞ | NAN | yes |
x | tanh(x) | invalid? |
---|---|---|
±0.0 | ±0.0 | no |
±∞ | ±1.0 | no |
Γ(x) is a generalisation of the factorial function to real and complex numbers. Like x!, Γ(x+1) = x*Γ(x).
Mathematically, if z.re > 0 then Γ(z) = ∫0 ∞ t z-1e -t dt
x | Γ(x) | invalid? |
---|---|---|
NAN | NAN | yes |
±0.0 | ±∞ | yes |
integer >0 | (x-1)! | no |
integer <0 | NAN | yes |
+∞ | +∞ | no |
-∞ | NAN | yes |
This is also known as "chop" rounding.