Engineering functions

ERFC

Close: 312 of 547 recorded answers differ in the last bits, worst 6 ULP

Everything else matches (544 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
BulgarianERFC
CzechERFC
DanishFEJLFUNK.KOMP
GermanERFC
GreekERFC
English (Australia)ERFC
English (United Kingdom)ERFC
English (United States)ERFC
SpanishFUN.ERROR.COMPL
EstonianERFC
FinnishVIRHEFUNKTIO.KOMPLEMENTTI
FrenchERFC
HebrewERFC
CroatianERFC
HungarianHIBAF.KOMPLEMENTER
IndonesianERFC
ItalianERFC
JapaneseERFC
KoreanERFC
LithuanianERFC
LatvianERFC
NorwegianERFC
DutchFOUT.COMPLEMENT
PolishERFC
Portuguese (Brazil)ERFC
Portuguese (Portugal)FUNCERROCOMPL
RomanianERFC
RussianДФОШ
SlovakERFC
SlovenianERFC
Serbian (Latin)ERFC
SwedishFELFK
ThaiERFC
TurkishTÜMHATAİŞLEV işlevi
UkrainianERFC
VietnameseERFC
Chinese (Simplified)ERFC
Chinese (Hong Kong)ERFC
Chinese (Traditional)ERFC

Names from Microsoft's support site.

What it does

ERFC(x)

ERFC(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(0.25) is about 0.723673609831763; =ERFC(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 · 4 lines · calc-func/src/catalogue/distributions.rs on GitHub
92 erfc "ERFC" (1, 1) [V "x"] |s, a, sv| {
    reject_logical(&a[0])?;
    out(s, sd::erfc_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 recorded41
20430Windows, 64-bit, CPU not recorded544

The record contains no same-input comparison between these environments. Reading different inputs on different builds does not establish either a version change or cross-build agreement.

Recorded environments and comparison details.

Excel 16.0 build 19929

Windows, bitness not recorded, CPU not recorded

41 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 20430

Windows, 64-bit, CPU not recorded

544 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