GAUSS

What it does

GAUSS(z)

GAUSS(z) returns the probability that a standard normal variable falls between 0 and z — that is, the standard normal cumulative distribution function shifted so that the origin maps to zero. Microsoft's one-line description says it exactly: "Returns 0.5 less than the standard normal cumulative distribution."

The quoted one-line description is Microsoft's text, from its support article https://support.microsoft.com/en-us/office/gauss-function-069f1b4e-7dee-4d6a-a71f-4b69044a6b33 and the VBA reference https://learn.microsoft.com/en-us/office/vba/api/excel.worksheetfunction.gauss.

GAUSS(z)  =  Φ(z) − ½  =  (1/√(2π)) ∫₀^z e^{−t²/2} dt  =  ½ · erf( z / √2 )

• Domain: the whole real line.
• Range: the open interval (−½, ½). The bounds are approached but never attained mathematically, and are attained in floating point once |z| is beyond about 8.3.
• Symmetry: odd. GAUSS(−z) = −GAUSS(z), and GAUSS(0) = 0 exactly. This is the structural reason the function exists: Φ itself is not odd, and the ½ subtraction is precisely what makes the symmetry manifest.
• Derivative: the standard normal density φ(z) = e^{−z²/2}/√(2π), which is 1/√(2π) ≈ 0.3989 at the origin and decays super-exponentially.
• Series at the origin: GAUSS(z) = φ(0)·(z − z³/6 + z⁵/40 − …), so for small z the function is z/√(2π) to first order.

This is the function classically tabulated in the back of statistics textbooks — the "area under the normal curve from 0 to z" table — and that is the whole reason it has a worksheet surface of its own. A&S §26.2 defines the same object and relates it to the error function of §7.1.

The identity that governs the implementation is the last one above: GAUSS is half an error function of a scaled argument. Everything numerical about this surface is therefore a statement about erf, and the Handbook's evidence for it says so in as many words.

Arguments

There is no mean, no standard deviation, and no cumulative flag. GAUSS is the standardised form only; a non-standard normal must be standardised first — GAUSS((x − μ)/σ) — or computed with NORM.DIST.

Try it

Quirks

Result and edge cases

Returns Number, always in [−½, ½].

• z = 0 gives exactly 0, and the signed zero is worth preserving.
• Small z gives z/√(2π) to within a rounding. Subnormals cannot be asked through a cell, which reads them back as 0 (FN-ERF.PRECISE-001). There is no cancellation here, unlike in the ½-subtracted form discussed below — which is the point.
• Large |z| saturates at ±½. In binary64 the difference between Φ(z) and 1 falls below the representable spacing at ½ once |z| exceeds roughly 8.3, so beyond that the function returns exactly ±½ and carries no further information.
• Odd symmetry is a free self-check: GAUSS(z) + GAUSS(−z) should be exactly zero for every z. An implementation that computes Φ(z) − ½ separately for each sign will generally fail this, and failing it is a defect provable without any oracle.
• Array arguments lift elementwise.

How to implement

Numerical notes

The whole function is one erf evaluation, and erf is a solved problem. The classical implementation is Cody's rational Chebyshev approximation (1969), refined into ACM Algorithm 715 (CALERF), which splits the line into three regions — a small-argument rational in z², a middle region computing erfc directly, and a large-argument asymptotic form — and is the ancestor of fdlibm's erf/erfc and of most library implementations. Boost.Math and Cephes are in the same lineage with different coefficient sets. The mathematics has been settled for fifty years; what differs between implementations is coefficients, region boundaries, and the order of the final arithmetic.

The reason GAUSS is a separate function is cancellation. Writing GAUSS(z) as Φ(z) − ½ is the obvious implementation and the wrong one for small z: the true answer is small, Φ(z) is close to ½, and the subtraction discards the leading significant digits. Computing ½·erf(z/√2) instead keeps the small quantity small throughout. This is the same lesson as log1p versus LN(1+x) and expm1 versus EXP(x)−1, applied to the normal integral — and it is the reason the function has a name of its own rather than being left to the reader to spell out. An implementation that quietly routes GAUSS through the CDF has thrown away the function's purpose while returning plausible answers everywhere except where it matters.

The scaling by √2 is not free. z/√2 must be computed with a correctly rounded division (or by multiplying by a correctly rounded 1/√2 — which is not the same, and the two differ in the last bit for many z). For a compatibility-oriented implementation this is a specification detail, not an optimisation: the choice is observable.

Saturation. The threshold beyond which the result is exactly ±½ is an implementation fingerprint, determined by where erf(z/√2) rounds to 1 rather than by any mathematical boundary.

What the Handbook's evidence says about the substrate. The open-discrepancy record for this surface diagnoses the disagreement as needing the error-function/CDF substrate. That is an unusually specific statement of why a surface is unresolved: not "we have not looked", but "the layer beneath it has not been identified". FN-ERF.PRECISE-001 has since identified that layer below 0.5: a stored (4, 5) rational, which GAUSS uses too, with coefficients read off Excel's answers and no published table matched. A separate record in the same family identifies the .PRECISE error-function surfaces as branches of an incomplete-gamma routine rather than as a standalone coefficient table; below 0.5 that note finds a coefficient table.

Rust code

16 gauss "GAUSS" (1, 1) [V "z"] |s, a, sv| { out(s, k::gauss_fn::gauss_kernel(num_with_subnormal(s, a, 0)?)) }

pub fn gauss_kernel(x: f64) -> Result<f64, WorksheetErrorCode> {
    if !x.is_finite() {
        return Err(WorksheetErrorCode::Num);
    }
    Ok(identified_gauss(x))
}

/// Native-multiply stored-z route for the distinct tiny GAUSS branch.
/// W111 independently distinguishes the ordinary normal-CDF wrapper's staged
/// RN64 multiply followed by a binary64 store; that wrapper does not call this.
pub fn stored_normal_z(x: f64) -> f64 {
    x.abs() * f64::from_bits(FRAC_1_SQRT_2_BITS)
}

/// Inclusive tiny GAUSS uses its stored native normal argument and the shared
/// ERF body, followed by halving. The witness report counts its remaining gaps.
fn gauss_tiny_direct(x: f64) -> f64 {
    let z = stored_normal_z(x);
    let mut y = 0.5 * erf_approx(z);
    if x.is_sign_negative() {
        y = -y;
    }
    flush_subnormal(y)
}

/// GAUSS is NORMSDIST's graph minus 0.5 on the ordinary route
/// (`abs(x) > 1e-15`). Inclusive tiny-direct uses the stored-z ERF route.
pub fn identified_gauss(x: f64) -> f64 {
    if x == 0.0 {
        return 0.0;
    }
    if x.abs() <= f64::from_bits(GAUSS_TINY_MAX_BITS) {
        return gauss_tiny_direct(x);
    }
    identified_std_normal_cdf(x) - 0.5
}

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-GAUSS-001: build 19929 versus build 20228; 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

• NORM.S.DIST(z, TRUE) — the unshifted standard normal CDF. GAUSS(z) and NORM.S.DIST(z, TRUE) − 0.5 are the same number mathematically. They are not the same computation in general, and the difference matters: forming Φ(z) and then subtracting ½ loses precision for small z, because Φ(z) ≈ ½ + small and the subtraction cancels the leading digits of the answer. GAUSS exists so that the small quantity never has to be recovered from a difference. Below 0.5 Excel's GAUSS uses the ERF rational of FN-ERF.PRECISE-001; from 0.5 up, whether it avoids that path is an open question here.
• PHI(z) — the standard normal density, not a probability. Naming collision with the common notation Φ for the CDF; Excel's PHI is φ, the derivative of NORM.S.DIST. The two were introduced together in Excel 2013 and are documented on separate pages.
• NORM.DIST / NORM.INV / NORM.S.INV — the general and inverse normal surfaces.
• ERF and ERF.PRECISE — the substrate. GAUSS(z) = ½·erf(z/√2) exactly, so any statement about GAUSS's last bits is a statement about the error function Excel provides. The Handbook's own evidence names this dependency explicitly.
• STANDARDIZE — the usual preprocessing step, (x − μ)/σ.
• CONFIDENCE.NORM, Z.TEST — consumers of the same normal-tail machinery.

Named variants

No named variants are recorded yet.