FISHERINV

What it does

FISHERINV(y)

FISHERINV(y) is the hyperbolic tangent:

FISHERINV(y)  =  tanh(y)  =  (e^{2y} − 1) / (e^{2y} + 1)
                          =  (e^{y} − e^{−y}) / (e^{y} + e^{−y})

• Domain: the whole real line. This function has no interior domain restriction, which is the structural difference between it and its partner.
• Range: the open interval (−1, 1). The endpoints are approached but never attained mathematically.
• Symmetry: odd. tanh(−y) = −tanh(y), tanh(0) = 0 exactly.
• Derivative: 1 − tanh²(y) = sech²(y); it is 1 at the origin and decays like 4e^{−2|y|}.
• Asymptotics: tanh(y) → ±1 exponentially fast. By |y| ≈ 19 the difference from 1 is below the double-precision spacing at 1, so every implementation saturates well before the argument gets large.
• Series at the origin: tanh(y) = y − y³/3 + 2y⁵/15 − … , so for small y the function is y to first order.

Microsoft states the relationship rather than the formula: "If y = FISHER(x), then FISHERINV(y) = x." That is the defining property, and it is exact as mathematics — tanh and artanh are genuine mutual inverses on (−1, 1) ↔ ℝ. It is not exact as floating point, and the round trip is one of the more useful probes this pair offers; see Numerical notes.

The statistical use is the return leg of the Fisher z-transformation: build a confidence interval on the transformed scale, where the sampling distribution is approximately normal, then map the interval endpoints back to correlations with FISHERINV. Because tanh is monotone, the mapped interval is still an interval, and because it is nonlinear, the mapped interval is asymmetric about the point estimate — which is the whole point.

Arguments

Try it

Quirks

Result and edge cases

Returns Number, always in [−1, 1] once floating point is accounted for.

• At the origin, tanh(0) = 0 exactly.
• Small y, including subnormals, returns y to within a rounding, because tanh(y) = y + O(y³).
• Large positive y saturates at exactly 1, and large negative y at exactly −1. This is a floating-point fact, not a mathematical one: the true value never reaches the endpoint, but the nearest double to it is the endpoint once |y| is beyond roughly 19.
• The negative side needs no guard: e^{2y} underflows to 0 and the direct quotient gives −1 without special handling. The asymmetry in the guard is a consequence of the asymmetry of the formula, not a modelling choice.
• Array arguments lift elementwise; the surface is classified as a unary numeric scalar-or-array kernel.

Errors

As documented by Microsoft:

That is the entire documented error surface — one row. There is no documented #NUM! condition, which is unusual for a Statistical-category function and is the clearest structural contrast with FISHER. Error values arriving in the argument propagate under the shared coercion discipline.

What the documentation does not say, and this page will not invent: what happens for an argument so large that the intermediate exponential overflows. The documented error table has no row for it, the mathematical answer is a value inside the range, and the observed answer in the upstream record is saturation — but "documented" and "observed once, upstream" are different warrants and the Handbook keeps them apart.

How to implement

Numerical notes

tanh(y) = expm1(2y) / (expm1(2y) + 2)

removes that cancellation entirely, which is why fdlibm's tanh is written that way. The symmetric form (e^y − e^{−y})/(e^y + e^{−y}) costs two exponentials and still overflows.

The standard treatment — fdlibm, Cephes, Boost — is a three-region split: return y (or the first series term) below a small threshold; use the expm1 form in the middle; and return ±1 with a token dependence on y beyond the saturation threshold, so the sign and the rounding mode behave. Argument reduction is not needed; tanh is its own reduction.

The round trip is a good test and a bad guarantee. FISHERINV(FISHER(x)) recovers x exactly only when the two roundings happen to cancel. Near x = 0 both functions are approximately the identity and the round trip is faithful; near |x| = 1 the forward map expands and the backward map contracts, so the round trip is catastrophically unstable there — a change of one ulp in the transformed value moves the recovered correlation by far more than one ulp. That instability is a property of the mathematics, not a defect, and it is precisely why the transformation is useful: it spreads out the region where correlations are hard to distinguish.

What a careful implementation does. Use expm1; special-case the origin so the signed zero survives; pick the saturation threshold from the actual double spacing rather than a hard-coded constant; and never let an intermediate infinity reach a quotient.

Rust code

52 fisherinv "FISHERINV" (1, 1) [V "y"] |s, a, sv| {
    out(s, k::fisherinv_fn::fisherinv_kernel(num(s, a, 0)?))
}

pub fn fisherinv_kernel(y: f64) -> Result<f64, WorksheetErrorCode> {
    // Inverse-problem identity, live Excel 16.0 b20228: FISHERINV(y) ==
    // (EXP(2*y)-1)/(EXP(2*y)+1) on 27/27 signed rows. FISHERINV is not
    // TANH (10/27). The algebraically equal 1-2/(EXP(2*y)+1) misses (9/27).
    let e = crate::ported::excel_numeric::excel_exp(2.0 * y);
    // BUG-FUNC-027 CLASS-A6: for large positive y, e=e^(2y) overflows to +Inf and
    // the direct form gives Inf/Inf = NaN; Excel saturates to +1. The large
    // negative side already saturates to -1 via e -> 0, so only +Inf needs a guard.
    if e.is_infinite() {
        return Ok(1.0);
    }
    Ok((e - 1.0) / (e + 1.0))
}

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.

The record contains no same-input comparison between these environments. Reading different inputs on different builds does not establish either a version change or cross-build agreement.

Recorded environments and comparison details.

Alternatives

Relationships

• FISHER — the forward transform, artanh. Microsoft documents the round trip. Note the asymmetry: FISHER guards its domain with #NUM!; FISHERINV has no domain to guard and documents no #NUM! at all.
• TANH — the Math-category spelling of the same mathematical function. Excel ships both. They are documented to compute the same thing; whether they are the same computation, and therefore agree in the last bit, is unestablished and would need evidence. Do not assume it.
• CORREL / PEARSON — the correlation estimators whose transformed confidence bounds are mapped back through this function.
• NORM.S.INV — the quantile that sets those bounds on the transformed scale.
• EXP, LN — the substrate. Any statement about FISHERINV's last bits is ultimately a statement about the exponential the platform provides.

Named variants

No named variants are recorded yet.