ACOSH

What it does

ACOSH(number)

ACOSH(number) is the inverse hyperbolic cosine: the non-negative value whose hyperbolic cosine is number.

acosh x  =  ln( x + sqrt(x^2 - 1) ),    x >= 1

• Domain: [1, +infinity). cosh maps R onto [1, +infinity) and is two-to-one, so the inverse requires a branch choice; the principal branch takes the non-negative one. Below 1 there is no real value at all — cosh never goes there.
• Range: [0, +infinity). acosh(1) = 0 is the branch point.
• Not odd, not even: the function is defined only on a half-line, so parity is not available. This is the structural difference from ASINH and ATANH, both of which are odd on symmetric domains, and it is why ACOSH is the awkward member of the trio.
• Derivative: d/dx acosh x = 1 / sqrt(x^2 - 1), which is infinite at x = 1 and decays like 1/x. Vertical tangent at the left endpoint; logarithmic flattening at the right.
• Endpoint behaviour: with x = 1 + t, acosh(1 + t) = sqrt(2t) * (1 - t/12 + 3t^2/160 - ...). The same square-root singularity that governs ACOS at its endpoints governs ACOSH at 1, and for the same reason — the inverse of a function with a quadratic minimum.
• Asymptotic behaviour: acosh x = ln(2x) - 1/(4x^2) - ... as x -> +infinity. Growth is logarithmic, so the whole upper half of the double range maps into a narrow band of results: at the top of binary64 the answer is a little over 710. Every argument from about 1e100 to the largest finite double produces an answer between roughly 230 and 711.
• Relations: acosh x = |asinh(sqrt(x^2 - 1))| and acosh x = atanh(sqrt(x^2-1)/x); also acosh(cosh t) = |t|, which is the round trip Microsoft's Learn reference states (as Acosh(Cosh(number)) equalling the number — true for non-negative arguments, and the absolute value is the part the documentation leaves out).
• Complex continuation: acosh extends to the plane with a branch cut along (-infinity, 1]. The real domain is exactly the complement of that cut on the real axis.

Abramowitz & Stegun give the logarithmic closed forms for the inverse hyperbolic functions in chapter 4 section 4.6.

Arguments

That wording is Microsoft's: the Learn reference describes the argument as "any real number equal to or greater than 1", and the description repeats that number must be greater than or equal to 1.

The misunderstood position is the lower bound. Readers who arrive from ASINH, which accepts every real, or from ACOS, whose domain is [-1, 1], routinely pass a value in (0, 1) and are surprised by a domain failure. [1, infinity) is the complement of ACOS's domain on the positive axis, and the two functions share exactly one point.

Try it

Quirks

Result and edge cases

Returns Number.

• x = 1 is in the domain and returns zero. The interval is closed on the left; an implementation testing x > 1 gets the branch point wrong.
• Just below 1 — one ulp under — is a domain failure. This is a real hazard because the natural producer of ACOSH arguments is a ratio that should be at least one and, after rounding, sometimes is not.
• Just above 1 is where the square-root singularity lives, and where a naive implementation loses half its significant digits. See the numerical notes.
• Very large arguments are all admissible: the mathematical result stays finite and small right up to the largest finite double. Whether an implementation delivers it there is the interesting question, because the naive closed form squares the argument first.
• Arrays lift elementwise, with out-of-domain elements producing element-local errors.

How to implement

Numerical notes

The closed form ln(x + sqrt(x^2 - 1)) is correct mathematics and, evaluated literally, a poor program. It fails at both ends of the domain, in different ways, and both failures have standard remedies.

Failure one: cancellation at the left endpoint. For x just above 1, x^2 - 1 is a subtraction of two nearly equal numbers. Worse, x^2 has already rounded, so bits are lost before the subtraction even happens. The correct answer near 1 is sqrt(2t) with t = x - 1; the naive form computes a square root of a quantity that has lost roughly half its significant digits, so the result loses about half of its own. The remedy is to factor:

x^2 - 1 = (x - 1)(x + 1) = t(t + 2)

and to write the whole thing through log1p:

acosh(1 + t) = log1p( t + sqrt(t*(t + 2)) )

Here 1 + t is never formed, t is exact when x is a double near 1 (Sterbenz), and the logarithm's own near-one cancellation is handled by log1p rather than by ln. Both remedies — factoring the difference of squares and using log1p — are needed; either alone leaves half the problem in place. Higham's discussion of log(1+x) is the standard statement of the second half.

Failure two: overflow in the intermediate at the right end. The literal form squares x first. x^2 overflows binary64 once x exceeds about 1.34e154 — the square root of the largest finite double — while the true acosh(x) at that point is a perfectly ordinary number near 355, and stays finite and small all the way to the top of the double range. So the naive form has an entire band of arguments, spanning more than half of the exponent range, on which the mathematics is representable and the program is not. The remedy is a branch: for x large enough that x^2 - 1 would round to x^2 anyway,

acosh(x) = ln(x) + ln(2)

evaluated without ever forming x^2. fdlibm's e_acosh.c implements exactly this three-branch structure — log1p form near 1, the closed form in the middle, ln(2x) at the top — and it is the shape any careful implementation converges on.

Where the branches go. The conventional cut points are x < 2 for the log1p branch and x > 2^28 (or thereabouts) for the ln(2x) branch, with the closed form in between. The exact choices differ between libraries, and the residual profile of an implementation against a high-precision reference makes them visible as steps — which is precisely how upstream identification work has read other surfaces in this family.

What this page does not claim. Nothing above says what Excel computes. ASINH's substrate has been identified upstream as the literal ln(x + sqrt(x^2+1)) — see that page and its evidence record — which makes the same question live for ACOSH; but no identification for ACOSH exists in the Handbook's record, and the two functions could easily be implemented by different code.

A self-test that needs no oracle. ACOSH(COSH(t)) should return |t|. Run it across t from subnormal to about 710. Where it stops round-tripping, and how it fails there, distinguishes the branch structures described above without any external reference.

Rust code

2 acosh "ACOSH" (1, 1) [V "number"] |s, a, sv| { unary(s, a, k::acosh::acosh_kernel) }

pub fn acosh_kernel(n: f64) -> Result<f64, WorksheetErrorCode> {
    if n < 1.0 {
        return Err(WorksheetErrorCode::Num);
    }
    // Inverse-problem identity, live Excel 16.0 b20228 Range.Value2:
    // ACOSH(x) == LN(x+SQRT(x*x-1)) on 29/29 including 1, 1+1ulp, and
    // large finite x. SQRT((x-1)*(x+1)) is not the graph (18/24).
    // When x*x overflows, Excel publishes #NUM! (ACOSH(1e200)), the same
    // intermediate overflow ASINH uses.
    if !(n * n).is_finite() {
        return Err(WorksheetErrorCode::Num);
    }
    Ok(crate::ported::excel_numeric::excel_log(n + (n * n - 1.0).sqrt()))
}

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-ACOSH-001: build 19929 versus build 20430; 1 same-input pairs, 0 differing answers. Compared axes: excel-build. Numeric answers were compared by their recorded binary64 bits; other answers by typed value.
• XC-ACOSH-002: build 19929 versus build 20430; 1 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

• COSH — the forward function. ACOSH(COSH(t)) = |t|; the absolute value is the branch choice made visible, and it is the part of the round trip the documentation omits.
• ATANH — the third inverse hyperbolic primary, defined on (-1, 1). Between them the three cover (-1,1), R, and [1,infinity); ACOSH and ATANH have complementary domains that meet only at ±1, where ATANH has poles and ACOSH a branch point.
• ACOTH — defined on |x| > 1, so it shares ACOSH's exclusion of the unit interval but on both sides.
• ACOS — the circular namesake, and the complementary domain: [-1, 1] versus [1, infinity). Both vanish at x = 1 and both have a square-root approach to it. They are genuinely two halves of one complex function restricted to the real axis.
• LN and SQRT — the substrate of every closed-form evaluation, and the source of both hazards.
• Confused with: ACOS, by name; and with 1/COSH, by readers expecting the "inverse" in "inverse hyperbolic cosine" to mean a reciprocal. It does not — SECH is the reciprocal.

Named variants

No named variants are recorded yet.