cosh.c File Reference

Hyperbolic cosine function. More...

#include "prim.h"

Include dependency graph for cosh.c:

Go to the source code of this file.

Functions
double	cosh (double x)
	Hyperbolic cosine function. More...

Variables
static const double	one = 1.0
static const double	half = 0.5
static const double	huge = 1.0e300

Detailed Description

Hyperbolic cosine function.

Definition in file cosh.c.

Function Documentation

cosh()

double cosh

(

double

x

)

Hyperbolic cosine function.

Mathematically cosh(x) if defined to be (exp(x)+exp(-x))/2

Method
1. Replace x by |x| (cosh(x) = cosh(-x))
2.
                                              [ exp(x) - 1 ]^2
   0        <= x <= ln2/2  :  cosh(x) := 1 + -------------------
                                                2*exp(x)

                                         exp(x) +  1/exp(x)
   ln2/2    <= x <= 22     :  cosh(x) := -------------------
                                                 2
   22       <= x <= lnovft :  cosh(x) := exp(x)/2
   lnovft   <= x <= ln2ovft:  cosh(x) := exp(x/2)/2 * exp(x/2)
   ln2ovft  <  x           :  cosh(x) := huge*huge (overflow)

Special cases:
cosh(x) is |x| if x is +INF, -INF, or NaN
only cosh(0)=1 is exact for finite x

Definition at line 83 of file cosh.c.

References exp(), expm1(), fabs(), half, huge, and one.

Referenced by cchc(), cchsh(), ccot(), ccoth(), ccsc(), ccsch(), coth(), csec(), csech(), ctan(), ctanh(), RealNumber::HypCosine(), and sech().

{
    double t, w;
    int32_t ix;
    uint32_t lx;

    // High word of |x|
    GET_HIGH_WORD(ix, x);
    ix &= 0x7FFFFFFF;

    // x is INF or NaN
    if (ix >= 0x7FF00000)
    {
        return x * x;
    }

    // |x| in [0,0.5*ln2]
    if (ix < 0x3FD62E43)
    {
        t = expm1(fabs(x));
        w = one + t;
        if (ix < 0x3C800000)
        {
            // cosh(tiny) = 1
            return w;
        }

        return one + (t * t) / (w + w);
    }

    // |x| in [0.5*ln2,22]
    if (ix < 0x40360000)
    {
        t = exp(fabs(x));
        return half * t + half / t;
    }

    // |x| in [22, log(maxdouble)]
    if (ix < 0x40862E42)
    {
        return half * exp(fabs(x));
    }

    // |x| in [log(maxdouble), overflowthresold]
    lx = *((((*(unsigned *)&one) >> 29)) + (unsigned *)&x);
    if (ix < 0x408633CE || ((ix == 0x408633CE) && (lx <= (unsigned)0x8FB9F87D)))
    {
        w = exp(half * fabs(x));
        t = half * w;
        return t * w;
    }

    // |x| > overflowthresold, cosh(x) overflow
    return huge * huge;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

half

const double half = 0.5

static

Definition at line 54 of file cosh.c.

Referenced by cosh().

huge

const double huge = 1.0e300

static

Definition at line 55 of file cosh.c.

Referenced by cosh().

one

const double one = 1.0

static

Definition at line 53 of file cosh.c.

Referenced by cosh().