std::erfc, std::erfcf, std::erfcl

Defined in header `<cmath>`
float erfc ( float arg ); float erfcf( float arg );	(1)	(since C++11)
double erfc ( double arg );	(2)	(since C++11)
long double erfc ( long double arg ); long double erfcl( long double arg );	(3)	(since C++11)
double erfc ( IntegralType arg );	(4)	(since C++11)

1-3) Computes the complementary error function of arg, that is 1.0-erf(arg), but without loss of precision for large arg

4) A set of overloads or a function template accepting an argument of any integral type. Equivalent to (2) (the argument is cast to double).

Parameters

arg

-

value of a floating-point or integral type

Return value

If no errors occur, value of the complementary error function of arg, that is

2 \sqrt π \int \infty arg e -t 2 d t

or

1-erf(arg)

, is returned.

If a range error occurs due to underflow, the correct result (after rounding) is returned

Error handling

Errors are reported as specified in math_errhandling.

If the implementation supports IEEE floating-point arithmetic (IEC 60559),

If the argument is +∞, +0 is returned
If the argument is -∞, 2 is returned
If the argument is NaN, NaN is returned

Notes

For the IEEE-compatible type double, underflow is guaranteed if arg > 26.55.

Example

Run this code

#include <iostream>
#include <cmath>
#include <iomanip>
double normalCDF(double x) // Phi(-∞, x) aka N(x)
{
    return std::erfc(-x/std::sqrt(2))/2;
}
int main()
{
    std::cout << "normal cumulative distribution function:\n"
              << std::fixed << std::setprecision(2);
    for(double n=0; n<1; n+=0.1)
        std::cout << "normalCDF(" << n << ") " << 100*normalCDF(n) << "%\n";
 
    std::cout << "special values:\n"
              << "erfc(-Inf) = " << std::erfc(-INFINITY) << '\n'
              << "erfc(Inf) = " << std::erfc(INFINITY) << '\n';
}

Output:

normal cumulative distribution function:
normalCDF(0.00) 50.00%
normalCDF(0.10) 53.98%
normalCDF(0.20) 57.93%
normalCDF(0.30) 61.79%
normalCDF(0.40) 65.54%
normalCDF(0.50) 69.15%
normalCDF(0.60) 72.57%
normalCDF(0.70) 75.80%
normalCDF(0.80) 78.81%
normalCDF(0.90) 81.59%
normalCDF(1.00) 84.13%
special values:
erfc(-Inf) = 2.00
erfc(Inf) = 0.00

External links

Weisstein, Eric W. "Erfc." From MathWorld--A Wolfram Web Resource.

Compiler support
Freestanding and hosted
Language
Standard library headers
Named requirements
Feature test macros (C++20)
Language support library
Concepts library (C++20)
Metaprogramming library (C++11)
Diagnostics library
General utilities library
Strings library
Containers library
Iterators library
Ranges library (C++20)
Algorithms library
Numerics library
Localizations library
Input/output library
Filesystem library (C++17)
Regular expressions library (C++11)
Concurrency support library (C++11)
Technical specifications
Symbols index
External libraries

Common mathematical functions
Mathematical special functions (C++17)
Mathematical constants (C++20)
Floating-point environment (C++11)
Complex numbers
Numeric arrays
Pseudo-random number generation
Factor operations
gcd (C++17)
lcm (C++17)
Interpolations
midpoint (C++20)
lerp (C++20)
Generic numeric operations
iota (C++11)
ranges::iota (C++23)
accumulate
inner_product
adjacent_difference
partial_sum
reduce (C++17)
transform_reduce (C++17)
inclusive_scan (C++17)
exclusive_scan (C++17)
transform_inclusive_scan (C++17)
transform_exclusive_scan (C++17)
Bit operations
bit_cast (C++20)
byteswap (C++23)
has_single_bit (C++20)
bit_ceil (C++20)
bit_floor (C++20)
bit_width (C++20)
rotl (C++20)
rotr (C++20)
countl_zero (C++20)
countl_one (C++20)
countr_zero (C++20)
countr_one (C++20)
popcount (C++20)
endian (C++20)