COSH

What it does

COSH(number)

COSH(number) returns the hyperbolic cosine. Microsoft's page gives the defining formula:

cosh x = (e^x + e^-x) / 2

It is the even part of the exponential function; sinh is the odd part, and e^x = cosh x + sinh x is the decomposition.

The catenary is the physical reading: a uniform chain hanging under gravity takes the shape y = a·cosh(x/a). That is also why COSH shows up in engineering spreadsheets far more often than its siblings.

Two numbers fix the practical boundary. cosh x exceeds the largest finite binary64 when |x| passes roughly 709.78 + ln 2 ≈ 710.4758; and cosh x is indistinguishable from e^{|x|}/2 in binary64 once |x| is above about 22, because the e^{-|x|} term has fallen below half an ulp of the result.

Arguments

Note the contrast with the newer hyperbolic surfaces: COTH and CSCH carry a documented |number| < 2^27 constraint on their pages, and COSH — a much older function — carries none.

Try it

Quirks

Result and edge cases

Returns Number in [1, ∞).

• Zero — COSH(0) = 1, exactly, and this is the function's minimum.
• Sign — the result never depends on the sign of the argument.
• Never below 1. An implementation that returns a value slightly under 1 for a tiny argument has a cancellation bug; the correct evaluation cannot do it. This is the cheapest self-check on the whole page.
• The gap between e^709 and cosh(710). A naive implementation that computes EXP(x) first overflows about ln 2 earlier than the true function does. There is a narrow band of arguments where the mathematically representable answer is lost to the algorithm rather than to the format. Whether Excel's answer covers that band is unchecked.

Errors

Microsoft's COSH page documents no error conditions.

That second row is the honest statement of what is known: the FINITE convention is on record with witnesses, and the boundary between the last #NUM!-free argument and the first #NUM! argument has not been located.

How to implement

Numerical notes

Hyperbolic cosine has no cancellation problem — the two terms of (e^x + e^-x)/2 are both positive — and no reduction problem. Its whole difficulty is range.

The standard branch structure, essentially as in fdlibm's e_cosh.c and Cephes' cosh.c:

1. Tiny |x| (below about 2^-27): return 1. The correction term is below half an ulp.
2. Small |x| (up to about ln 2 / 2): use t = expm1(|x|) and evaluate cosh x = 1 + t²/(2(1+t)). The point is accuracy in the correction, not in the result: computing (e^x + e^-x)/2 directly here is stable in the result but computes the deviation from 1 poorly, and the deviation is what a caller who then subtracts 1 actually wants. (Excel has no COSHM1, so a spreadsheet user computing COSH(x)-1 for small x gets the cancellation regardless of how good COSH is. The remedy in a worksheet is the series x²/2 + x⁴/24, not a better COSH.)
3. Moderate |x| (up to about 22): t = e^{|x|}; return (t + 1/t)/2.
4. Large |x| (up to the overflow threshold of e): return e^{|x|}/2; the reciprocal term is below the rounding of the result.
5. Near the top (|x| between ln(DBL_MAX) and ln(2·DBL_MAX)): e^{|x|} itself overflows even though cosh x does not. The standard trick is w = e^{|x|/2}, return (w/2)·w — two representable halves multiplied at the end. Skipping this step costs the function its top ln 2 of range, which is the band named above.

A&S chapter 4.5 gives the identity set; 4.5.64 onwards gives the classical polynomial approximations. The accuracy of any of these branches is inherited from EXP, which is why EV-MATH-0001's identification of the exponential's substrate (on the EXP page) is the most relevant external fact about this surface — even though EV-MATH-0001 does not name COSH and nothing from it may be attributed here.

Rust code

11 cosh "COSH" (1, 1) [V "number"] |s, a, sv| {
    raw(s, a, ExcelRealPolicy::FINITE, k::cosh::cosh_kernel)
}

No implementation has been published with a Handbook test suite for this function.

Version differences

The recorded environments below distinguish a reading from a same-input comparison. Counts describe captured inputs in each environment; overlapping captures and comparisons are not totals of unique worksheet calls.

• XC-COSH-001: build 19929 versus build 20430; 2 same-input pairs, 0 differing answers. Compared axes: excel-build. Numeric answers were compared by their recorded binary64 bits; other answers by typed value.

Agreement on these compared inputs does not establish agreement on unmeasured inputs.

Recorded environments and comparison details.

Alternatives

Relationships

• SINH — the odd partner. SINH has a cancellation problem near zero that COSH does not have, and the same overflow problem at large arguments. EV-MATH-0008 names both.
• TANH — sinh/cosh, bounded by 1, and the numerically well-behaved member.
• SECH — the reciprocal 1/COSH, which underflows smoothly to zero where COSH overflows: the reciprocal pair is not symmetric in difficulty.
• COTH, CSCH — the 2013-generation hyperbolic reciprocals, with documented magnitude constraints that COSH does not carry.
• ACOSH — the inverse on [1, ∞), principal branch. ACOSH(COSH(x)) = |x|, which is the useful metamorphic identity here precisely because it exposes the evenness.
• EXP — the substrate in every plausible implementation, and the surface whose evaluation route has actually been identified. Anything learned about EXP transfers here.
• COS — cosh x = cos(ix). Related in name and in theory; opposite in every computational respect.
• IMCOSH — the complex version.

Named variants

No named variants are recorded yet.