ERF.PRECISE

What it does

ERF.PRECISE(x)

ERF.PRECISE(x) returns the normalised integral of exp(-t*t) from zero to x. The normalisation factor is 2/sqrt(pi). It is odd: negating x negates the mathematical result.

Try it

=ERF.PRECISE(0.25) is about 0.276326390168237. =ERF.PRECISE(-0.25) has the negative value.

Quirks

Nonnumeric arguments give #VALUE!. The PRECISE name does not imply correctly rounded results on every input. The measured below-half stage and the unresolved upper stage need separate treatment. Subnormal inputs transferred to worksheet cells can be read back as zero, so the input route is part of a useful reproduction.

How to implement

For normal abs(x)<0.5, use R(op)=RN53(RN64(op)): round each operation to a 64-bit significand, then store to binary64. Decode the following hexadecimal strings as binary64 bit patterns, not integers converted to floating-point values.

1. Store t=R(x*x).
2. Evaluate each polynomial by Horner, beginning with its highest-power coefficient. Every step is v=R(R(v*t)+coefficient). Keep the multiplication store separate from the addition store; do not use FMA.
3. Store p=R(x*N) and return R(p/D).

Worked x=0.25: t=0.0625; the staged coefficient evaluation gives N=1.126001525484713, D=1.018724202200851, p=0.2815003813711783, and result 0.276326390168237 (0x3fd1af54e232d60a). These are outputs of the stated reconstruction, with all input coefficients retained above.

The degrees and stores are supported by discriminating readings. The final bits of several higher-order coefficients remain open: the fixed c14 model matched 59,982 of a fresh 60,000-row holdout. Do not extrapolate this ratio above abs(x)=0.5. For larger magnitudes the current code uses the signed stored complement copysign(R(1-upper_ERFC(abs(x))),x). At exactly plus or minus 0.5 it instead retains its runtime ERF fallback. The fixed ratio and the mathematical value agree in bits at the positive half point, so that single recorded answer does not identify which private branch owns it. Zero and nonnormal inputs also retain the fallback and their separate transfer/publication rules. The upper ERFC exponential stage is measured, but its remaining rational factor is a stand-in. No published Handbook suite establishes a whole-domain equality claim.

Rust code

91 erf_precise "ERF.PRECISE" (1, 1) [V "x"] |s, a, sv| {
    reject_logical(&a[0])?;
    out(s, sd::erf_precise_kernel(num(s, a, 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.

• XC-ERF.PRECISE-001: build 19929 versus build 20131; 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.

Retained controls from the indexed captures:

These are earlier recorded answers, not new Excel runs or an additional cross-build comparison. The function JSON retains each source locator, exact argument bits where available, and input-route status. Call notation does not imply that captured binary64 values were entered as decimal formula literals.

Alternatives

ERFC computes the complementary tail directly. NORM.S.DIST provides a standard-normal CDF with a different argument transformation.

Named variants

No named variants are recorded yet.