Engineering functions

ERFC.PRECISE

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
LanguageName in Excel
ArabicERFC.PRECISE
BulgarianERFC.PRECISE
CzechERFC.PRECISE
DanishERFC.PRECISE
GermanERFC.PRECISE
GreekERFC.PRECISE
English (Australia)ERFC.PRECISE
English (United Kingdom)ERFC.PRECISE
English (United States)ERFC.PRECISE
SpanishFUN.ERROR.COMPL.EXACTO
EstonianERFC.PRECISE
FinnishVIRHEFUNKTIO.KOMPLEMENTTI.TARKKA
FrenchERFC.PRECIS
HebrewERFC.PRECISE
CroatianERFC.PRECISE
HungarianHIBAFKOMPLEMENTER.PONTOS
IndonesianERFC.PRECISE
ItalianERFC.PRECISE
JapaneseERFC.PRECISE
KoreanERFC.PRECISE
LithuanianERFC.PRECISE
LatvianERFC.PRECISE
NorwegianERFC.PRECISE
DutchFOUT.COMPLEMENT.NAUWKEURIG
PolishKOMP.FUNKCJA.BŁ.DOKŁ
Portuguese (Brazil)ERFC.PRECISE
Portuguese (Portugal)FUNCERROCOMPL.PRECISO
RomanianERFC.PRECISE
RussianДФОШ.ТОЧН
SlovakERFC.PRECISE
SlovenianERFC.PRECISE
Serbian (Latin)ERFC.PRECISE
SwedishFELFK.EXAKT
ThaiERFC.PRECISE
TurkishTÜMHATAİŞLEV.DUYARLI
UkrainianERFC.PRECISE
VietnameseERFC.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

Input cells (optional)

Example: {"B2": 3, "B3": 4}. A1 holds the formula. Other cells need values before a formula can read them.

Enter a formula, then calculate.

Runs locally in your browser with OneCalc. Its answer may differ from Excel. Use English function names and commas between arguments.

=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.

FormulaExcelMathematical value
ERF.PRECISE(0.4524739583333333)
Excel 16.0 build 20131, platform and bitness not recorded, AMD Ryzen 7 4800H
Inputs 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 4800H
Inputs 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 4800H
Inputs and reference value

Number supplied through a cell.

x: 9.999999999999998e-11
0x3ddb7cdfd9d7bdb9

mpmath erf at 800 bits from the binary64 input, correctly rounded.

1.1283791670955125e-10
0x3ddf044332d68160
1.1283791670955123e-10
0x3ddf044332d6815f

Inputs, build details and evidence

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.

FormulaExcelMathematical value
ERFC.PRECISE(26.543000000000003)
Excel 16.0 build 20131, platform and bitness not recorded, AMD Ryzen 7 4800H
Inputs 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 4800H
Inputs 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 4800H
Inputs and reference value

Number supplied through a cell.

x: 2
0x4000000000000000

mpmath erfc at 800 bits from the binary64 input, correctly rounded.

0.0046777349810472645
0x3f7328f5ec350e65
0.004677734981047266
0x3f7328f5ec350e67

Inputs, build details and evidence

How to implement

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 rangeCurrent computation
0<x<0.5D(1-stored_ERF_rational(x))
x=0.5D(1-runtime_ERF(0.5))
x>0.5Positive upper-tail candidate below
x<-0.5R(2-positive_upper_tail(abs(x)))
-0.5<=x<=0Runtime 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.

ERFC.PRECISE · 4 lines · calc-func/src/catalogue/distributions.rs on GitHub
93 erfc_precise "ERFC.PRECISE" (1, 1) [V "x"] |s, a, sv| {
    reject_logical(&a[0])?;
    out(s, sd::erfc_precise_kernel(num(s, a, 0)?))
}

Kernels shared with other functions

Argument and result plumbing

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 buildPlatform and CPUCaptured inputs
19929Windows, bitness not recorded, CPU not recorded43
20131Windows, bitness not recorded, AMD Ryzen 7 4800H with Radeon Graphics935
20430Windows, 64-bit, CPU not recorded928
  • 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.

Recorded environments and comparison details.

Excel 16.0 build 20131

platform not recorded

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.

Observed formulas and results
  • ERFC.PRECISE(26.543000000000003) → 2.2558350220536164e-308
    0x001038a055f6d0d3 (cell-value2)
  • ERFC.PRECISE(5.927083333333333) → 5.1964407001614455e-17
    0x3c8df497ca9a0a49 (cell-value2)
  • ERFC.PRECISE(2.0) → 0.0046777349810472645
    0x3f7328f5ec350e65 (cell-value2)

Excel 16.0 build 19929

Windows, bitness not recorded, CPU not recorded

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.

Named variants

No named variants are recorded yet.

Suggest a correction or contribute an implementation · For agents