def test_erf():
assert erf(nan) == nan
assert erf(oo) == 1
assert erf(-oo) == -1
assert erf(0) == 0
assert erf(I * oo) == oo * I
assert erf(-I * oo) == -oo * I
assert erf(-2) == -erf(2)
assert erf(-x * y) == -erf(x * y)
assert erf(-x - y) == -erf(x + y)
assert erf(erfinv(x)) == x
assert erf(erfcinv(x)) == 1 - x
assert erf(erf2inv(0, x)) == x
assert erf(erf2inv(0, erf(erfcinv(1 - erf(erfinv(x)))))) == x
assert erf(I).is_real is False
assert erf(0).is_real is True
assert conjugate(erf(z)) == erf(conjugate(z))
assert erf(x).as_leading_term(x) == 2 * x / sqrt(pi)
assert erf(1 / x).as_leading_term(x) == erf(1 / x)
assert erf(z).rewrite('uppergamma') == sqrt(z**
2) * (1 - erfc(sqrt(z**2))) / z
assert erf(z).rewrite('erfc') == S.One - erfc(z)
assert erf(z).rewrite('erfi') == -I * erfi(I * z)
assert erf(z).rewrite('fresnels') == (1 + I) * (
fresnelc(z * (1 - I) / sqrt(pi)) - I * fresnels(z *
(1 - I) / sqrt(pi)))
assert erf(z).rewrite('fresnelc') == (1 + I) * (
fresnelc(z * (1 - I) / sqrt(pi)) - I * fresnels(z *
(1 - I) / sqrt(pi)))
assert erf(z).rewrite('hyper') == 2 * z * hyper([S.Half], [3 * S.Half],
-z**2) / sqrt(pi)
assert erf(z).rewrite('meijerg') == z * meijerg([S.Half], [], [0],
[-S.Half], z**2) / sqrt(pi)
assert erf(z).rewrite(
'expint') == sqrt(z**2) / z - z * expint(S.Half, z**2) / sqrt(S.Pi)
assert limit(exp(x)*exp(x**2)*(erf(x + 1/exp(x)) - erf(x)), x, oo) == \
2/sqrt(pi)
assert limit((1 - erf(z)) * exp(z**2) * z, z, oo) == 1 / sqrt(pi)
assert limit((1 - erf(x)) * exp(x**2) * sqrt(pi) * x, x, oo) == 1
assert limit(((1 - erf(x)) * exp(x**2) * sqrt(pi) * x - 1) * 2 * x**2, x,
oo) == -1
assert erf(x).as_real_imag() == \
((erf(re(x) - I*re(x)*Abs(im(x))/Abs(re(x)))/2 +
erf(re(x) + I*re(x)*Abs(im(x))/Abs(re(x)))/2,
I*(erf(re(x) - I*re(x)*Abs(im(x))/Abs(re(x))) -
erf(re(x) + I*re(x)*Abs(im(x))/Abs(re(x)))) *
re(x)*Abs(im(x))/(2*im(x)*Abs(re(x)))))
raises(ArgumentIndexError, lambda: erf(x).fdiff(2))
def test_erfi():
assert erfi(nan) is nan
assert erfi(oo) is S.Infinity
assert erfi(-oo) is S.NegativeInfinity
assert erfi(0) is S.Zero
assert erfi(I * oo) == I
assert erfi(-I * oo) == -I
assert erfi(-x) == -erfi(x)
assert erfi(I * erfinv(x)) == I * x
assert erfi(I * erfcinv(x)) == I * (1 - x)
assert erfi(I * erf2inv(0, x)) == I * x
assert erfi(
I * erf2inv(0, x, evaluate=False)) == I * x # To cover code in erfi
assert erfi(I).is_real is False
assert erfi(0).is_real is True
assert conjugate(erfi(z)) == erfi(conjugate(z))
assert erfi(x).as_leading_term(x) == 2 * x / sqrt(pi)
assert erfi(x * y).as_leading_term(y) == 2 * x * y / sqrt(pi)
assert (erfi(x * y) / erfi(y)).as_leading_term(y) == x
assert erfi(1 / x).as_leading_term(x) == erfi(1 / x)
assert erfi(z).rewrite('erf') == -I * erf(I * z)
assert erfi(z).rewrite('erfc') == I * erfc(I * z) - I
assert erfi(z).rewrite('fresnels') == (1 - I) * (
fresnelc(z * (1 + I) / sqrt(pi)) - I * fresnels(z *
(1 + I) / sqrt(pi)))
assert erfi(z).rewrite('fresnelc') == (1 - I) * (
fresnelc(z * (1 + I) / sqrt(pi)) - I * fresnels(z *
(1 + I) / sqrt(pi)))
assert erfi(z).rewrite('hyper') == 2 * z * hyper([S.Half], [3 * S.Half], z
**2) / sqrt(pi)
assert erfi(z).rewrite('meijerg') == z * meijerg(
[S.Half], [], [0], [Rational(-1, 2)], -z**2) / sqrt(pi)
assert erfi(z).rewrite('uppergamma') == (
sqrt(-z**2) / z * (uppergamma(S.Half, -z**2) / sqrt(S.Pi) - S.One))
assert erfi(z).rewrite(
'expint') == sqrt(-z**2) / z - z * expint(S.Half, -z**2) / sqrt(S.Pi)
assert erfi(z).rewrite('tractable') == -I * (-_erfs(I * z) * exp(z**2) + 1)
assert expand_func(erfi(I * z)) == I * erf(z)
assert erfi(x).as_real_imag() == \
(erfi(re(x) - I*im(x))/2 + erfi(re(x) + I*im(x))/2,
-I*(-erfi(re(x) - I*im(x)) + erfi(re(x) + I*im(x)))/2)
assert erfi(x).as_real_imag(deep=False) == \
(erfi(re(x) - I*im(x))/2 + erfi(re(x) + I*im(x))/2,
-I*(-erfi(re(x) - I*im(x)) + erfi(re(x) + I*im(x)))/2)
assert erfi(w).as_real_imag() == (erfi(w), 0)
assert erfi(w).as_real_imag(deep=False) == (erfi(w), 0)
raises(ArgumentIndexError, lambda: erfi(x).fdiff(2))
def test_erf():
assert erf(nan) == nan
assert erf(oo) == 1
assert erf(-oo) == -1
assert erf(0) == 0
assert erf(I*oo) == oo*I
assert erf(-I*oo) == -oo*I
assert erf(-2) == -erf(2)
assert erf(-x*y) == -erf(x*y)
assert erf(-x - y) == -erf(x + y)
assert erf(erfinv(x)) == x
assert erf(erfcinv(x)) == 1 - x
assert erf(erf2inv(0, x)) == x
assert erf(erf2inv(0, erf(erfcinv(1 - erf(erfinv(x)))))) == x
assert erf(I).is_real is False
assert erf(0).is_real is True
assert conjugate(erf(z)) == erf(conjugate(z))
assert erf(x).as_leading_term(x) == 2*x/sqrt(pi)
assert erf(1/x).as_leading_term(x) == erf(1/x)
assert erf(z).rewrite('uppergamma') == sqrt(z**2)*(1 - erfc(sqrt(z**2)))/z
assert erf(z).rewrite('erfc') == S.One - erfc(z)
assert erf(z).rewrite('erfi') == -I*erfi(I*z)
assert erf(z).rewrite('fresnels') == (1 + I)*(fresnelc(z*(1 - I)/sqrt(pi)) -
I*fresnels(z*(1 - I)/sqrt(pi)))
assert erf(z).rewrite('fresnelc') == (1 + I)*(fresnelc(z*(1 - I)/sqrt(pi)) -
I*fresnels(z*(1 - I)/sqrt(pi)))
assert erf(z).rewrite('hyper') == 2*z*hyper([S.Half], [3*S.Half], -z**2)/sqrt(pi)
assert erf(z).rewrite('meijerg') == z*meijerg([S.Half], [], [0], [-S.Half], z**2)/sqrt(pi)
assert erf(z).rewrite('expint') == sqrt(z**2)/z - z*expint(S.Half, z**2)/sqrt(S.Pi)
assert limit(exp(x)*exp(x**2)*(erf(x + 1/exp(x)) - erf(x)), x, oo) == \
2/sqrt(pi)
assert limit((1 - erf(z))*exp(z**2)*z, z, oo) == 1/sqrt(pi)
assert limit((1 - erf(x))*exp(x**2)*sqrt(pi)*x, x, oo) == 1
assert limit(((1 - erf(x))*exp(x**2)*sqrt(pi)*x - 1)*2*x**2, x, oo) == -1
assert erf(x).as_real_imag() == \
((erf(re(x) - I*re(x)*Abs(im(x))/Abs(re(x)))/2 +
erf(re(x) + I*re(x)*Abs(im(x))/Abs(re(x)))/2,
I*(erf(re(x) - I*re(x)*Abs(im(x))/Abs(re(x))) -
erf(re(x) + I*re(x)*Abs(im(x))/Abs(re(x)))) *
re(x)*Abs(im(x))/(2*im(x)*Abs(re(x)))))
raises(ArgumentIndexError, lambda: erf(x).fdiff(2))
def test_erf2inv():
assert erf2inv(0, 0) == S.Zero
assert erf2inv(0, 1) == S.Infinity
assert erf2inv(1, 0) == S.One
assert erf2inv(0, y) == erfinv(y)
assert erf2inv(oo,y) == erfcinv(-y)
assert erf2inv(x, y).diff(x) == exp(-x**2 + erf2inv(x, y)**2)
assert erf2inv(x, y).diff(y) == sqrt(pi)*exp(erf2inv(x, y)**2)/2
def test_erf2():
assert erf2(0, 0) == S.Zero
assert erf2(x, x) == S.Zero
assert erf2(nan, 0) == nan
assert erf2(-oo, y) == erf(y) + 1
assert erf2( oo, y) == erf(y) - 1
assert erf2( x, oo) == 1 - erf(x)
assert erf2( x,-oo) == -1 - erf(x)
assert erf2(x, erf2inv(x, y)) == y
assert erf2(-x, -y) == -erf2(x,y)
assert erf2(-x, y) == erf(y) + erf(x)
assert erf2( x, -y) == -erf(y) - erf(x)
assert erf2(x, y).rewrite('fresnels') == erf(y).rewrite(fresnels)-erf(x).rewrite(fresnels)
assert erf2(x, y).rewrite('fresnelc') == erf(y).rewrite(fresnelc)-erf(x).rewrite(fresnelc)
assert erf2(x, y).rewrite('hyper') == erf(y).rewrite(hyper)-erf(x).rewrite(hyper)
assert erf2(x, y).rewrite('meijerg') == erf(y).rewrite(meijerg)-erf(x).rewrite(meijerg)
assert erf2(x, y).rewrite('uppergamma') == erf(y).rewrite(uppergamma) - erf(x).rewrite(uppergamma)
assert erf2(x, y).rewrite('expint') == erf(y).rewrite(expint)-erf(x).rewrite(expint)
assert erf2(I, 0).is_real is False
assert erf2(0, 0).is_real is True
assert expand_func(erf(x) + erf2(x, y)) == erf(y)
assert conjugate(erf2(x, y)) == erf2(conjugate(x), conjugate(y))
assert erf2(x, y).rewrite('erf') == erf(y) - erf(x)
assert erf2(x, y).rewrite('erfc') == erfc(x) - erfc(y)
assert erf2(x, y).rewrite('erfi') == I*(erfi(I*x) - erfi(I*y))
raises(ArgumentIndexError, lambda: erfi(x).fdiff(3))
def test_erf2():
assert erf2(0, 0) == S.Zero
assert erf2(x, x) == S.Zero
assert erf2(nan, 0) == nan
assert erf2(-oo, y) == erf(y) + 1
assert erf2(oo, y) == erf(y) - 1
assert erf2(x, oo) == 1 - erf(x)
assert erf2(x, -oo) == -1 - erf(x)
assert erf2(x, erf2inv(x, y)) == y
assert erf2(-x, -y) == -erf2(x, y)
assert erf2(-x, y) == erf(y) + erf(x)
assert erf2(x, -y) == -erf(y) - erf(x)
assert erf2(x, y).rewrite(
'fresnels') == erf(y).rewrite(fresnels) - erf(x).rewrite(fresnels)
assert erf2(x, y).rewrite(
'fresnelc') == erf(y).rewrite(fresnelc) - erf(x).rewrite(fresnelc)
assert erf2(
x, y).rewrite('hyper') == erf(y).rewrite(hyper) - erf(x).rewrite(hyper)
assert erf2(x, y).rewrite(
'meijerg') == erf(y).rewrite(meijerg) - erf(x).rewrite(meijerg)
assert erf2(
x,
y).rewrite('uppergamma'
) == erf(y).rewrite(uppergamma) - erf(x).rewrite(uppergamma)
assert erf2(
x,
y).rewrite('expint') == erf(y).rewrite(expint) - erf(x).rewrite(expint)
assert erf2(I, 0).is_real is False
assert erf2(0, 0).is_real is True
assert expand_func(erf(x) + erf2(x, y)) == erf(y)
assert conjugate(erf2(x, y)) == erf2(conjugate(x), conjugate(y))
assert erf2(x, y).rewrite('erf') == erf(y) - erf(x)
assert erf2(x, y).rewrite('erfc') == erfc(x) - erfc(y)
assert erf2(x, y).rewrite('erfi') == I * (erfi(I * x) - erfi(I * y))
assert erf2(x, y).diff(x) == erf2(x, y).fdiff(1)
assert erf2(x, y).diff(y) == erf2(x, y).fdiff(2)
assert erf2(x, y).diff(x) == -2 * exp(-x**2) / sqrt(pi)
assert erf2(x, y).diff(y) == 2 * exp(-y**2) / sqrt(pi)
raises(ArgumentIndexError, lambda: erf2(x, y).fdiff(3))
assert erf2(x, y).is_extended_real is None
xr, yr = symbols('xr yr', extended_real=True)
assert erf2(xr, yr).is_extended_real is True
def test_erf2():
assert erf2(0, 0) is S.Zero
assert erf2(x, x) is S.Zero
assert erf2(nan, 0) is nan
assert erf2(-oo, y) == erf(y) + 1
assert erf2(oo, y) == erf(y) - 1
assert erf2(x, oo) == 1 - erf(x)
assert erf2(x, -oo) == -1 - erf(x)
assert erf2(x, erf2inv(x, y)) == y
assert erf2(-x, -y) == -erf2(x, y)
assert erf2(-x, y) == erf(y) + erf(x)
assert erf2(x, -y) == -erf(y) - erf(x)
assert erf2(x, y).rewrite(
"fresnels") == erf(y).rewrite(fresnels) - erf(x).rewrite(fresnels)
assert erf2(x, y).rewrite(
"fresnelc") == erf(y).rewrite(fresnelc) - erf(x).rewrite(fresnelc)
assert erf2(
x, y).rewrite("hyper") == erf(y).rewrite(hyper) - erf(x).rewrite(hyper)
assert erf2(x, y).rewrite(
"meijerg") == erf(y).rewrite(meijerg) - erf(x).rewrite(meijerg)
assert erf2(
x,
y).rewrite("uppergamma"
) == erf(y).rewrite(uppergamma) - erf(x).rewrite(uppergamma)
assert erf2(
x,
y).rewrite("expint") == erf(y).rewrite(expint) - erf(x).rewrite(expint)
assert erf2(I, 0).is_real is False
assert erf2(0, 0).is_real is True
assert expand_func(erf(x) + erf2(x, y)) == erf(y)
assert conjugate(erf2(x, y)) == erf2(conjugate(x), conjugate(y))
assert erf2(x, y).rewrite("erf") == erf(y) - erf(x)
assert erf2(x, y).rewrite("erfc") == erfc(x) - erfc(y)
assert erf2(x, y).rewrite("erfi") == I * (erfi(I * x) - erfi(I * y))
assert erf2(x, y).diff(x) == erf2(x, y).fdiff(1)
assert erf2(x, y).diff(y) == erf2(x, y).fdiff(2)
assert erf2(x, y).diff(x) == -2 * exp(-(x**2)) / sqrt(pi)
assert erf2(x, y).diff(y) == 2 * exp(-(y**2)) / sqrt(pi)
raises(ArgumentIndexError, lambda: erf2(x, y).fdiff(3))
assert erf2(x, y).is_extended_real is None
xr, yr = symbols("xr yr", extended_real=True)
assert erf2(xr, yr).is_extended_real is True
def test_erfi():
assert erfi(nan) == nan
assert erfi(oo) == S.Infinity
assert erfi(-oo) == S.NegativeInfinity
assert erfi(0) == S.Zero
assert erfi(I * oo) == I
assert erfi(-I * oo) == -I
assert erfi(-x) == -erfi(x)
assert erfi(I * erfinv(x)) == I * x
assert erfi(I * erfcinv(x)) == I * (1 - x)
assert erfi(I * erf2inv(0, x)) == I * x
assert erfi(I).is_real is False
assert erfi(0).is_real is True
assert conjugate(erfi(z)) == erfi(conjugate(z))
assert erfi(z).rewrite('erf') == -I * erf(I * z)
assert erfi(z).rewrite('erfc') == I * erfc(I * z) - I
assert erfi(z).rewrite('fresnels') == (1 - I) * (
fresnelc(z * (1 + I) / sqrt(pi)) - I * fresnels(z *
(1 + I) / sqrt(pi)))
assert erfi(z).rewrite('fresnelc') == (1 - I) * (
fresnelc(z * (1 + I) / sqrt(pi)) - I * fresnels(z *
(1 + I) / sqrt(pi)))
assert erfi(z).rewrite('hyper') == 2 * z * hyper([S.Half], [3 * S.Half], z
**2) / sqrt(pi)
assert erfi(z).rewrite('meijerg') == z * meijerg(
[S.Half], [], [0], [-S.Half], -z**2) / sqrt(pi)
assert erfi(z).rewrite('uppergamma') == (
sqrt(-z**2) / z * (uppergamma(S.Half, -z**2) / sqrt(S.Pi) - S.One))
assert erfi(z).rewrite(
'expint') == sqrt(-z**2) / z - z * expint(S.Half, -z**2) / sqrt(S.Pi)
assert expand_func(erfi(I * z)) == I * erf(z)
assert erfi(x).as_real_imag() == \
((erfi(re(x) - I*re(x)*Abs(im(x))/Abs(re(x)))/2 +
erfi(re(x) + I*re(x)*Abs(im(x))/Abs(re(x)))/2,
I*(erfi(re(x) - I*re(x)*Abs(im(x))/Abs(re(x))) -
erfi(re(x) + I*re(x)*Abs(im(x))/Abs(re(x)))) *
re(x)*Abs(im(x))/(2*im(x)*Abs(re(x)))))
raises(ArgumentIndexError, lambda: erfi(x).fdiff(2))
def test_erfi():
assert erfi(nan) == nan
assert erfi(oo) == S.Infinity
assert erfi(-oo) == S.NegativeInfinity
assert erfi(0) == S.Zero
assert erfi(I*oo) == I
assert erfi(-I*oo) == -I
assert erfi(-x) == -erfi(x)
assert erfi(I*erfinv(x)) == I*x
assert erfi(I*erfcinv(x)) == I*(1 - x)
assert erfi(I*erf2inv(0, x)) == I*x
assert erfi(I).is_real is False
assert erfi(0).is_real is True
assert conjugate(erfi(z)) == erfi(conjugate(z))
assert erfi(z).rewrite('erf') == -I*erf(I*z)
assert erfi(z).rewrite('erfc') == I*erfc(I*z) - I
assert erfi(z).rewrite('fresnels') == (1 - I)*(fresnelc(z*(1 + I)/sqrt(pi)) -
I*fresnels(z*(1 + I)/sqrt(pi)))
assert erfi(z).rewrite('fresnelc') == (1 - I)*(fresnelc(z*(1 + I)/sqrt(pi)) -
I*fresnels(z*(1 + I)/sqrt(pi)))
assert erfi(z).rewrite('hyper') == 2*z*hyper([S.Half], [3*S.Half], z**2)/sqrt(pi)
assert erfi(z).rewrite('meijerg') == z*meijerg([S.Half], [], [0], [-S.Half], -z**2)/sqrt(pi)
assert erfi(z).rewrite('uppergamma') == (sqrt(-z**2)/z*(uppergamma(S.Half,
-z**2)/sqrt(S.Pi) - S.One))
assert erfi(z).rewrite('expint') == sqrt(-z**2)/z - z*expint(S.Half, -z**2)/sqrt(S.Pi)
assert expand_func(erfi(I*z)) == I*erf(z)
assert erfi(x).as_real_imag() == \
((erfi(re(x) - I*re(x)*Abs(im(x))/Abs(re(x)))/2 +
erfi(re(x) + I*re(x)*Abs(im(x))/Abs(re(x)))/2,
I*(erfi(re(x) - I*re(x)*Abs(im(x))/Abs(re(x))) -
erfi(re(x) + I*re(x)*Abs(im(x))/Abs(re(x)))) *
re(x)*Abs(im(x))/(2*im(x)*Abs(re(x)))))
raises(ArgumentIndexError, lambda: erfi(x).fdiff(2))
def test_erf2inv():
assert erf2inv(0, 0) == S.Zero
assert erf2inv(0, 1) == S.Infinity
assert erf2inv(1, 0) == S.One
assert erf2inv(0, y) == erfinv(y)
assert erf2inv(oo, y) == erfcinv(-y)
assert erf2inv(x, 0) == x
assert erf2inv(x, oo) == erfinv(x)
assert erf2inv(nan, 0) == nan
assert erf2inv(0, nan) == nan
assert erf2inv(x, y).diff(x) == exp(-x**2 + erf2inv(x, y)**2)
assert erf2inv(x, y).diff(y) == sqrt(pi) * exp(erf2inv(x, y)**2) / 2
raises(ArgumentIndexError, lambda: erf2inv(x, y).fdiff(3))
def test_erf():
assert erf(nan) is nan
assert erf(oo) == 1
assert erf(-oo) == -1
assert erf(0) == 0
assert erf(I * oo) == oo * I
assert erf(-I * oo) == -oo * I
assert erf(-2) == -erf(2)
assert erf(-x * y) == -erf(x * y)
assert erf(-x - y) == -erf(x + y)
assert erf(erfinv(x)) == x
assert erf(erfcinv(x)) == 1 - x
assert erf(erf2inv(0, x)) == x
assert erf(erf2inv(0, x, evaluate=False)) == x # To cover code in erf
assert erf(erf2inv(0, erf(erfcinv(1 - erf(erfinv(x)))))) == x
assert erf(I).is_real is False
assert erf(0).is_real is True
assert conjugate(erf(z)) == erf(conjugate(z))
assert erf(x).as_leading_term(x) == 2 * x / sqrt(pi)
assert erf(1 / x).as_leading_term(x) == erf(1 / x)
assert erf(z).rewrite('uppergamma') == sqrt(z**
2) * (1 - erfc(sqrt(z**2))) / z
assert erf(z).rewrite('erfc') == S.One - erfc(z)
assert erf(z).rewrite('erfi') == -I * erfi(I * z)
assert erf(z).rewrite('fresnels') == (1 + I) * (
fresnelc(z * (1 - I) / sqrt(pi)) - I * fresnels(z *
(1 - I) / sqrt(pi)))
assert erf(z).rewrite('fresnelc') == (1 + I) * (
fresnelc(z * (1 - I) / sqrt(pi)) - I * fresnels(z *
(1 - I) / sqrt(pi)))
assert erf(z).rewrite('hyper') == 2 * z * hyper([S.Half], [3 * S.Half],
-z**2) / sqrt(pi)
assert erf(z).rewrite('meijerg') == z * meijerg(
[S.Half], [], [0], [Rational(-1, 2)], z**2) / sqrt(pi)
assert erf(z).rewrite(
'expint') == sqrt(z**2) / z - z * expint(S.Half, z**2) / sqrt(S.Pi)
assert limit(exp(x)*exp(x**2)*(erf(x + 1/exp(x)) - erf(x)), x, oo) == \
2/sqrt(pi)
assert limit((1 - erf(z)) * exp(z**2) * z, z, oo) == 1 / sqrt(pi)
assert limit((1 - erf(x)) * exp(x**2) * sqrt(pi) * x, x, oo) == 1
assert limit(((1 - erf(x)) * exp(x**2) * sqrt(pi) * x - 1) * 2 * x**2, x,
oo) == -1
assert erf(x).as_real_imag() == \
(erf(re(x) - I*im(x))/2 + erf(re(x) + I*im(x))/2,
-I*(-erf(re(x) - I*im(x)) + erf(re(x) + I*im(x)))/2)
assert erf(x).as_real_imag(deep=False) == \
(erf(re(x) - I*im(x))/2 + erf(re(x) + I*im(x))/2,
-I*(-erf(re(x) - I*im(x)) + erf(re(x) + I*im(x)))/2)
assert erf(w).as_real_imag() == (erf(w), 0)
assert erf(w).as_real_imag(deep=False) == (erf(w), 0)
# issue 13575
assert erf(I).as_real_imag() == (0, -I * erf(I))
raises(ArgumentIndexError, lambda: erf(x).fdiff(2))
assert erf(x).inverse() == erfinv
