ASINH

What it does

ASINH(number)

ASINH(number) is the inverse hyperbolic sine.

asinh x  =  ln( x + sqrt(x^2 + 1) )

• Domain: all real numbers. sinh is a strictly increasing bijection from R onto R, so its inverse needs no branch choice and has no domain restriction. Microsoft's Learn reference says exactly this: the argument is "any real number".
• Range: all real numbers.
• Parity: odd, exactly. asinh(-x) = -asinh(x). Because the square root is always at least |x|, the closed form above never cancels for positive x — but it cancels badly for negative x, which is why every implementation folds the sign. See the numerical notes.
• Monotonicity: strictly increasing everywhere.
• Derivative: d/dx asinh x = 1 / sqrt(x^2 + 1) — bounded by 1, positive, and smooth on the whole line. There are no singularities of any kind. ASINH is the best-conditioned function in its family and its difficulties are entirely about representation.
• Series about zero: asinh x = x - x^3/6 + 3x^5/40 - ..., so asinh x -> x for small x and subnormals pass through unchanged in the mathematics. Excel's do not: see Result and edge cases.
• Asymptotics: asinh x = ln(2x) + 1/(4x^2) - ... as x -> +infinity. Growth is logarithmic: every argument in the upper half of the double range maps into a narrow band of results, and at the top of binary64 the answer is a little over 710.
• Relations: asinh x = sign(x) * acosh(sqrt(x^2 + 1)) and asinh x = atanh( x / sqrt(x^2 + 1) ); also asinh(sinh t) = t for every real t, which is the round trip Microsoft's Learn reference states.
• Complex continuation: branch cuts along the imaginary axis outside [-i, i]. Nothing on the real line is cut, which is the precise reason the real domain is unrestricted.

Abramowitz & Stegun give the logarithmic closed form in chapter 4 section 4.6.

Arguments

That is Microsoft's own wording from the Learn reference. The Handbook flags it as the most consequential documented statement on this page, because what is on record upstream about the implementation contradicts it — see Result and edge cases below.

There are no units here. ASINH takes a number, not an angle; the RADIANS/DEGREES apparatus that attaches to the circular inverses is meaningless for it.

Try it

Quirks

Result and edge cases

Returns Number.

• Zero returns zero, and an odd implementation preserves the sign of zero.
• Subnormals and very small arguments do not pass through. In the recorded rows every |x| up to 1.05E-16, including every subnormal, gives 0, and slightly larger inputs move in steps of about 2.2E-16 (FN-ASINH-001).
• Negative arguments are the case the closed form handles badly and the oddness handles for free.
• Very large arguments are the interesting case, and the reason this page carries an evidence record.

The overflow boundary — the substantive finding on this page

Mathematically, asinh of the largest finite double is a modest number just above 710: finite, representable, and nowhere near any limit. But the closed form ln(x + sqrt(x^2 + 1)) forms x^2 first, and x^2 overflows binary64 as soon as |x| exceeds the square root of the largest finite double — approximately 1.34e154. Above that point the intermediate is infinite while the answer is small.

EV-MATH-0009 is an excel-math-deviation record whose subject is FUNC.ASINH, and what it identifies is exactly this: the substrate is the literal ln(x + sqrt(x^2+1)), the x^2 intermediate overflows, and an error is published well below where the mathematical result would require one. The record states the mechanism and, in its own words, publishes no count; its reader warning says that an exactness claim without a denominator is not a count and that this record publishes none. The Handbook repeats the shape and not the figures, which are rendered mechanically beside this page.

The documentation-versus-record divergence, stated plainly. Microsoft's Learn reference documents the argument as "any real number" and lists no error condition. The identified substrate makes an entire band of real numbers — more than a hundred decades of the double range, from about 1.34e154 to the largest finite double — fail. Documentation and behaviour disagree, and the Handbook publishes both.

• Arrays lift elementwise.

Errors

There is no mathematical domain error for ASINH. The #NUM! above is an artefact of an evaluation form, not a statement about the function.

How to implement

Numerical notes

The closed form is correct and, taken literally, fails at three places. All three are standard, and all three have one-line remedies.

1. Cancellation for negative arguments. For x large and negative, x + sqrt(x^2 + 1) is a difference of two nearly equal magnitudes, and the relative accuracy of the sum collapses; the logarithm then magnifies whatever survived. The remedy is oddness: compute on |x| and apply the sign at the end. This costs nothing and additionally makes ASINH(-x) = -ASINH(x) hold to the last bit. Any implementation of an odd function that does not do this has a symmetry defect that is trivially detectable.

2. Cancellation for small arguments. For small x, x + sqrt(x^2 + 1) is near 1, and ln of a value near 1 loses exactly the digits that carry the answer. The remedy is log1p, applied to a rearranged argument:

asinh x  =  log1p( x + x^2 / (1 + sqrt(1 + x^2)) )

Here nothing near 1 is ever formed and nothing is subtracted. Higham's treatment of log(1+x) is the standard statement of why this rearrangement is necessary rather than merely tidy. Below a threshold the series x - x^3/6 — or simply x itself — is correctly rounded and cheaper.

3. Overflow in the intermediate for large arguments. Described above. The remedy is a branch: once x is large enough that x^2 + 1 would round to x^2 anyway,

asinh x = ln(x) + ln(2)

computed without ever forming x^2. This extends the working range from the square root of the largest finite double all the way to the largest finite double itself — a hundred-odd decades recovered for the cost of one comparison.

fdlibm's s_asinh.c is the published implementation of exactly this three-branch structure, and it is what "a careful implementation" means for this function.

Why the naive form survives in the wild. It is one line, it is correct on the range people actually use, and its failure mode at the top of the range is an error rather than a wrong number; at small inputs it does give wrong numbers (FN-ASINH-001). That is a defensible engineering position and it is very likely how the behaviour on record came to exist. The Handbook records it as a departure from the mathematics without implying carelessness.

Rust code

6 asinh "ASINH" (1, 1) [V "number"] |s, a, sv| { out(s, k::asinh::asinh_kernel(num_with_subnormal(s, a, 0)?)) }

pub fn asinh_kernel(n: f64) -> Result<f64, WorksheetErrorCode> {
    // Excel computes `ln(x + sqrt(x² + 1))` and overflows when the `x²` intermediate
    // overflows f64, publishing `#NUM!` rather than the (finite, representable) analytic
    // value for such large |x|. Reproduce that boundary *bit-exactly* by forming the same
    // `x*x` intermediate Excel forms and rejecting when it is non-finite: this flips to
    // `#NUM!` at exactly the input Excel does (|x| > sqrt(f64::MAX) = 1.3407807929942596e154,
    // verified live against Excel 16.0 build 20026 around 0x5fefffffffffffff↔0x5ff0000000000000).
    // No guessed magic constant — identical f64 arithmetic yields Excel's exact threshold.
    if !(n * n).is_finite() {
        return Err(WorksheetErrorCode::Num);
    }
    // Inverse-problem identity, live Excel 16.0 b20228 Range.Value2:
    // ASINH(x) == SIGN(x)*LN(ABS(x)+SQRT(x*x+1)) on 23/23 signed rows.
    // The unsigned LN(x+SQRT(x*x+1)) misses negatives. Worksheet HYPOT
    // is not the graph. When x*x+1 overflows (x*x == f64::MAX), SQRT
    // cannot be formed; the published finite value is LN(2*|x|).
    let a = n.abs();
    // The recorded identity stores each operation from PC64, including SQRT.
    // Retaining the entire expression in the registers loses recorded matches.
    let sq = excel_x87_mul(a, a);
    let radicand = excel_x87_add(sq, 1.0);
    let inner = if !radicand.is_finite() {
        excel_x87_add(a, a)
    } else {
        excel_x87_add(a, excel_sqrt_staged(radicand))
    };
    Ok(n.signum() * crate::ported::excel_numeric::excel_log(inner))
}

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-ASINH-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 forward function. ASINH(SINH(t)) = t for every real t, which is the cleanest round trip in the family (no absolute value, no branch), and therefore the best oracle-free test on this page.
• ATANH — the third inverse hyperbolic primary. asinh x = atanh(x/sqrt(x^2+1)).
• ASIN — the circular namesake, and a completely different shape: bounded domain, bounded range, singular derivative at the endpoints. Sharing a name is the only thing they do.
• LN and SQRT — the substrate, and the source of both the cancellation and the overflow.
• LOG1P — which Excel does not expose as a worksheet function. Its absence is why a worksheet-level workaround for the small-argument hazard is awkward, and why a careful implementation of this surface must supply it internally. Excel's recorded answers follow a route without it (FN-ASINH-001).
• Confused with: ASIN, by name; and with 1/SINH, which is CSCH.

Named variants

No named variants are recorded yet.