Close: 802 of 1,866 recorded answers differ in the last bits, worst 6 ULP
Everything else matches (1,863 in the answer bank and 3 workbook cells). Last-bit means a finite number within 16 ULP of Excel's. How we measure this · See the Rust code
Local names in 40 languages
Language
Name in Excel
Arabic
ERFC.PRECISE
Bulgarian
ERFC.PRECISE
Czech
ERFC.PRECISE
Danish
ERFC.PRECISE
German
ERFC.PRECISE
Greek
ERFC.PRECISE
English (Australia)
ERFC.PRECISE
English (United Kingdom)
ERFC.PRECISE
English (United States)
ERFC.PRECISE
Spanish
FUN.ERROR.COMPL.EXACTO
Estonian
ERFC.PRECISE
Finnish
VIRHEFUNKTIO.KOMPLEMENTTI.TARKKA
French
ERFC.PRECIS
Hebrew
ERFC.PRECISE
Croatian
ERFC.PRECISE
Hungarian
HIBAFKOMPLEMENTER.PONTOS
Indonesian
ERFC.PRECISE
Italian
ERFC.PRECISE
Japanese
ERFC.PRECISE
Korean
ERFC.PRECISE
Lithuanian
ERFC.PRECISE
Latvian
ERFC.PRECISE
Norwegian
ERFC.PRECISE
Dutch
FOUT.COMPLEMENT.NAUWKEURIG
Polish
KOMP.FUNKCJA.BŁ.DOKŁ
Portuguese (Brazil)
ERFC.PRECISE
Portuguese (Portugal)
FUNCERROCOMPL.PRECISO
Romanian
ERFC.PRECISE
Russian
ДФОШ.ТОЧН
Slovak
ERFC.PRECISE
Slovenian
ERFC.PRECISE
Serbian (Latin)
ERFC.PRECISE
Swedish
FELFK.EXAKT
Thai
ERFC.PRECISE
Turkish
TÜMHATAİŞLEV.DUYARLI
Ukrainian
ERFC.PRECISE
Vietnamese
ERFC.PRECISE
Chinese (Simplified)
ERFC.PRECISE
Chinese (Hong Kong)
ERFC.PRECISE
Chinese (Traditional)
ERFC.PRECISE
Names from Microsoft's support site.
What it does
ERFC.PRECISE(x)
ERFC.PRECISE(x) is the normalised integral of exp(-t*t) from x to infinity. Mathematically it is 1-erf(x), but a direct tail calculation retains information when erf is close to one.
Try it
=ERFC.PRECISE(0.25) is about 0.723673609831763; =ERFC.PRECISE(0) is 1. A large positive argument has a small positive tail, whereas a large negative argument approaches two.
Quirks
Nonnumeric input gives #VALUE!. Subtracting a value rounded to one from one can erase a representable tail. The PRECISE spelling is not a whole-domain accuracy guarantee. The current kernel flushes a final subnormal tail to zero.
Below 0.5, ERF is a stored (4, 5) rational from a table not yet identified
With RN(v) meaning v rounded to 64 bits on the x87 unit and then stored to binary64, ERF.PRECISE for |x| < 0.5 is x*N(t)/D(t) with t = RN(x*x), p = RN(x*N), y = RN(p/D), and N and D Horner sums in t in which every product and every sum is RN. N has degree 4 and D degree 5, and the coefficients read off Excel's answers, order 0 upward, are N: 0x3ff1df5e70c7956b, 0x3fc201d8627a7d2c, 0x3fa6f289d165b303, 0x3f5d93a5813e372c, 0x3f2932767df264b2; D: 0x3fefada15778ece6, 0x3fdd191aca8d2499, 0x3fb79f85ba68803e, 0x3f856de5da86af12, 0x3f4609751b5b6488, 0x3ef4f20a473a5ab0. The rational stops at 0.5 itself. It equals erf to a flat 9E-17 up to 0.5, and its error climbs at once beyond, so 0.5 is its design interval and not Cody's 0.46875. No published table has been matched: Cody's 1969 rational is refuted by its linear terms, and Cephes has the same shape with different ratios. Evidence record EV-DIST-0026, which predates this note, attributes ERF.PRECISE and ERFC.PRECISE to the a < 1 branches of the NSWC GRATIO routine and says no coefficient table exists; below 0.5 this note replaces that attribution. Because every step rounds, answers need not be correctly rounded: of the 654 recorded rows of build 20131 in [0.25, 0.5), 400 differ from the correctly rounded erf, by up to 3 units, and small arguments can be 1 unit high, as below. ERFC and ERFC.PRECISE below 0.5 are 1 less this value, and GAUSS at tiny arguments takes half of it at its stored z/sqrt(2).
Explanation (inferred): That the legacy ERF(x) shares this body is inferred: ERF.PRECISE, ERFC and ERFC.PRECISE rows were scored in full, and for ERF itself the record holds only nine non-zero single-argument inputs below 0.5 (build 19929), all equal to the rational.
Formula
Excel
Mathematical value
ERF.PRECISE(0.4524739583333333) Excel 16.0 build 20131, platform and bitness not recorded, AMD Ryzen 7 4800HInputs and reference value
Number supplied through a cell.
x: 0.4524739583333333 0x3fdcf55555555555
mpmath erf at 800 bits from the binary64 input, correctly rounded.
0.4777590107351978 0x3fde939a879e86f6
0.4777590107351976 0x3fde939a879e86f3
ERF.PRECISE(9.094947017729282e-13) Excel 16.0 build 20131, platform and bitness not recorded, AMD Ryzen 7 4800HInputs and reference value
Number supplied through a cell.
x: 9.094947017729282e-13 0x3d70000000000000
mpmath erf at 800 bits from the binary64 input, correctly rounded.
1.0262548740643186e-12 0x3d720dd750429b6e
1.0262548740643184e-12 0x3d720dd750429b6d
ERF.PRECISE(9.999999999999998e-11) Excel 16.0 build 20131, platform and bitness not recorded, AMD Ryzen 7 4800HInputs and reference value
Number supplied through a cell.
x: 9.999999999999998e-11 0x3ddb7cdfd9d7bdb9
mpmath erf at 800 bits from the binary64 input, correctly rounded.
Above 0.5, ERFC rounds x*x before the exponential, so the tail drifts by hundreds of units
With RN(v) meaning v rounded to 64 bits on the x87 unit and then stored to binary64, ERFC for x >= 0.5 behaves as Q = E*F with z = RN(x*x) and E = exp(-z) stored to binary64, then multiplied by a factor F that is not identified. So the rounding error of x*x reaches the answer at full size. At x = 26.543000000000003, x*x exceeds z by 4.64E-14, which at the size of this answer is about 212 units, and Excel's answer is 212 units above the correctly rounded erfc. Near x = 5.93 the same effect is 23 units. For small x, where x*x is exact or nearly so, the answer stays within a few units.
Explanation (inferred): F is not a closed form: y = RN(E*RN(F)) with any offset matches 40% of answers at best. Its noise tracks about a dozen smooth curves, consistent with two polynomials of degree about 8 in x with shapes near Cephes' erfc P and Q, but that is a reading of shape only, and no table has been matched.
Formula
Excel
Mathematical value
ERFC.PRECISE(26.543000000000003) Excel 16.0 build 20131, platform and bitness not recorded, AMD Ryzen 7 4800HInputs and reference value
Number supplied through a cell.
x: 26.543000000000003 0x403a8b020c49ba5f
mpmath erfc at 800 bits from the binary64 input, correctly rounded.
2.2558350220536164e-308 0x001038a055f6d0d3
2.2558350220535116e-308 0x001038a055f6cfff
ERFC.PRECISE(5.927083333333333) Excel 16.0 build 20131, platform and bitness not recorded, AMD Ryzen 7 4800HInputs and reference value
Number supplied through a cell.
x: 5.927083333333333 0x4017b55555555555
mpmath erfc at 800 bits from the binary64 input, correctly rounded.
5.1964407001614455e-17 0x3c8df497ca9a0a49
5.1964407001614313e-17 0x3c8df497ca9a0a32
ERFC.PRECISE(2.0) Excel 16.0 build 20131, platform and bitness not recorded, AMD Ryzen 7 4800HInputs and reference value
Number supplied through a cell.
x: 2 0x4000000000000000
mpmath erfc at 800 bits from the binary64 input, correctly rounded.
Let D denote ordinary binary64 storage and R a 64-bit-significand operation followed by a binary64 store. The current finite-input branch table is:
Input range
Current computation
0<x<0.5
D(1-stored_ERF_rational(x))
x=0.5
D(1-runtime_ERF(0.5))
x>0.5
Positive upper-tail candidate below
x<-0.5
R(2-positive_upper_tail(abs(x)))
-0.5<=x<=0
Runtime ERFC fallback
For the positive upper stage, store z=R(x*x), obtain the stored public exponential E=EXP(-z), and form R(E*F(x)). Excel’s rational factor F is still open. The current code uses published Cody coefficients with stored arithmetic as a stand-in; copying that table does not complete an identified Excel tail recipe.
Worked below-half case: the stated ERF reconstruction at 0.25 is 0.276326390168237, so subtracting it from one gives about 0.723673609831763. In the upper stage at x=1, z is one and E is about 0.36787944117144233; the still unresolved F must supply the remaining factor.
Apply the current final subnormal-to-zero rule after the chosen branch. In particular, the negative half interval is not routed through the positive small-rational complement by this implementation. The exact half-point ownership in private Excel code is unseparated by the retained equal-answer control. Keep the reconstructed outer stages, current numerical substitutes and unmeasured transfer cases distinct.
Rust code
Show the CalcFunc source of this function
Quoted from the public repository DnaCalc/DnaCalc, crates calc-func and calc-fml, at commit 9e1884369a67. Comments are the source's own. A kernel shared with other functions appears once, on its module page.
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.
Excel 16.0 build
Platform and CPU
Captured inputs
19929
Windows, bitness not recorded, CPU not recorded
43
20131
Windows, bitness not recorded, AMD Ryzen 7 4800H with Radeon Graphics
935
20430
Windows, 64-bit, CPU not recorded
928
XC-ERFC.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.
ERFC.PRECISE(26.543000000000003) returned 2.2558350220536164e-308 (0x001038a055f6d0d3). ERFC.PRECISE(5.927083333333333) returned 5.1964407001614455e-17 (0x3c8df497ca9a0a49). 1 further recorded control is attached. Inputs were supplied through cells using Value2. These are controls from this environment, not a same-input comparison with another build.
43 captured inputs are indexed for this environment. Capture dates are not recorded. This is a reading count, not a comparison with another build.
Excel 16.0 build 20131
Windows, bitness not recorded, AMD Ryzen 7 4800H with Radeon Graphics
935 captured inputs are indexed for this environment. Capture dates: 2026-07-16 to 2026-07-17. This is a reading count, not a comparison with another build.
Excel 16.0 build 20430
Windows, 64-bit, CPU not recorded
928 captured inputs are indexed for this environment. Capture dates: 2026-09-29 to 2026-09-29. This is a reading count, not a comparison with another build.
Alternatives
ERF computes the central integral; NORM.S.DIST expresses normal probabilities. Use a scaled complementary error function internally to avoid overflow when designing a mathematical tail algorithm.