FISHER

What it does

FISHER(x)

FISHER(x) is the inverse hyperbolic tangent:

FISHER(x)  =  artanh(x)  =  ½ · ln( (1 + x) / (1 − x) )

• Domain: the open interval −1 < x < 1.
• Range: the whole real line.
• Poles: logarithmic singularities at x = −1 and x = +1, where the function tends to −∞ and +∞ respectively. There is no branch cut inside the domain.
• Symmetry: odd. artanh(−x) = −artanh(x), and artanh(0) = 0 exactly.
• Derivative: 1 / (1 − x²), which is 1 at the origin and grows without bound at the ends.
• Limiting form near zero: artanh(x) = x + x³/3 + x⁵/5 + … , so for small x the function is x to first order.

Microsoft's documentation states the purpose rather than the formula in text: the transformation "produces a function that is normally distributed rather than skewed", and it is for hypothesis testing on the correlation coefficient. That is the statistical reason the function exists. Pearson's sample correlation r is confined to [−1, 1] and its sampling distribution is badly skewed near the ends; artanh(r) is approximately normal with variance 1/(n − 3) more or less independently of the true correlation, which is what makes confidence intervals for a correlation tractable. This is R. A. Fisher's variance-stabilizing z-transformation, and the function is a spreadsheet spelling of it.

The mathematics and the statistics are separable. FISHER is artanh; the normal-approximation story is why Excel ships it under a statistician's name rather than as ATANH — which Excel also ships, in the Math category. See Relationships.

Arguments

The trap in that sentence is worth naming: TRUE converts to 1, and 1 is outside the domain. FISHER(TRUE) is therefore a domain failure rather than a value, and so is FISHER("1"). Nothing in the documentation warns about this, because the documentation discusses the domain in terms of x and the coercion in terms of "nonnumeric".

Try it

Quirks

Result and edge cases

Returns Number.

• At the origin, artanh(0) = 0, and 0 is exactly representable, so an implementation that gets anything other than a signed zero here is doing something wrong.
• Approaching the poles, the true value diverges. The documented behaviour is not a saturating value and not an infinity: it is #NUM! for the whole closed complement |x| ≥ 1, which means the endpoints themselves error rather than returning ±∞.
• Very small x, including subnormals, should return x itself to within a rounding, because artanh(x) = x + O(x³).

Errors

As documented by Microsoft:

The #NUM! condition is stated with non-strict inequalities on both sides, so both endpoints are errors. Error values arriving in the argument propagate under the shared coercion discipline; the Handbook has not observed any of this in Excel itself.

How to implement

Numerical notes

The interesting part of FISHER is that the textbook formula is the wrong way to evaluate it.

Cancellation near zero. Written as ½·ln((1 + x)/(1 − x)), the quotient is a number close to 1 for small x, and taking a logarithm of something close to 1 discards the leading significant digits: the information about x lives in the difference between the quotient and 1, and that difference has already been rounded away by the division. The accurate rearrangement is

artanh(x) = ½ · log1p( 2x / (1 − x) )

which keeps the small quantity small and hands it to a routine designed for arguments near 1. This is what fdlibm's atanh does, and it is the standard treatment in the literature — the same cancellation lesson that governs LN(1+x) throughout the Handbook. Cephes and Boost use the equivalent form; Numerical Recipes discusses the general pattern under the heading of avoiding subtractive cancellation.

Overflow is not the failure mode; loss of the domain is. As |x| → 1 the quotient grows, but only to about 2/(1 − |x|), and the logarithm tames it, so a double-precision evaluation stays finite until x is within a rounding of ±1. The practical hazard is the other side: 1 − x is computed exactly only when x is not extremely close to 1 (Sterbenz), and once x is within half an ulp of 1 the subtraction returns the rounded gap and the result is dominated by that single rounding.

What a careful implementation does. Use the log1p form; return x unchanged (or x + x³/3) below the threshold where the series is indistinguishable from the function at working precision; preserve the sign of zero; and decide deliberately whether the endpoints raise or saturate, since Excel's documented answer there is an error rather than an infinity.

Rust code

51 fisher "FISHER" (1, 1) [V "x"] |s, a, sv| {
    out(s, k::fisher_fn::fisher_kernel(num(s, a, 0)?))
}

pub fn fisher_kernel(x: f64) -> Result<f64, WorksheetErrorCode> {
    if x.abs() >= 1.0 {
        return Err(WorksheetErrorCode::Num);
    }
    // Inverse-problem identity, live Excel 16.0 b20228: FISHER(x) ==
    // 0.5*LN((1+x)/(1-x)) on 33/33 signed rows including tiny and near-1.
    // FISHER is not ATANH (21/33): ATANH keeps a cubic small-x body.
    // Split LN(1+x)-LN(1-x) is not the graph (10/33).
    // W111's small-input neighbors distinguish all three arithmetic stores.
    let numerator = crate::ported::excel_numeric::excel_x87_add(1.0, x);
    let denominator = crate::ported::excel_numeric::excel_x87_sub(1.0, x);
    let ratio = crate::ported::excel_numeric::excel_x87_div(numerator, denominator);
    Ok(0.5 * crate::ported::excel_numeric::excel_log(ratio))
}

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-FISHER-001: build 19929 versus build 20430; 3 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

• FISHERINV — the inverse, tanh. Microsoft states the round trip directly: if y = FISHER(x) then FISHERINV(y) = x. The pair is asymmetric in a way that matters to implementers: FISHER has a bounded domain and a documented #NUM! guard, while FISHERINV has an unbounded domain and no documented #NUM! condition at all.
• ATANH — the Math-category spelling of the same mathematical function. Excel publishes both. They are documented to compute the same thing; whether they compute it with the same code, and therefore return the same bits, is not established here and would need evidence. Treating FISHER and ATANH as interchangeable is an assumption, not a fact.
• CORREL / PEARSON — the usual producers of the r that gets fed to FISHER.
• NORM.S.INV, NORM.S.DIST — the usual next step: the transformed value is compared against a standard normal quantile, and FISHERINV maps the interval endpoints back.
• TANH / ATANH — the hyperbolic pair FISHER/FISHERINV shadows.

Named variants

No named variants are recorded yet.