def test_jacobi():
assert jacobi(0, a, b, x) == 1
assert jacobi(1, a, b, x) == a / 2 - b / 2 + x * (a / 2 + b / 2 + 1)
assert (jacobi(2, a, b, x) == a**2 / 8 - a * b / 4 - a / 8 + b**2 / 8 -
b / 8 + x**2 * (a**2 / 8 + a * b / 4 + 7 * a / 8 + b**2 / 8 +
7 * b / 8 + Rational(3, 2)) + x *
(a**2 / 4 + 3 * a / 4 - b**2 / 4 - 3 * b / 4) - S.Half)
assert jacobi(n, a, a, x) == RisingFactorial(a + 1, n) * gegenbauer(
n, a + Rational(1, 2), x) / RisingFactorial(2 * a + 1, n)
assert jacobi(n, a, -a,
x) == ((-1)**a * (-x + 1)**(-a / 2) * (x + 1)**(a / 2) *
assoc_legendre(n, a, x) * factorial(-a + n) *
gamma(a + n + 1) / (factorial(a + n) * gamma(n + 1)))
assert jacobi(n, -b, b, x) == ((-x + 1)**(b / 2) * (x + 1)**(-b / 2) *
assoc_legendre(n, b, x) *
gamma(-b + n + 1) / gamma(n + 1))
assert jacobi(n, 0, 0, x) == legendre(n, x)
assert jacobi(n, S.Half, S.Half, x) == RisingFactorial(Rational(
3, 2), n) * chebyshevu(n, x) / factorial(n + 1)
assert jacobi(n, -S.Half, -S.Half, x) == RisingFactorial(
Rational(1, 2), n) * chebyshevt(n, x) / factorial(n)
X = jacobi(n, a, b, x)
assert isinstance(X, jacobi)
assert jacobi(n, a, b, -x) == (-1)**n * jacobi(n, b, a, x)
assert jacobi(n, a, b, 0) == 2**(-n) * gamma(a + n + 1) * hyper(
(-b - n, -n), (a + 1, ), -1) / (factorial(n) * gamma(a + 1))
assert jacobi(n, a, b, 1) == RisingFactorial(a + 1, n) / factorial(n)
m = Symbol("m", positive=True)
assert jacobi(m, a, b, oo) == oo * RisingFactorial(a + b + m + 1, m)
assert conjugate(jacobi(m, a, b, x)) == \
jacobi(m, conjugate(a), conjugate(b), conjugate(x))
assert diff(jacobi(n, a, b, x), n) == Derivative(jacobi(n, a, b, x), n)
assert diff(jacobi(n, a, b, x), x) == \
(a/2 + b/2 + n/2 + Rational(1, 2))*jacobi(n - 1, a + 1, b + 1, x)
# XXX see issue sympy/sympy#5539
assert str(jacobi(n, a, b, x).diff(a)) == \
("Sum((jacobi(n, a, b, x) + (a + b + 2*_k + 1)*RisingFactorial(b + "
"_k + 1, n - _k)*jacobi(_k, a, b, x)/((n - _k)*RisingFactorial(a + "
"b + _k + 1, n - _k)))/(a + b + n + _k + 1), (_k, 0, n - 1))")
assert str(jacobi(n, a, b, x).diff(b)) == \
("Sum(((-1)**(n - _k)*(a + b + 2*_k + 1)*RisingFactorial(a + "
"_k + 1, n - _k)*jacobi(_k, a, b, x)/((n - _k)*RisingFactorial(a + "
"b + _k + 1, n - _k)) + jacobi(n, a, b, x))/(a + b + n + "
"_k + 1), (_k, 0, n - 1))")
assert jacobi_normalized(n, a, b, x) == \
(jacobi(n, a, b, x)/sqrt(2**(a + b + 1)*gamma(a + n + 1)*gamma(b + n + 1)
/ ((a + b + 2*n + 1)*factorial(n)*gamma(a + b + n + 1))))
pytest.raises(ValueError, lambda: jacobi(-2.1, a, b, x))
pytest.raises(ValueError,
lambda: jacobi(Dummy(positive=True, integer=True), 1, 2, oo))
pytest.raises(ArgumentIndexError, lambda: jacobi(n, a, b, x).fdiff(5))
def test_laguerre():
assert laguerre(0, x) == 1
assert laguerre(1, x) == -x + 1
assert laguerre(2, x) == x**2/2 - 2*x + 1
assert laguerre(3, x) == -x**3/6 + 3*x**2/2 - 3*x + 1
assert laguerre(n, oo) == (-1)**n*oo
assert laguerre(n, -oo) == oo
assert laguerre(-n, x) == exp(x)*laguerre(n - 1, -x)
X = laguerre(n, x)
assert isinstance(X, laguerre)
assert laguerre(n, 0) == 1
assert conjugate(laguerre(n, x)) == laguerre(n, conjugate(x))
assert diff(laguerre(n, x), x) == -assoc_laguerre(n - 1, 1, x)
pytest.raises(ArgumentIndexError, lambda: laguerre(n, x).fdiff(1))
pytest.raises(ValueError, lambda: laguerre(-2.1, x))
# issue sympy/sympy#10961
X = laguerre(Rational(5, 2), x)
assert isinstance(X, laguerre)
def test_laguerre():
assert laguerre(0, x) == 1
assert laguerre(1, x) == -x + 1
assert laguerre(2, x) == x**2 / 2 - 2 * x + 1
assert laguerre(3, x) == -x**3 / 6 + 3 * x**2 / 2 - 3 * x + 1
assert laguerre(n, oo) == (-1)**n * oo
assert laguerre(n, -oo) == oo
X = laguerre(n, x)
assert isinstance(X, laguerre)
assert laguerre(n, 0) == 1
assert conjugate(laguerre(n, x)) == laguerre(n, conjugate(x))
assert diff(laguerre(n, x), x) == -assoc_laguerre(n - 1, 1, x)
pytest.raises(ArgumentIndexError, lambda: laguerre(n, x).fdiff(1))
pytest.raises(ValueError, lambda: laguerre(-2.1, x))
# issue sympy/sympy#10961
X = laguerre(Rational(5, 2), x)
assert isinstance(X, laguerre)
def test_DiracDelta():
assert DiracDelta(1) == 0
assert DiracDelta(5.1) == 0
assert DiracDelta(-pi) == 0
assert DiracDelta(5, 7) == 0
assert DiracDelta(nan) == nan
assert DiracDelta(0).func is DiracDelta
assert DiracDelta(x).func is DiracDelta
assert adjoint(DiracDelta(x)) == DiracDelta(x)
assert adjoint(DiracDelta(x - y)) == DiracDelta(x - y)
assert conjugate(DiracDelta(x)) == DiracDelta(x)
assert conjugate(DiracDelta(x - y)) == DiracDelta(x - y)
assert transpose(DiracDelta(x)) == DiracDelta(x)
assert transpose(DiracDelta(x - y)) == DiracDelta(x - y)
assert DiracDelta(x).diff(x) == DiracDelta(x, 1)
assert DiracDelta(x, 1).diff(x) == DiracDelta(x, 2)
assert DiracDelta(x).is_simple(x) is True
assert DiracDelta(3 * x).is_simple(x) is True
assert DiracDelta(x**2).is_simple(x) is False
assert DiracDelta(sqrt(x)).is_simple(x) is False
assert DiracDelta(x).is_simple(y) is False
assert DiracDelta(x * y).simplify(x) == DiracDelta(x) / abs(y)
assert DiracDelta(x * y).simplify(y) == DiracDelta(y) / abs(x)
assert DiracDelta(x**2 * y).simplify(x) == DiracDelta(x**2 * y)
assert DiracDelta(y).simplify(x) == DiracDelta(y)
assert DiracDelta((x - 1)*(x - 2)*(x - 3)).simplify(x) == \
DiracDelta(x - 3)/2 + DiracDelta(x - 2) + DiracDelta(x - 1)/2
pytest.raises(ArgumentIndexError, lambda: DiracDelta(x).fdiff(2))
pytest.raises(ValueError, lambda: DiracDelta(x, -1))
def test_adjoint():
Sq = MatrixSymbol('Sq', n, n)
assert Adjoint(A).shape == (m, n)
assert Adjoint(A * B).shape == (l, n)
assert adjoint(Adjoint(A)) == A
assert isinstance(Adjoint(Adjoint(A)), Adjoint)
assert conjugate(Adjoint(A)) == Transpose(A) == Adjoint(A).conjugate()
assert transpose(Adjoint(A)) == Adjoint(
Transpose(A)) == Transpose(A).adjoint()
assert Adjoint(eye(3)).doit() == Adjoint(eye(3)).doit(deep=False) == eye(3)
assert Adjoint(Integer(5)).doit() == Integer(5)
assert Adjoint(Matrix([[1, 2], [3, 4]])).doit() == Matrix([[1, 3], [2, 4]])
assert adjoint(trace(Sq)) == conjugate(trace(Sq))
assert trace(adjoint(Sq)) == conjugate(trace(Sq))
assert Adjoint(Sq)[0, 1] == conjugate(Sq[1, 0])
assert Adjoint(A * B).doit() == Adjoint(B) * Adjoint(A)
assert Adjoint(C + D).doit() == Adjoint(C) + Adjoint(D)
def test_gamma():
assert gamma(nan) == nan
assert gamma(oo) == oo
assert gamma(-100) == zoo
assert gamma(0) == zoo
assert gamma(1) == 1
assert gamma(2) == 1
assert gamma(3) == 2
assert gamma(102) == factorial(101)
assert gamma(Rational(1, 2)) == sqrt(pi)
assert gamma(Rational(3, 2)) == Rational(1, 2)*sqrt(pi)
assert gamma(Rational(5, 2)) == Rational(3, 4)*sqrt(pi)
assert gamma(Rational(7, 2)) == Rational(15, 8)*sqrt(pi)
assert gamma(Rational(-1, 2)) == -2*sqrt(pi)
assert gamma(Rational(-3, 2)) == Rational(4, 3)*sqrt(pi)
assert gamma(Rational(-5, 2)) == -Rational(8, 15)*sqrt(pi)
assert gamma(Rational(-15, 2)) == Rational(256, 2027025)*sqrt(pi)
assert gamma(Rational(
-11, 8)).expand(func=True) == Rational(64, 33)*gamma(Rational(5, 8))
assert gamma(Rational(
-10, 3)).expand(func=True) == Rational(81, 280)*gamma(Rational(2, 3))
assert gamma(Rational(
14, 3)).expand(func=True) == Rational(880, 81)*gamma(Rational(2, 3))
assert gamma(Rational(
17, 7)).expand(func=True) == Rational(30, 49)*gamma(Rational(3, 7))
assert gamma(Rational(
19, 8)).expand(func=True) == Rational(33, 64)*gamma(Rational(3, 8))
assert gamma(x).diff(x) == gamma(x)*polygamma(0, x)
pytest.raises(ArgumentIndexError, lambda: gamma(x).fdiff(2))
assert gamma(x - 1).expand(func=True) == gamma(x)/(x - 1)
assert gamma(x + 2).expand(func=True, mul=False) == x*(x + 1)*gamma(x)
assert conjugate(gamma(x)) == gamma(conjugate(x))
assert expand_func(gamma(x + Rational(3, 2))) == \
(x + Rational(1, 2))*gamma(x + Rational(1, 2))
assert expand_func(gamma(x - Rational(1, 2))) == \
gamma(Rational(1, 2) + x)/(x - Rational(1, 2))
# Test a bug:
assert expand_func(gamma(x + Rational(3, 4))) == gamma(x + Rational(3, 4))
assert gamma(3*exp_polar(I*pi)/4).is_nonnegative is False
assert gamma(3*exp_polar(I*pi)/4).is_nonpositive is True
# Issue sympy/sympy#8526
k = Symbol('k', integer=True, nonnegative=True)
assert isinstance(gamma(k), gamma)
assert gamma(-k) == zoo
def test_sympyissue_11581():
x = Symbol('x', real=True)
y = Symbol('y', real=True)
r = sqrt(x**2 + y**2)
assert conjugate(r) == r
s = abs(x + I * y)
assert conjugate(s) == r
def test_heaviside():
x, y = symbols('x, y', extended_real=True)
z = Symbol('z')
assert Heaviside(0) == 0.5
assert Heaviside(-5) == 0
assert Heaviside(1) == 1
assert Heaviside(nan) == nan
assert Heaviside(x).is_real
assert Heaviside(z).is_real is None
assert adjoint(Heaviside(x)) == Heaviside(x)
assert adjoint(Heaviside(x - y)) == Heaviside(x - y)
assert conjugate(Heaviside(x)) == Heaviside(x)
assert conjugate(Heaviside(x - y)) == Heaviside(x - y)
assert transpose(Heaviside(x)) == Heaviside(x)
assert transpose(Heaviside(x - y)) == Heaviside(x - y)
assert Heaviside(x).diff(x) == DiracDelta(x)
assert Heaviside(z + I).is_Function is True
assert Heaviside(I * z).is_Function is True
pytest.raises(ArgumentIndexError, lambda: Heaviside(x).fdiff(2))
pytest.raises(ValueError, lambda: Heaviside(I))
pytest.raises(ValueError, lambda: Heaviside(2 + 3 * I))
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, w).is_extended_real is False
assert erf2(2*w, w).is_extended_real is True
assert erf2(z, w).is_extended_real is None
assert erf2(w, z).is_extended_real is None
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))
pytest.raises(ArgumentIndexError, lambda: erfi(x).fdiff(3))
def test_erfc():
assert erfc(nan) == nan
assert erfc(oo) == 0
assert erfc(-oo) == 2
assert erfc(0) == 1
assert erfc(I * oo) == -oo * I
assert erfc(-I * oo) == oo * I
assert erfc(-x) == Integer(2) - erfc(x)
assert erfc(erfcinv(x)) == x
assert erfc(erfinv(x)) == 1 - x
assert erfc(I).is_extended_real is False
assert erfc(w).is_extended_real is True
assert erfc(z).is_extended_real is None
assert conjugate(erfc(z)) == erfc(conjugate(z))
assert erfc(x).as_leading_term(x) == 1
assert erfc(1 / x).as_leading_term(x) == erfc(1 / x)
assert erfc(z).rewrite('erf') == 1 - erf(z)
assert erfc(z).rewrite('erfi') == 1 + I * erfi(I * z)
assert erfc(z).rewrite('fresnels') == 1 - (1 + I) * (
fresnelc(z * (1 - I) / sqrt(pi)) - I * fresnels(z *
(1 - I) / sqrt(pi)))
assert erfc(z).rewrite('fresnelc') == 1 - (1 + I) * (
fresnelc(z * (1 - I) / sqrt(pi)) - I * fresnels(z *
(1 - I) / sqrt(pi)))
assert erfc(z).rewrite('hyper') == 1 - 2 * z * hyper(
[Rational(1, 2)], [Rational(3, 2)], -z**2) / sqrt(pi)
assert erfc(z).rewrite('meijerg') == 1 - z * meijerg(
[Rational(1, 2)], [], [0], [Rational(-1, 2)], z**2) / sqrt(pi)
assert erfc(z).rewrite(
'uppergamma') == 1 - sqrt(z**2) * erf(sqrt(z**2)) / z
assert erfc(z).rewrite('expint') == 1 - sqrt(z**2) / z + z * expint(
Rational(1, 2), z**2) / sqrt(pi)
assert erfc(x).as_real_imag() == \
((erfc(re(x) - I*re(x)*abs(im(x))/abs(re(x)))/2 +
erfc(re(x) + I*re(x)*abs(im(x))/abs(re(x)))/2,
I*(erfc(re(x) - I*re(x)*abs(im(x))/abs(re(x))) -
erfc(re(x) + I*re(x)*abs(im(x))/abs(re(x)))) *
re(x)*abs(im(x))/(2*im(x)*abs(re(x)))))
assert erfc(x).as_real_imag(deep=False) == erfc(x).as_real_imag()
assert erfc(w).as_real_imag() == (erfc(w), 0)
assert erfc(w).as_real_imag(deep=False) == erfc(w).as_real_imag()
assert erfc(I).as_real_imag() == (1, -erfi(1))
pytest.raises(ArgumentIndexError, lambda: erfc(x).fdiff(2))
assert erfc(x).taylor_term(3, x, *(-2 * x / sqrt(pi),
0)) == 2 * x**3 / 3 / sqrt(pi)
assert erfc(x).limit(x, oo) == 0
assert erfc(x).diff(x) == -2 * exp(-x**2) / sqrt(pi)
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_extended_real is False
assert erf(w).is_extended_real is True
assert erf(z).is_extended_real is None
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) * erf(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)))))
pytest.raises(ArgumentIndexError, lambda: erf(x).fdiff(2))
def test_conjugate_transpose():
A, B = symbols("A B", commutative=False)
p = Piecewise((A * B**2, x > 0), (A**2 * B, True))
assert p.adjoint() == \
Piecewise((adjoint(A*B**2), x > 0), (adjoint(A**2*B), True))
assert p.conjugate() == \
Piecewise((conjugate(A*B**2), x > 0), (conjugate(A**2*B), True))
assert p.transpose() == \
Piecewise((transpose(A*B**2), x > 0), (transpose(A**2*B), True))
def test_conjugate_transpose():
A, B = symbols("A B", commutative=False)
p = Piecewise((A*B**2, x > 0), (A**2*B, True))
assert p.adjoint() == \
Piecewise((adjoint(A*B**2), x > 0), (adjoint(A**2*B), True))
assert p.conjugate() == \
Piecewise((conjugate(A*B**2), x > 0), (conjugate(A**2*B), True))
assert p.transpose() == \
Piecewise((transpose(A*B**2), x > 0), (transpose(A**2*B), True))
def test_erfi():
assert erfi(nan) == nan
assert erfi(+oo) == +oo
assert erfi(-oo) == -oo
assert erfi(0) == 0
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_extended_real is False
assert erfi(w).is_extended_real is True
assert erfi(z).is_extended_real is None
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(
[Rational(1, 2)], [Rational(3, 2)], z**2) / sqrt(pi)
assert erfi(z).rewrite('meijerg') == z * meijerg(
[Rational(1, 2)], [], [0], [Rational(-1, 2)], -z**2) / sqrt(pi)
assert erfi(z).rewrite('uppergamma') == (
sqrt(-z**2) / z * (uppergamma(Rational(1, 2), -z**2) / sqrt(pi) - 1))
assert erfi(z).rewrite('expint') == sqrt(-z**2) / z - z * expint(
Rational(1, 2), -z**2) / sqrt(pi)
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)))))
assert erfi(x).as_real_imag(deep=False) == erfi(x).as_real_imag()
assert erfi(w).as_real_imag() == (erfi(w), 0)
assert erfi(w).as_real_imag(deep=False) == erfi(w).as_real_imag()
assert erfi(I).as_real_imag() == (0, erf(1))
pytest.raises(ArgumentIndexError, lambda: erfi(x).fdiff(2))
assert erfi(x).taylor_term(3, x, *(2 * x / sqrt(pi),
0)) == 2 * x**3 / 3 / sqrt(pi)
assert erfi(x).limit(x, oo) == oo
def test_jacobi():
assert jacobi(0, a, b, x) == 1
assert jacobi(1, a, b, x) == a/2 - b/2 + x*(a/2 + b/2 + 1)
assert (jacobi(2, a, b, x) == a**2/8 - a*b/4 - a/8 + b**2/8 - b/8 +
x**2*(a**2/8 + a*b/4 + 7*a/8 + b**2/8 + 7*b/8 + Rational(3, 2)) +
x*(a**2/4 + 3*a/4 - b**2/4 - 3*b/4) - Rational(1, 2))
assert jacobi(n, a, a, x) == RisingFactorial(
a + 1, n)*gegenbauer(n, a + Rational(1, 2), x)/RisingFactorial(2*a + 1, n)
assert jacobi(n, a, -a, x) == ((-1)**a*(-x + 1)**(-a/2)*(x + 1)**(a/2)*assoc_legendre(n, a, x) *
factorial(-a + n)*gamma(a + n + 1)/(factorial(a + n)*gamma(n + 1)))
assert jacobi(n, -b, b, x) == ((-x + 1)**(b/2)*(x + 1)**(-b/2)*assoc_legendre(n, b, x) *
gamma(-b + n + 1)/gamma(n + 1))
assert jacobi(n, 0, 0, x) == legendre(n, x)
assert jacobi(n, Rational(1, 2), Rational(1, 2), x) == RisingFactorial(
Rational(3, 2), n)*chebyshevu(n, x)/factorial(n + 1)
assert jacobi(n, Rational(-1, 2), Rational(-1, 2), x) == RisingFactorial(
Rational(1, 2), n)*chebyshevt(n, x)/factorial(n)
X = jacobi(n, a, b, x)
assert isinstance(X, jacobi)
assert jacobi(n, a, b, -x) == (-1)**n*jacobi(n, b, a, x)
assert jacobi(n, a, b, 0) == 2**(-n)*gamma(a + n + 1)*hyper(
(-b - n, -n), (a + 1,), -1)/(factorial(n)*gamma(a + 1))
assert jacobi(n, a, b, 1) == RisingFactorial(a + 1, n)/factorial(n)
m = Symbol("m", positive=True)
assert jacobi(m, a, b, oo) == oo*RisingFactorial(a + b + m + 1, m)
assert jacobi(n, a, b, oo) == jacobi(n, a, b, oo, evaluate=False)
assert conjugate(jacobi(m, a, b, x)) == \
jacobi(m, conjugate(a), conjugate(b), conjugate(x))
assert diff(jacobi(n, a, b, x), n) == Derivative(jacobi(n, a, b, x), n)
assert diff(jacobi(n, a, b, x), x) == \
(a/2 + b/2 + n/2 + Rational(1, 2))*jacobi(n - 1, a + 1, b + 1, x)
# XXX see issue sympy/sympy#5539
assert str(jacobi(n, a, b, x).diff(a)) == \
("Sum((jacobi(n, a, b, x) + (a + b + 2*_k + 1)*RisingFactorial(b + "
"_k + 1, n - _k)*jacobi(_k, a, b, x)/((n - _k)*RisingFactorial(a + "
"b + _k + 1, n - _k)))/(a + b + n + _k + 1), (_k, 0, n - 1))")
assert str(jacobi(n, a, b, x).diff(b)) == \
("Sum(((-1)**(n - _k)*(a + b + 2*_k + 1)*RisingFactorial(a + "
"_k + 1, n - _k)*jacobi(_k, a, b, x)/((n - _k)*RisingFactorial(a + "
"b + _k + 1, n - _k)) + jacobi(n, a, b, x))/(a + b + n + "
"_k + 1), (_k, 0, n - 1))")
assert jacobi_normalized(n, a, b, x) == \
(jacobi(n, a, b, x)/sqrt(2**(a + b + 1)*gamma(a + n + 1)*gamma(b + n + 1)
/ ((a + b + 2*n + 1)*factorial(n)*gamma(a + b + n + 1))))
pytest.raises(ValueError, lambda: jacobi(-2.1, a, b, x))
pytest.raises(ValueError, lambda: jacobi(Dummy(positive=True, integer=True), 1, 2, oo))
pytest.raises(ArgumentIndexError, lambda: jacobi(n, a, b, x).fdiff(5))
def test_erfc():
assert erfc(nan) == nan
assert erfc(oo) == 0
assert erfc(-oo) == 2
assert erfc(0) == 1
assert erfc(I*oo) == -oo*I
assert erfc(-I*oo) == oo*I
assert erfc(-x) == Integer(2) - erfc(x)
assert erfc(erfcinv(x)) == x
assert erfc(erfinv(x)) == 1 - x
assert erfc(I).is_extended_real is False
assert erfc(w).is_extended_real is True
assert erfc(z).is_extended_real is None
assert conjugate(erfc(z)) == erfc(conjugate(z))
assert erfc(x).as_leading_term(x) == 1
assert erfc(1/x).as_leading_term(x) == erfc(1/x)
assert erfc(z).rewrite('erf') == 1 - erf(z)
assert erfc(z).rewrite('erfi') == 1 + I*erfi(I*z)
assert erfc(z).rewrite('fresnels') == 1 - (1 + I)*(fresnelc(z*(1 - I)/sqrt(pi)) -
I*fresnels(z*(1 - I)/sqrt(pi)))
assert erfc(z).rewrite('fresnelc') == 1 - (1 + I)*(fresnelc(z*(1 - I)/sqrt(pi)) -
I*fresnels(z*(1 - I)/sqrt(pi)))
assert erfc(z).rewrite('hyper') == 1 - 2*z*hyper([Rational(1, 2)], [Rational(3, 2)], -z**2)/sqrt(pi)
assert erfc(z).rewrite('meijerg') == 1 - z*meijerg([Rational(1, 2)], [], [0], [Rational(-1, 2)], z**2)/sqrt(pi)
assert erfc(z).rewrite('uppergamma') == 1 - sqrt(z**2)*erf(sqrt(z**2))/z
assert erfc(z).rewrite('expint') == 1 - sqrt(z**2)/z + z*expint(Rational(1, 2), z**2)/sqrt(pi)
assert erfc(x).as_real_imag() == \
((erfc(re(x) - I*re(x)*Abs(im(x))/Abs(re(x)))/2 +
erfc(re(x) + I*re(x)*Abs(im(x))/Abs(re(x)))/2,
I*(erfc(re(x) - I*re(x)*Abs(im(x))/Abs(re(x))) -
erfc(re(x) + I*re(x)*Abs(im(x))/Abs(re(x)))) *
re(x)*Abs(im(x))/(2*im(x)*Abs(re(x)))))
assert erfc(x).as_real_imag(deep=False) == erfc(x).as_real_imag()
assert erfc(w).as_real_imag() == (erfc(w), 0)
assert erfc(w).as_real_imag(deep=False) == erfc(w).as_real_imag()
assert erfc(I).as_real_imag() == (1, -erfi(1))
pytest.raises(ArgumentIndexError, lambda: erfc(x).fdiff(2))
assert erfc(x).taylor_term(3, x, *(-2*x/sqrt(pi), 0)) == 2*x**3/3/sqrt(pi)
assert erfc(x).limit(x, oo) == 0
assert erfc(x).diff(x) == -2*exp(-x**2)/sqrt(pi)
def test_chebyshev():
assert chebyshevt(0, x) == 1
assert chebyshevt(1, x) == x
assert chebyshevt(2, x) == 2*x**2 - 1
assert chebyshevt(3, x) == 4*x**3 - 3*x
assert chebyshevt(-2, x) == 2*x**2 - 1
for n in range(1, 4):
for k in range(n):
z = chebyshevt_root(n, k)
assert chebyshevt(n, z) == 0
pytest.raises(ValueError, lambda: chebyshevt_root(n, n))
for n in range(1, 4):
for k in range(n):
z = chebyshevu_root(n, k)
assert chebyshevu(n, z) == 0
pytest.raises(ValueError, lambda: chebyshevu_root(n, n))
n = Symbol("n")
X = chebyshevt(n, x)
assert isinstance(X, chebyshevt)
assert chebyshevt(n, -x) == (-1)**n*chebyshevt(n, x)
assert chebyshevt(-n, x) == chebyshevt(n, x)
assert chebyshevt(n, oo) == oo
assert chebyshevt(n, 0) == cos(pi*n/2)
assert chebyshevt(n, 1) == 1
assert conjugate(chebyshevt(n, x)) == chebyshevt(n, conjugate(x))
assert diff(chebyshevt(n, x), x) == n*chebyshevu(n - 1, x)
pytest.raises(ArgumentIndexError, lambda: chebyshevt(n, x).fdiff(1))
X = chebyshevu(n, x)
assert isinstance(X, chebyshevu)
assert chebyshevu(n, -x) == (-1)**n*chebyshevu(n, x)
assert chebyshevu(-n, x) == -chebyshevu(n - 2, x)
assert chebyshevu(n, oo) == oo
assert chebyshevu(n, 0) == cos(pi*n/2)
assert chebyshevu(n, 1) == n + 1
assert chebyshevu(-1, x) == 0
assert chebyshevu(-2, x) == -1
assert conjugate(chebyshevu(n, x)) == chebyshevu(n, conjugate(x))
assert diff(chebyshevu(n, x), x) == \
(-x*chebyshevu(n, x) + (n + 1)*chebyshevt(n + 1, x))/(x**2 - 1)
pytest.raises(ArgumentIndexError, lambda: chebyshevu(n, x).fdiff(1))
def test_chebyshev():
assert chebyshevt(0, x) == 1
assert chebyshevt(1, x) == x
assert chebyshevt(2, x) == 2*x**2 - 1
assert chebyshevt(3, x) == 4*x**3 - 3*x
assert chebyshevt(-2, x) == 2*x**2 - 1
for n in range(1, 4):
for k in range(n):
z = chebyshevt_root(n, k)
assert chebyshevt(n, z) == 0
pytest.raises(ValueError, lambda: chebyshevt_root(n, n))
for n in range(1, 4):
for k in range(n):
z = chebyshevu_root(n, k)
assert chebyshevu(n, z) == 0
pytest.raises(ValueError, lambda: chebyshevu_root(n, n))
n = Symbol('n')
X = chebyshevt(n, x)
assert isinstance(X, chebyshevt)
assert chebyshevt(n, -x) == (-1)**n*chebyshevt(n, x)
assert chebyshevt(-n, x) == chebyshevt(n, x)
assert chebyshevt(n, oo) == oo
assert chebyshevt(n, 0) == cos(pi*n/2)
assert chebyshevt(n, 1) == 1
assert conjugate(chebyshevt(n, x)) == chebyshevt(n, conjugate(x))
assert diff(chebyshevt(n, x), x) == n*chebyshevu(n - 1, x)
pytest.raises(ArgumentIndexError, lambda: chebyshevt(n, x).fdiff(1))
X = chebyshevu(n, x)
assert isinstance(X, chebyshevu)
assert chebyshevu(n, -x) == (-1)**n*chebyshevu(n, x)
assert chebyshevu(-n, x) == -chebyshevu(n - 2, x)
assert chebyshevu(n, oo) == oo
assert chebyshevu(n, 0) == cos(pi*n/2)
assert chebyshevu(n, 1) == n + 1
assert chebyshevu(-1, x) == 0
assert chebyshevu(-2, x) == -1
assert conjugate(chebyshevu(n, x)) == chebyshevu(n, conjugate(x))
assert diff(chebyshevu(n, x), x) == \
(-x*chebyshevu(n, x) + (n + 1)*chebyshevt(n + 1, x))/(x**2 - 1)
pytest.raises(ArgumentIndexError, lambda: chebyshevu(n, x).fdiff(1))
def test_beta():
assert isinstance(beta(x, y), beta)
assert expand_func(beta(x, y)) == gamma(x)*gamma(y)/gamma(x + y)
assert expand_func(beta(x, y) - beta(y, x)) == 0 # Symmetric
assert expand_func(beta(x, y)) == expand_func(beta(x, y + 1) +
beta(x + 1, y)).simplify()
assert diff(beta(x, y), x) == beta(x, y)*(digamma(x) - digamma(x + y))
assert diff(beta(x, y), y) == beta(x, y)*(digamma(y) - digamma(x + y))
pytest.raises(ArgumentIndexError, lambda: beta(x, y).fdiff(3))
assert conjugate(beta(x, y)) == beta(conjugate(x), conjugate(y))
def test_airy_base():
z = Symbol('z')
x = Symbol('x', extended_real=True)
y = Symbol('y', extended_real=True)
assert conjugate(airyai(z)) == airyai(conjugate(z))
assert airyai(x).is_extended_real
assert airyai(z).is_extended_real is None
assert airyai(x+I*y).as_real_imag() == (
airyai(x - I*x*Abs(y)/Abs(x))/2 + airyai(x + I*x*Abs(y)/Abs(x))/2,
I*x*(airyai(x - I*x*Abs(y)/Abs(x)) -
airyai(x + I*x*Abs(y)/Abs(x)))*Abs(y)/(2*y*Abs(x)))
def test_transpose():
assert transpose(A).is_commutative is False
assert transpose(A * A) == transpose(A)**2
assert transpose(A * B) == transpose(B) * transpose(A)
assert transpose(A * B**2) == transpose(B)**2 * transpose(A)
assert transpose(A*B - B*A) == \
transpose(B)*transpose(A) - transpose(A)*transpose(B)
assert transpose(A + I * B) == transpose(A) + I * transpose(B)
assert transpose(X) == conjugate(X)
assert transpose(-I * X) == -I * conjugate(X)
assert transpose(Y) == -conjugate(Y)
assert transpose(-I * Y) == I * conjugate(Y)
def test_order_conjugate_transpose():
x = Symbol('x', extended_real=True)
y = Symbol('y', imaginary=True)
assert conjugate(O(x)) == O(conjugate(x))
assert conjugate(O(y)) == O(conjugate(y))
assert conjugate(O(x**2)) == O(conjugate(x)**2)
assert conjugate(O(y**2)) == O(conjugate(y)**2)
assert conjugate(O(z)) == conjugate(O(z), evaluate=False)
assert transpose(O(x)) == O(transpose(x))
assert transpose(O(y)) == O(transpose(y))
assert transpose(O(x**2)) == O(transpose(x)**2)
assert transpose(O(y**2)) == O(transpose(y)**2)
assert transpose(O(z)) == transpose(O(z), evaluate=False)
def test_beta():
assert isinstance(beta(x, y), beta)
assert expand_func(beta(x, y)) == gamma(x) * gamma(y) / gamma(x + y)
assert expand_func(beta(x, y) - beta(y, x)) == 0 # Symmetric
assert expand_func(beta(
x, y)) == expand_func(beta(x, y + 1) + beta(x + 1, y)).simplify()
assert diff(beta(x, y), x) == beta(x, y) * (digamma(x) - digamma(x + y))
assert diff(beta(x, y), y) == beta(x, y) * (digamma(y) - digamma(x + y))
pytest.raises(ArgumentIndexError, lambda: beta(x, y).fdiff(3))
assert conjugate(beta(x, y)) == beta(conjugate(x), conjugate(y))
def test_airy_base():
z = Symbol('z')
x = Symbol('x', extended_real=True)
y = Symbol('y', extended_real=True)
assert conjugate(airyai(z)) == airyai(conjugate(z))
assert airyai(x).is_extended_real
assert airyai(z).is_extended_real is None
assert airyai(x+I*y).as_real_imag() == (
airyai(x - I*x*abs(y)/abs(x))/2 + airyai(x + I*x*abs(y)/abs(x))/2,
I*x*(airyai(x - I*x*abs(y)/abs(x)) -
airyai(x + I*x*abs(y)/abs(x)))*abs(y)/(2*y*abs(x)))
def test_erfi():
assert erfi(nan) == nan
assert erfi(+oo) == +oo
assert erfi(-oo) == -oo
assert erfi(0) == 0
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_extended_real is False
assert erfi(w).is_extended_real is True
assert erfi(z).is_extended_real is None
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([Rational(1, 2)], [Rational(3, 2)], z**2)/sqrt(pi)
assert erfi(z).rewrite('meijerg') == z*meijerg([Rational(1, 2)], [], [0], [Rational(-1, 2)], -z**2)/sqrt(pi)
assert erfi(z).rewrite('uppergamma') == (sqrt(-z**2)/z*(uppergamma(Rational(1, 2),
-z**2)/sqrt(pi) - 1))
assert erfi(z).rewrite('expint') == sqrt(-z**2)/z - z*expint(Rational(1, 2), -z**2)/sqrt(pi)
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)))))
assert erfi(x).as_real_imag(deep=False) == erfi(x).as_real_imag()
assert erfi(w).as_real_imag() == (erfi(w), 0)
assert erfi(w).as_real_imag(deep=False) == erfi(w).as_real_imag()
assert erfi(I).as_real_imag() == (0, erf(1))
pytest.raises(ArgumentIndexError, lambda: erfi(x).fdiff(2))
assert erfi(x).taylor_term(3, x, *(2*x/sqrt(pi), 0)) == 2*x**3/3/sqrt(pi)
assert erfi(x).limit(x, oo) == oo
def test_elliptic_e():
assert elliptic_e(z, 0) == z
assert elliptic_e(0, m) == 0
assert elliptic_e(i * pi / 2, m) == i * elliptic_e(m)
assert elliptic_e(z, oo) == zoo
assert elliptic_e(z, -oo) == zoo
assert elliptic_e(0) == pi / 2
assert elliptic_e(1) == 1
assert elliptic_e(oo) == I * oo
assert elliptic_e(-oo) == oo
assert elliptic_e(zoo) == zoo
assert elliptic_e(-z, m) == -elliptic_e(z, m)
assert elliptic_e(z, m).diff(z) == sqrt(1 - m * sin(z)**2)
assert elliptic_e(
z, m).diff(m) == (elliptic_e(z, m) - elliptic_f(z, m)) / (2 * m)
assert elliptic_e(z).diff(z) == (elliptic_e(z) - elliptic_k(z)) / (2 * z)
r = randcplx()
assert td(elliptic_e(r, m), m)
assert td(elliptic_e(z, r), z)
assert td(elliptic_e(z), z)
pytest.raises(ArgumentIndexError, lambda: elliptic_e(z, m).fdiff(3))
pytest.raises(ArgumentIndexError, lambda: elliptic_e(z).fdiff(2))
mi = Symbol('m', extended_real=False)
assert elliptic_e(z, mi).conjugate() == elliptic_e(z.conjugate(),
mi.conjugate())
assert elliptic_e(mi).conjugate() == elliptic_e(mi.conjugate())
mr = Symbol('m', extended_real=True, negative=True)
assert elliptic_e(z, mr).conjugate() == elliptic_e(z.conjugate(), mr)
assert elliptic_e(mr).conjugate() == elliptic_e(mr)
assert elliptic_e(z, m).conjugate() == conjugate(elliptic_e(z, m))
assert elliptic_e(z).conjugate() == conjugate(elliptic_e(z))
assert elliptic_e(z).rewrite(hyper) == (pi / 2) * hyper(
(Rational(-1, 2), Rational(1, 2)), (1, ), z)
assert elliptic_e(z, m).rewrite(hyper) == elliptic_e(z, m)
assert tn(elliptic_e(z), (pi / 2) * hyper(
(Rational(-1, 2), Rational(1, 2)), (1, ), z))
assert elliptic_e(z).rewrite(meijerg) == \
-meijerg(((Rational(1, 2), Rational(3, 2)), []), ((0,), (0,)), -z)/4
assert elliptic_e(z, m).rewrite(meijerg) == elliptic_e(z, m)
assert tn(
elliptic_e(z), -meijerg(((Rational(1, 2), Rational(3, 2)), []),
((0, ), (0, )), -z) / 4)
assert elliptic_e(z, m).series(z) == \
z + z**5*(-m**2/40 + m/30) - m*z**3/6 + O(z**6)
assert elliptic_e(z).series(z) == pi/2 - pi*z/8 - 3*pi*z**2/128 - \
5*pi*z**3/512 - 175*pi*z**4/32768 - 441*pi*z**5/131072 + O(z**6)
def test_transpose():
assert transpose(A).is_commutative is False
assert transpose(A*A) == transpose(A)**2
assert transpose(A*B) == transpose(B)*transpose(A)
assert transpose(A*B**2) == transpose(B)**2*transpose(A)
assert transpose(A*B - B*A) == \
transpose(B)*transpose(A) - transpose(A)*transpose(B)
assert transpose(A + I*B) == transpose(A) + I*transpose(B)
assert transpose(X) == conjugate(X)
assert transpose(-I*X) == -I*conjugate(X)
assert transpose(Y) == -conjugate(Y)
assert transpose(-I*Y) == I*conjugate(Y)
assert transpose(X**pi) == transpose(X**pi, evaluate=False)
def test_erfc():
assert erfc(nan) == nan
assert erfc(oo) == 0
assert erfc(-oo) == 2
assert erfc(0) == 1
assert erfc(I * oo) == -oo * I
assert erfc(-I * oo) == oo * I
assert erfc(-x) == Integer(2) - erfc(x)
assert erfc(erfcinv(x)) == x
assert erfc(I).is_extended_real is False
assert erfc(w).is_extended_real is True
assert erfc(z).is_extended_real is None
assert conjugate(erfc(z)) == erfc(conjugate(z))
assert erfc(x).as_leading_term(x) == S.One
assert erfc(1 / x).as_leading_term(x) == erfc(1 / x)
assert erfc(z).rewrite('erf') == 1 - erf(z)
assert erfc(z).rewrite('erfi') == 1 + I * erfi(I * z)
assert erfc(z).rewrite('fresnels') == 1 - (1 + I) * (
fresnelc(z * (1 - I) / sqrt(pi)) - I * fresnels(z *
(1 - I) / sqrt(pi)))
assert erfc(z).rewrite('fresnelc') == 1 - (1 + I) * (
fresnelc(z * (1 - I) / sqrt(pi)) - I * fresnels(z *
(1 - I) / sqrt(pi)))
assert erfc(z).rewrite(
'hyper') == 1 - 2 * z * hyper([S.Half], [3 * S.Half], -z**2) / sqrt(pi)
assert erfc(z).rewrite('meijerg') == 1 - z * meijerg(
[S.Half], [], [0], [-S.Half], z**2) / sqrt(pi)
assert erfc(z).rewrite(
'uppergamma') == 1 - sqrt(z**2) * erf(sqrt(z**2)) / z
assert erfc(z).rewrite('expint') == S.One - sqrt(z**2) / z + z * expint(
S.Half, z**2) / sqrt(S.Pi)
assert erfc(x).as_real_imag() == \
((erfc(re(x) - I*re(x)*Abs(im(x))/Abs(re(x)))/2 +
erfc(re(x) + I*re(x)*Abs(im(x))/Abs(re(x)))/2,
I*(erfc(re(x) - I*re(x)*Abs(im(x))/Abs(re(x))) -
erfc(re(x) + I*re(x)*Abs(im(x))/Abs(re(x)))) *
re(x)*Abs(im(x))/(2*im(x)*Abs(re(x)))))
pytest.raises(ArgumentIndexError, lambda: erfc(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_extended_real is False
assert erfi(w).is_extended_real is True
assert erfi(z).is_extended_real is None
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 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)))))
pytest.raises(ArgumentIndexError, lambda: erfi(x).fdiff(2))
def test_assoc_legendre():
Plm = assoc_legendre
Q = sqrt(1 - x**2)
assert Plm(0, 0, x) == 1
assert Plm(1, 0, x) == x
assert Plm(1, 1, x) == -Q
assert Plm(2, 0, x) == (3 * x**2 - 1) / 2
assert Plm(2, 1, x) == -3 * x * Q
assert Plm(2, 2, x) == 3 * Q**2
assert Plm(3, 0, x) == (5 * x**3 - 3 * x) / 2
assert Plm(3, 1,
x).expand() == ((3 * (1 - 5 * x**2) / 2).expand() * Q).expand()
assert Plm(3, 2, x) == 15 * x * Q**2
assert Plm(3, 3, x) == -15 * Q**3
# negative m
assert Plm(1, -1, x) == -Plm(1, 1, x) / 2
assert Plm(2, -2, x) == Plm(2, 2, x) / 24
assert Plm(2, -1, x) == -Plm(2, 1, x) / 6
assert Plm(3, -3, x) == -Plm(3, 3, x) / 720
assert Plm(3, -2, x) == Plm(3, 2, x) / 120
assert Plm(3, -1, x) == -Plm(3, 1, x) / 12
X = Plm(n, m, x)
assert isinstance(X, assoc_legendre)
assert Plm(n, 0, x) == legendre(n, x)
assert Plm(n, m, 0) == 2**m * sqrt(pi) / (gamma(
(1 - m - n) / 2) * gamma(1 - (m - n) / 2))
pytest.raises(ValueError, lambda: Plm(-1, 0, x))
pytest.raises(ValueError, lambda: Plm(0, 1, x))
pytest.raises(ValueError, lambda: Plm(-1, 2, x))
assert conjugate(assoc_legendre(n, m, x)) == \
assoc_legendre(n, conjugate(m), conjugate(x))
assert assoc_legendre(n, m, x).diff(x) == \
(n*x*assoc_legendre(n, m, x) -
(m + n)*assoc_legendre(n - 1, m, x))/(x**2 - 1)
pytest.raises(ArgumentIndexError, lambda: assoc_legendre(n, m, x).fdiff(1))
assert (str(assoc_laguerre(
n, m,
x).diff(m)) == 'Sum(assoc_laguerre(_k, m, x)/(-m + n), (_k, 0, n - 1))'
)
def test_Trace():
assert isinstance(Trace(A), Trace)
assert not isinstance(Trace(A), MatrixExpr)
pytest.raises(ShapeError, lambda: Trace(C))
assert trace(eye(3)) == 3
assert trace(Matrix(3, 3, [1, 2, 3, 4, 5, 6, 7, 8, 9])) == 15
assert adjoint(Trace(A)) == trace(Adjoint(A))
assert conjugate(Trace(A)) == trace(Adjoint(A))
assert transpose(Trace(A)) == Trace(A)
assert isinstance(A / Trace(A), MatrixExpr)
# Some easy simplifications
assert trace(Identity(5)) == 5
assert trace(ZeroMatrix(5, 5)) == 0
assert trace(2 * A * B) == 2 * Trace(A * B)
assert trace(A.T) == trace(A)
i, j = symbols('i j')
F = FunctionMatrix(3, 3, Lambda((i, j), i + j))
assert trace(F) == (0 + 0) + (1 + 1) + (2 + 2)
pytest.raises(TypeError, lambda: Trace(1))
assert Trace(A).arg is A
assert str(trace(A)) == str(Trace(A).doit())
def test_elliptic_f():
assert elliptic_f(z, 0) == z
assert elliptic_f(0, m) == 0
assert elliptic_f(pi * i / 2, m) == i * elliptic_k(m)
assert elliptic_f(z, oo) == 0
assert elliptic_f(z, -oo) == 0
assert elliptic_f(-z, m) == -elliptic_f(z, m)
assert elliptic_f(z, m).diff(z) == 1 / sqrt(1 - m * sin(z)**2)
assert elliptic_f(z, m).diff(m) == elliptic_e(z, m)/(2*m*(1 - m)) - elliptic_f(z, m)/(2*m) - \
sin(2*z)/(4*(1 - m)*sqrt(1 - m*sin(z)**2))
r = randcplx()
assert td(elliptic_f(z, r), z)
assert td(elliptic_f(r, m), m)
pytest.raises(ArgumentIndexError, lambda: elliptic_f(z, m).fdiff(3))
mi = Symbol('m', extended_real=False)
assert elliptic_f(z, mi).conjugate() == elliptic_f(z.conjugate(),
mi.conjugate())
mr = Symbol('m', extended_real=True, negative=True)
assert elliptic_f(z, mr).conjugate() == elliptic_f(z.conjugate(), mr)
assert elliptic_f(z, m).conjugate() == conjugate(elliptic_f(z, m),
evaluate=False)
assert elliptic_f(z, m).series(z) == \
z + z**5*(3*m**2/40 - m/30) + m*z**3/6 + O(z**6)
def test_kronecker_delta():
i, j = symbols('i j')
k = Symbol('k', nonzero=True)
assert KroneckerDelta(1, 1) == 1
assert KroneckerDelta(1, 2) == 0
assert KroneckerDelta(k, 0) == 0
assert KroneckerDelta(x, x) == 1
assert KroneckerDelta(x**2 - y**2, x**2 - y**2) == 1
assert KroneckerDelta(i, i) == 1
assert KroneckerDelta(i, i + 1) == 0
assert KroneckerDelta(0, 0) == 1
assert KroneckerDelta(0, 1) == 0
assert KroneckerDelta(i + k, i) == 0
assert KroneckerDelta(i + k, i + k) == 1
assert KroneckerDelta(i + k, i + 1 + k) == 0
assert KroneckerDelta(i, j).subs({i: 1, j: 0}) == 0
assert KroneckerDelta(i, j).subs({i: 3, j: 3}) == 1
assert KroneckerDelta(i, j)**0 == 1
for n in range(1, 10):
assert KroneckerDelta(i, j)**n == KroneckerDelta(i, j)
assert KroneckerDelta(i, j)**-n == 1/KroneckerDelta(i, j)
assert KroneckerDelta(i, j).is_integer is True
assert adjoint(KroneckerDelta(i, j)) == KroneckerDelta(i, j)
assert conjugate(KroneckerDelta(i, j)) == KroneckerDelta(i, j)
assert transpose(KroneckerDelta(i, j)) == KroneckerDelta(i, j)
# to test if canonical
assert KroneckerDelta(i, j) == KroneckerDelta(j, i)
def test_kronecker_delta():
i, j = symbols('i j')
k = Symbol('k', nonzero=True)
assert KroneckerDelta(1, 1) == 1
assert KroneckerDelta(1, 2) == 0
assert KroneckerDelta(k, 0) == 0
assert KroneckerDelta(x, x) == 1
assert KroneckerDelta(x**2 - y**2, x**2 - y**2) == 1
assert KroneckerDelta(i, i) == 1
assert KroneckerDelta(i, i + 1) == 0
assert KroneckerDelta(0, 0) == 1
assert KroneckerDelta(0, 1) == 0
assert KroneckerDelta(i + k, i) == 0
assert KroneckerDelta(i + k, i + k) == 1
assert KroneckerDelta(i + k, i + 1 + k) == 0
assert KroneckerDelta(i, j).subs({i: 1, j: 0}) == 0
assert KroneckerDelta(i, j).subs({i: 3, j: 3}) == 1
assert KroneckerDelta(i, j)**0 == 1
for n in range(1, 10):
assert KroneckerDelta(i, j)**n == KroneckerDelta(i, j)
assert KroneckerDelta(i, j)**-n == 1 / KroneckerDelta(i, j)
assert KroneckerDelta(i, j).is_integer is True
assert adjoint(KroneckerDelta(i, j)) == KroneckerDelta(i, j)
assert conjugate(KroneckerDelta(i, j)) == KroneckerDelta(i, j)
assert transpose(KroneckerDelta(i, j)) == KroneckerDelta(i, j)
# to test if canonical
assert KroneckerDelta(i, j) == KroneckerDelta(j, i)
def test_li():
z = Symbol("z")
zr = Symbol("z", extended_real=True)
zp = Symbol("z", positive=True)
zn = Symbol("z", negative=True)
assert li(0) == 0
assert li(1) == -oo
assert li(oo) == oo
assert isinstance(li(z), li)
assert diff(li(z), z) == 1/log(z)
assert conjugate(li(z)) == li(conjugate(z))
assert conjugate(li(-zr)) == li(-zr)
assert conjugate(li(-zp)) == conjugate(li(-zp))
assert conjugate(li(zn)) == conjugate(li(zn))
assert li(z).rewrite(Li) == Li(z) + li(2)
assert li(z).rewrite(Ei) == Ei(log(z))
assert li(z).rewrite(uppergamma) == (-log(1/log(z))/2 - log(-log(z)) +
log(log(z))/2 - expint(1, -log(z)))
assert li(z).rewrite(Si) == (-log(I*log(z)) - log(1/log(z))/2 +
log(log(z))/2 + Ci(I*log(z)) + Shi(log(z)))
assert li(z).rewrite(Ci) == (-log(I*log(z)) - log(1/log(z))/2 +
log(log(z))/2 + Ci(I*log(z)) + Shi(log(z)))
assert li(z).rewrite(Shi) == (-log(1/log(z))/2 + log(log(z))/2 +
Chi(log(z)) - Shi(log(z)))
assert li(z).rewrite(Chi) == (-log(1/log(z))/2 + log(log(z))/2 +
Chi(log(z)) - Shi(log(z)))
assert li(z).rewrite(hyper) == (log(z)*hyper((1, 1), (2, 2), log(z)) -
log(1/log(z))/2 + log(log(z))/2 + EulerGamma)
assert li(z).rewrite(meijerg) == (-log(1/log(z))/2 - log(-log(z)) + log(log(z))/2 -
meijerg(((), (1,)), ((0, 0), ()), -log(z)))
def test_hermite():
assert hermite(0, x) == 1
assert hermite(1, x) == 2 * x
assert hermite(2, x) == 4 * x**2 - 2
assert hermite(3, x) == 8 * x**3 - 12 * x
assert hermite(4, x) == 16 * x**4 - 48 * x**2 + 12
assert hermite(6, x) == 64 * x**6 - 480 * x**4 + 720 * x**2 - 120
assert hermite(n, x) == hermite(n, x)
assert hermite(n, -x) == (-1)**n * hermite(n, x)
assert hermite(-n, x) == hermite(-n, x)
assert hermite(n, 0) == 2**n * sqrt(pi) / gamma((1 - n) / 2)
assert hermite(n, oo) == oo
assert conjugate(hermite(n, x)) == hermite(n, conjugate(x))
assert diff(hermite(n, x), x) == 2 * n * hermite(n - 1, x)
assert diff(hermite(n, x), n) == Derivative(hermite(n, x), n)
def test_adjoint():
assert adjoint(A).is_commutative is False
assert adjoint(A * A) == adjoint(A)**2
assert adjoint(A * B) == adjoint(B) * adjoint(A)
assert adjoint(A * B**2) == adjoint(B)**2 * adjoint(A)
assert adjoint(A * B -
B * A) == adjoint(B) * adjoint(A) - adjoint(A) * adjoint(B)
assert adjoint(A + I * B) == adjoint(A) - I * adjoint(B)
assert adjoint(X) == X
assert adjoint(-I * X) == I * X
assert adjoint(Y) == -Y
assert adjoint(-I * Y) == -I * Y
assert adjoint(X) == conjugate(transpose(X))
assert adjoint(Y) == conjugate(transpose(Y))
assert adjoint(X) == transpose(conjugate(X))
assert adjoint(Y) == transpose(conjugate(Y))
def test_assoc_legendre():
Plm = assoc_legendre
Q = sqrt(1 - x**2)
assert Plm(0, 0, x) == 1
assert Plm(1, 0, x) == x
assert Plm(1, 1, x) == -Q
assert Plm(2, 0, x) == (3*x**2 - 1)/2
assert Plm(2, 1, x) == -3*x*Q
assert Plm(2, 2, x) == 3*Q**2
assert Plm(3, 0, x) == (5*x**3 - 3*x)/2
assert Plm(3, 1, x).expand() == (( 3*(1 - 5*x**2)/2 ).expand() * Q).expand()
assert Plm(3, 2, x) == 15*x * Q**2
assert Plm(3, 3, x) == -15 * Q**3
# negative m
assert Plm(1, -1, x) == -Plm(1, 1, x)/2
assert Plm(2, -2, x) == Plm(2, 2, x)/24
assert Plm(2, -1, x) == -Plm(2, 1, x)/6
assert Plm(3, -3, x) == -Plm(3, 3, x)/720
assert Plm(3, -2, x) == Plm(3, 2, x)/120
assert Plm(3, -1, x) == -Plm(3, 1, x)/12
X = Plm(n, m, x)
assert isinstance(X, assoc_legendre)
assert Plm(n, 0, x) == legendre(n, x)
assert Plm(n, m, 0) == 2**m*sqrt(pi)/(gamma((1 - m - n)/2)*gamma(1 - (m - n)/2))
pytest.raises(ValueError, lambda: Plm(-1, 0, x))
pytest.raises(ValueError, lambda: Plm(0, 1, x))
pytest.raises(ValueError, lambda: Plm(-1, 2, x))
assert conjugate(assoc_legendre(n, m, x)) == \
assoc_legendre(n, conjugate(m), conjugate(x))
assert assoc_legendre(n, m, x).diff(x) == \
(n*x*assoc_legendre(n, m, x) -
(m + n)*assoc_legendre(n - 1, m, x))/(x**2 - 1)
pytest.raises(ArgumentIndexError, lambda: assoc_legendre(n, m, x).fdiff(1))
assert (str(assoc_laguerre(n, m, x).diff(m)) ==
'Sum(assoc_laguerre(_k, m, x)/(-m + n), (_k, 0, n - 1))')
def test_Ynm():
# http://en.wikipedia.org/wiki/Spherical_harmonics
th, ph = Symbol("theta", extended_real=True), Symbol("phi",
extended_real=True)
from diofant.abc import n, m
assert Ynm(0, 0, th, ph).expand(func=True) == 1 / (2 * sqrt(pi))
assert Ynm(1, -1, th, ph) == -exp(-2 * I * ph) * Ynm(1, 1, th, ph)
assert Ynm(1, -1, th, ph).expand(
func=True) == sqrt(6) * sin(th) * exp(-I * ph) / (4 * sqrt(pi))
assert Ynm(1, -1, th, ph).expand(
func=True) == sqrt(6) * sin(th) * exp(-I * ph) / (4 * sqrt(pi))
assert Ynm(1, 0, th,
ph).expand(func=True) == sqrt(3) * cos(th) / (2 * sqrt(pi))
assert Ynm(1, 1, th, ph).expand(
func=True) == -sqrt(6) * sin(th) * exp(I * ph) / (4 * sqrt(pi))
assert Ynm(2, 0, th, ph).expand(
func=True
) == 3 * sqrt(5) * cos(th)**2 / (4 * sqrt(pi)) - sqrt(5) / (4 * sqrt(pi))
assert Ynm(2, 1, th, ph).expand(func=True) == -sqrt(30) * sin(th) * exp(
I * ph) * cos(th) / (4 * sqrt(pi))
assert Ynm(
2, -2, th,
ph).expand(func=True) == (-sqrt(30) * exp(-2 * I * ph) * cos(th)**2 /
(8 * sqrt(pi)) +
sqrt(30) * exp(-2 * I * ph) / (8 * sqrt(pi)))
assert Ynm(
2, 2, th,
ph).expand(func=True) == (-sqrt(30) * exp(2 * I * ph) * cos(th)**2 /
(8 * sqrt(pi)) + sqrt(30) * exp(2 * I * ph) /
(8 * sqrt(pi)))
assert diff(Ynm(
n, m, th, ph), th) == (m * cot(th) * Ynm(n, m, th, ph) + sqrt(
(-m + n) * (m + n + 1)) * exp(-I * ph) * Ynm(n, m + 1, th, ph))
assert diff(Ynm(n, m, th, ph), ph) == I * m * Ynm(n, m, th, ph)
pytest.raises(ArgumentIndexError, lambda: Ynm(n, m, th, ph).fdiff(1))
assert conjugate(
Ynm(n, m, th,
ph)) == (-1)**(2 * m) * exp(-2 * I * m * ph) * Ynm(n, m, th, ph)
assert Ynm(n, m, -th, ph) == Ynm(n, m, th, ph)
assert Ynm(n, m, th, -ph) == exp(-2 * I * m * ph) * Ynm(n, m, th, ph)
assert Ynm(n, -m, th,
ph) == (-1)**m * exp(-2 * I * m * ph) * Ynm(n, m, th, ph)
assert (Ynm(n, m, th, ph).rewrite(sin) == Ynm(
n, m, th, ph).rewrite(cos) == exp(I * m * ph) * sqrt(
(2 * n + 1) * factorial(-m + n) / factorial(m + n)) *
assoc_legendre(n, m, cos(th)) / (2 * sqrt(pi)))
assert (Ynm(n, m, th, ph).as_real_imag() == (
sqrt((2 * n + 1) * factorial(-m + n) / factorial(m + n)) *
cos(m * ph) * assoc_legendre(n, m, cos(th)) / (2 * sqrt(pi)),
sqrt((2 * n + 1) * factorial(-m + n) / factorial(m + n)) *
sin(m * ph) * assoc_legendre(n, m, cos(th)) / (2 * sqrt(pi))))
def test_minimal_polynomial_conjugate():
e = sqrt(1 + sqrt(2 + I))
ec = conjugate(e)
for meth in ('compose', 'groebner'):
assert (minimal_polynomial(ec, method=meth)(x) == minimal_polynomial(
e, method=meth)(x) == x**8 - 4 * x**6 + 2 * x**4 + 4 * x**2 + 2)
assert (minimal_polynomial(
(e + ec) / 2, method=meth)(x) == 4096 * x**16 - 16384 * x**14 +
20480 * x**12 - 12288 * x**10 - 1152 * x**8 + 3328 * x**6 -
1600 * x**4 + 64 * x**2 + 1)
def test_piecewise_complex():
p1 = Piecewise((2, x < 0), (1, 0 <= x))
p2 = Piecewise((2*I, x < 0), (I, 0 <= x))
p3 = Piecewise((I*x, x > 1), (1 + I, True))
p4 = Piecewise((-I*conjugate(x), x > 1), (1 - I, True))
assert conjugate(p1) == p1
assert conjugate(p2) == piecewise_fold(-p2)
assert conjugate(p3) == p4
assert p1.is_imaginary is False
assert p1.is_extended_real is True
assert p2.is_imaginary is True
assert p2.is_extended_real is False
assert p3.is_imaginary is None
assert p3.is_extended_real is None
assert p1.as_real_imag() == (p1, 0)
assert p2.as_real_imag() == (0, -I*p2)
def test_piecewise_complex():
p1 = Piecewise((2, x < 0), (1, 0 <= x))
p2 = Piecewise((2 * I, x < 0), (I, 0 <= x))
p3 = Piecewise((I * x, x > 1), (1 + I, True))
p4 = Piecewise((-I * conjugate(x), x > 1), (1 - I, True))
assert conjugate(p1) == p1
assert conjugate(p2) == piecewise_fold(-p2)
assert conjugate(p3) == p4
assert p1.is_imaginary is False
assert p1.is_extended_real is True
assert p2.is_imaginary is True
assert p2.is_extended_real is False
assert p3.is_imaginary is None
assert p3.is_extended_real is None
assert p1.as_real_imag() == (p1, 0)
assert p2.as_real_imag() == (0, -I * p2)
def test_minimal_polynomial_conjugate():
e = sqrt(1 + sqrt(2 + I))
ec = conjugate(e)
for meth in ('compose', 'groebner'):
assert (minimal_polynomial(ec, method=meth)(x) ==
minimal_polynomial(e, method=meth)(x) ==
x**8 - 4*x**6 + 2*x**4 + 4*x**2 + 2)
assert (minimal_polynomial((e + ec)/2, method=meth)(x) ==
4096*x**16 - 16384*x**14 + 20480*x**12 - 12288*x**10 -
1152*x**8 + 3328*x**6 - 1600*x**4 + 64*x**2 + 1)
def test_hermite():
assert hermite(0, x) == 1
assert hermite(1, x) == 2*x
assert hermite(2, x) == 4*x**2 - 2
assert hermite(3, x) == 8*x**3 - 12*x
assert hermite(4, x) == 16*x**4 - 48*x**2 + 12
assert hermite(6, x) == 64*x**6 - 480*x**4 + 720*x**2 - 120
assert hermite(n, x) == hermite(n, x)
assert hermite(n, -x) == (-1)**n*hermite(n, x)
assert hermite(-n, x) == hermite(-n, x)
assert hermite(n, 0) == 2**n*sqrt(pi)/gamma((1 - n)/2)
assert hermite(n, oo) == oo
pytest.raises(ValueError, lambda: hermite(-1, x))
assert conjugate(hermite(n, x)) == hermite(n, conjugate(x))
assert diff(hermite(n, x), x) == 2*n*hermite(n - 1, x)
assert diff(hermite(n, x), n) == Derivative(hermite(n, x), n)
def test_adjoint():
assert adjoint(A).is_commutative is False
assert adjoint(A*A) == adjoint(A)**2
assert adjoint(A*B) == adjoint(B)*adjoint(A)
assert adjoint(A*B**2) == adjoint(B)**2*adjoint(A)
assert adjoint(A*B - B*A) == adjoint(B)*adjoint(A) - adjoint(A)*adjoint(B)
assert adjoint(A + I*B) == adjoint(A) - I*adjoint(B)
assert adjoint(X) == X
assert adjoint(-I*X) == I*X
assert adjoint(Y) == -Y
assert adjoint(-I*Y) == -I*Y
assert adjoint(X) == conjugate(transpose(X))
assert adjoint(Y) == conjugate(transpose(Y))
assert adjoint(X) == transpose(conjugate(X))
assert adjoint(Y) == transpose(conjugate(Y))
assert adjoint(2**x) == 2**adjoint(x)
assert adjoint(x**pi) == adjoint(x**pi, evaluate=False)
def test_gegenbauer():
assert gegenbauer(0, a, x) == 1
assert gegenbauer(1, a, x) == 2*a*x
assert gegenbauer(2, a, x) == -a + x**2*(2*a**2 + 2*a)
assert gegenbauer(3, a, x) == \
x**3*(4*a**3/3 + 4*a**2 + 8*a/3) + x*(-2*a**2 - 2*a)
assert gegenbauer(-1, a, x) == 0
assert gegenbauer(n, Rational(1, 2), x) == legendre(n, x)
assert gegenbauer(n, 1, x) == chebyshevu(n, x)
assert gegenbauer(n, -1, x) == 0
assert gegenbauer(n, -2, -1) == gegenbauer(n, -2, -1, evaluate=False)
X = gegenbauer(n, a, x)
assert isinstance(X, gegenbauer)
assert gegenbauer(n, a, -x) == (-1)**n*gegenbauer(n, a, x)
assert gegenbauer(n, a, 0) == 2**n*sqrt(pi) * \
gamma(a + n/2)/(gamma(a)*gamma(-n/2 + Rational(1, 2))*gamma(n + 1))
assert gegenbauer(n, a, 1) == gamma(2*a + n)/(gamma(2*a)*gamma(n + 1))
assert gegenbauer(n, Rational(3, 4), -1) == zoo
m = Symbol("m", positive=True)
assert gegenbauer(m, a, oo) == oo*RisingFactorial(a, m)
assert gegenbauer(n, a, oo) == gegenbauer(n, a, oo, evaluate=False)
assert conjugate(gegenbauer(n, a, x)) == gegenbauer(n, conjugate(a), conjugate(x))
assert diff(gegenbauer(n, a, x), n) == Derivative(gegenbauer(n, a, x), n)
assert diff(gegenbauer(n, a, x), x) == 2*a*gegenbauer(n - 1, a + 1, x)
pytest.raises(ArgumentIndexError, lambda: gegenbauer(n, a, x).fdiff(4))
# XXX see issue sympy/sympy#5539
assert str(gegenbauer(n, a, x).diff(a)) == \
("Sum((2*(-1)**(n - _k) + 2)*(a + _k)*gegenbauer(_k, a, x)/((n - "
"_k)*(2*a + n + _k)) + (2/(2*a + n + _k) + (2*_k + 2)/((2*a + "
"_k)*(2*a + 2*_k + 1)))*gegenbauer(n, a, x), (_k, 0, n - 1))")
def test_legendre():
pytest.raises(ValueError, lambda: legendre(-1, x))
assert legendre(0, x) == 1
assert legendre(1, x) == x
assert legendre(2, x) == ((3*x**2 - 1)/2).expand()
assert legendre(3, x) == ((5*x**3 - 3*x)/2).expand()
assert legendre(4, x) == ((35*x**4 - 30*x**2 + 3)/8).expand()
assert legendre(5, x) == ((63*x**5 - 70*x**3 + 15*x)/8).expand()
assert legendre(6, x) == ((231*x**6 - 315*x**4 + 105*x**2 - 5)/16).expand()
assert legendre(10, -1) == 1
assert legendre(11, -1) == -1
assert legendre(10, 1) == 1
assert legendre(11, 1) == 1
assert legendre(10, 0) != 0
assert legendre(11, 0) == 0
assert roots(legendre(4, x), x) == {
sqrt(Rational(3, 7) - Rational(2, 35)*sqrt(30)): 1,
-sqrt(Rational(3, 7) - Rational(2, 35)*sqrt(30)): 1,
sqrt(Rational(3, 7) + Rational(2, 35)*sqrt(30)): 1,
-sqrt(Rational(3, 7) + Rational(2, 35)*sqrt(30)): 1,
}
X = legendre(n, x)
assert isinstance(X, legendre)
assert legendre(-n, x) == legendre(n - 1, x)
assert legendre(n, -x) == (-1)**n*legendre(n, x)
assert legendre(n, 0) == sqrt(pi)/(gamma(Rational(1, 2) - n/2)*gamma(1 + n/2))
assert legendre(n, 1) == 1
assert legendre(n, oo) == oo
assert conjugate(legendre(n, x)) == legendre(n, conjugate(x))
assert diff(legendre(n, x), x) == \
n*(x*legendre(n, x) - legendre(n - 1, x))/(x**2 - 1)
assert diff(legendre(n, x), n) == Derivative(legendre(n, x), n)
def test_assoc_laguerre():
# generalized Laguerre polynomials:
assert assoc_laguerre(0, alpha, x) == 1
assert assoc_laguerre(1, alpha, x) == -x + alpha + 1
assert assoc_laguerre(2, alpha, x).expand() == \
(x**2/2 - (alpha + 2)*x + (alpha + 2)*(alpha + 1)/2).expand()
assert assoc_laguerre(3, alpha, x).expand() == \
(-x**3/6 + (alpha + 3)*x**2/2 - (alpha + 2)*(alpha + 3)*x/2 +
(alpha + 1)*(alpha + 2)*(alpha + 3)/6).expand()
# Test the lowest 10 polynomials with laguerre_poly, to make sure it works:
for i in range(10):
assert assoc_laguerre(i, 0, x).expand() == laguerre_poly(i, x)
X = assoc_laguerre(n, m, x)
assert isinstance(X, assoc_laguerre)
assert assoc_laguerre(n, 0, x) == laguerre(n, x)
assert assoc_laguerre(n, alpha, 0) == binomial(alpha + n, alpha)
p = Symbol('p', positive=True)
assert assoc_laguerre(p, alpha, oo) == (-1)**p*oo
assert assoc_laguerre(p, alpha, -oo) == oo
assert diff(assoc_laguerre(n, alpha, x), x) == \
-assoc_laguerre(n - 1, alpha + 1, x)
pytest.raises(ArgumentIndexError, lambda: assoc_laguerre(n, m, x).fdiff(1))
assert conjugate(assoc_laguerre(n, alpha, x)) == \
assoc_laguerre(n, conjugate(alpha), conjugate(x))
pytest.raises(ValueError, lambda: assoc_laguerre(-2.1, alpha, x))
# issue sympy/sympy#10961
X = assoc_laguerre(Rational(5, 2), alpha, x)
assert isinstance(X, assoc_laguerre)
def test_erf2():
assert erf2(0, 0) == 0
assert erf2(x, x) == 0
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, w).is_extended_real is False
assert erf2(2*w, w).is_extended_real is True
assert erf2(z, w).is_extended_real is None
assert erf2(w, z).is_extended_real is None
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))
pytest.raises(ArgumentIndexError, lambda: erfi(x).fdiff(3))
pytest.raises(ArgumentIndexError, lambda: erf2(x, y).fdiff(3))
assert erf2(x, y).diff(x) == -2*exp(-x**2)/sqrt(pi)
assert erf2(x, y).diff(y) == +2*exp(-y**2)/sqrt(pi)
def test_levicivita():
assert Eijk(1, 2, 3) == LeviCivita(1, 2, 3)
assert LeviCivita(1, 2, 3) == 1
assert LeviCivita(1, 3, 2) == -1
assert LeviCivita(1, 2, 2) == 0
i, j, k = symbols('i j k')
assert LeviCivita(i, j, k) == LeviCivita(i, j, k, evaluate=False)
assert LeviCivita(i, j, i) == 0
assert LeviCivita(1, i, i) == 0
assert LeviCivita(i, j, k).doit() == (j - i)*(k - i)*(k - j)/2
assert LeviCivita(1, 2, 3, 1) == 0
assert LeviCivita(4, 5, 1, 2, 3) == 1
assert LeviCivita(4, 5, 2, 1, 3) == -1
assert LeviCivita(i, j, k).is_integer is True
assert adjoint(LeviCivita(i, j, k)) == LeviCivita(i, j, k)
assert conjugate(LeviCivita(i, j, k)) == LeviCivita(i, j, k)
assert transpose(LeviCivita(i, j, k)) == LeviCivita(i, j, k)
def test_conjugate_transpose():
x = Symbol('x')
assert conjugate(transpose(x)) == adjoint(x)
assert transpose(conjugate(x)) == adjoint(x)
assert adjoint(transpose(x)) == conjugate(x)
assert transpose(adjoint(x)) == conjugate(x)
assert adjoint(conjugate(x)) == transpose(x)
assert conjugate(adjoint(x)) == transpose(x)
class Symmetric(Expr):
def _eval_adjoint(self):
return
def _eval_conjugate(self):
return
def _eval_transpose(self):
return self
x = Symmetric()
assert conjugate(x) == adjoint(x)
assert transpose(x) == x
def test_RootOf_conjugate():
p = x**7 + x + 1
assert RootOf(p, 0).conjugate() == RootOf(p, 0)
assert RootOf(p, 1).conjugate() == RootOf(p, 2)
assert RootOf(p, 2).conjugate() == RootOf(p, 1)
assert RootOf(p, 6).conjugate() == RootOf(p, 5)
p2 = p*(x - 123)
assert RootOf(p2, 0).conjugate() == RootOf(p2, 0)
assert RootOf(p2, 1).conjugate() == RootOf(p2, 1)
assert RootOf(p2, 2).conjugate() == RootOf(p2, 3)
assert RootOf(p2, 3).conjugate() == RootOf(p2, 2)
assert RootOf(p2, 7).conjugate() == RootOf(p2, 6)
p3 = Poly(x**7 + x*y + 1, x)
assert RootOf(p3, x, 0).conjugate() == conjugate(RootOf(p3, x, 0),
evaluate=False)
p4 = x**12 - 4*x**8 + 2*x**6 + 4*x**4 + 4*x**2 + 1
r4 = RootOf(p4, 4)
r5 = RootOf(p4, 5)
assert r4.conjugate() == r5
assert r4.evalf() == -r5.evalf()
def test_Ynm():
# https//en.wikipedia.org/wiki/Spherical_harmonics
th, ph = Symbol("theta", extended_real=True), Symbol("phi", extended_real=True)
assert Ynm(0, 0, th, ph).expand(func=True) == 1/(2*sqrt(pi))
assert Ynm(1, -1, th, ph) == -exp(-2*I*ph)*Ynm(1, 1, th, ph)
assert Ynm(1, -1, th, ph).expand(func=True) == sqrt(6)*sin(th)*exp(-I*ph)/(4*sqrt(pi))
assert Ynm(1, -1, th, ph).expand(func=True) == sqrt(6)*sin(th)*exp(-I*ph)/(4*sqrt(pi))
assert Ynm(1, 0, th, ph).expand(func=True) == sqrt(3)*cos(th)/(2*sqrt(pi))
assert Ynm(1, 1, th, ph).expand(func=True) == -sqrt(6)*sin(th)*exp(I*ph)/(4*sqrt(pi))
assert Ynm(2, 0, th, ph).expand(func=True) == 3*sqrt(5)*cos(th)**2/(4*sqrt(pi)) - sqrt(5)/(4*sqrt(pi))
assert Ynm(2, 1, th, ph).expand(func=True) == -sqrt(30)*sin(th)*exp(I*ph)*cos(th)/(4*sqrt(pi))
assert Ynm(2, -2, th, ph).expand(func=True) == (-sqrt(30)*exp(-2*I*ph)*cos(th)**2/(8*sqrt(pi))
+ sqrt(30)*exp(-2*I*ph)/(8*sqrt(pi)))
assert Ynm(2, 2, th, ph).expand(func=True) == (-sqrt(30)*exp(2*I*ph)*cos(th)**2/(8*sqrt(pi))
+ sqrt(30)*exp(2*I*ph)/(8*sqrt(pi)))
assert diff(Ynm(n, m, th, ph), th) == (m*cot(th)*Ynm(n, m, th, ph)
+ sqrt((-m + n)*(m + n + 1))*exp(-I*ph)*Ynm(n, m + 1, th, ph))
assert diff(Ynm(n, m, th, ph), ph) == I*m*Ynm(n, m, th, ph)
pytest.raises(ArgumentIndexError, lambda: Ynm(n, m, th, ph).fdiff(1))
assert conjugate(Ynm(n, m, th, ph)) == (-1)**(2*m)*exp(-2*I*m*ph)*Ynm(n, m, th, ph)
assert Ynm(n, m, -th, ph) == Ynm(n, m, th, ph)
assert Ynm(n, m, th, -ph) == exp(-2*I*m*ph)*Ynm(n, m, th, ph)
assert Ynm(n, -m, th, ph) == (-1)**m*exp(-2*I*m*ph)*Ynm(n, m, th, ph)
assert (Ynm(n, m, th, ph).rewrite(sin) ==
Ynm(n, m, th, ph).rewrite(cos) ==
exp(I*m*ph)*sqrt((2*n + 1)*factorial(-m + n)/factorial(m + n)) *
assoc_legendre(n, m, cos(th))/(2*sqrt(pi)))
assert (Ynm(n, m, th, ph).as_real_imag() ==
(sqrt((2*n + 1)*factorial(-m + n)/factorial(m + n))*cos(m*ph) *
assoc_legendre(n, m, cos(th))/(2*sqrt(pi)),
sqrt((2*n + 1)*factorial(-m + n)/factorial(m + n))*sin(m*ph) *
assoc_legendre(n, m, cos(th))/(2*sqrt(pi))))
def test_arg():
assert arg(0) == 0
assert arg(1) == 0
assert arg(-1) == pi
assert arg(I) == pi/2
assert arg(-I) == -pi/2
assert arg(1 + I) == pi/4
assert arg(-1 + I) == 3*pi/4
assert arg(1 - I) == -pi/4
f = Function('f')
assert not arg(f(0) + I*f(1)).atoms(re)
p = Symbol('p', positive=True)
assert arg(p) == 0
n = Symbol('n', negative=True)
assert arg(n) == pi
x = Symbol('x')
assert conjugate(arg(x)) == arg(x)
e = p + I*p**2
assert arg(e) == arg(1 + p*I)
# make sure sign doesn't swap
e = -2*p + 4*I*p**2
assert arg(e) == arg(-1 + 2*p*I)
# make sure sign isn't lost
x = symbols('x', extended_real=True) # could be zero
e = x + I*x
assert arg(e) == arg(x*(1 + I))
assert arg(e/p) == arg(x*(1 + I))
e = p*cos(p) + I*log(p)*exp(p)
assert arg(e).args[0] == e
# keep it simple -- let the user do more advanced cancellation
e = (p + 1) + I*(p**2 - 1)
assert arg(e).args[0] == e
def test_li():
z = Symbol("z")
zr = Symbol("z", extended_real=True)
zp = Symbol("z", positive=True)
zn = Symbol("z", negative=True)
assert li(0) == 0
assert li(1) == -oo
assert li(oo) == oo
assert isinstance(li(z), li)
assert diff(li(z), z) == 1/log(z)
pytest.raises(ArgumentIndexError, lambda: li(z).fdiff(2))
assert conjugate(li(z)) == li(conjugate(z))
assert conjugate(li(-zr)) == li(-zr)
assert conjugate(li(-zp)) == conjugate(li(-zp))
assert conjugate(li(zn)) == conjugate(li(zn))
assert li(z).rewrite(Li) == Li(z) + li(2)
assert li(z).rewrite(Ei) == Ei(log(z))
assert li(z).rewrite(uppergamma) == (-log(1/log(z))/2 - log(-log(z)) +
log(log(z))/2 - expint(1, -log(z)))
assert li(z).rewrite(Si) == (-log(I*log(z)) - log(1/log(z))/2 +
log(log(z))/2 + Ci(I*log(z)) + Shi(log(z)))
assert li(z).rewrite(Ci) == (-log(I*log(z)) - log(1/log(z))/2 +
log(log(z))/2 + Ci(I*log(z)) + Shi(log(z)))
assert li(z).rewrite(Shi) == (-log(1/log(z))/2 + log(log(z))/2 +
Chi(log(z)) - Shi(log(z)))
assert li(z).rewrite(Chi) == (-log(1/log(z))/2 + log(log(z))/2 +
Chi(log(z)) - Shi(log(z)))
assert li(z).rewrite(hyper) == (log(z)*hyper((1, 1), (2, 2), log(z)) -
log(1/log(z))/2 + log(log(z))/2 + EulerGamma)
assert li(z).rewrite(meijerg) == (-log(1/log(z))/2 - log(-log(z)) + log(log(z))/2 -
meijerg(((), (1,)), ((0, 0), ()), -log(z)))
def test_conjugate():
a = Symbol('a', extended_real=True)
b = Symbol('b', imaginary=True)
assert conjugate(a) == a
assert conjugate(I*a) == -I*a
assert conjugate(b) == -b
assert conjugate(I*b) == I*b
assert conjugate(a*b) == -a*b
assert conjugate(I*a*b) == I*a*b
assert conjugate(conjugate(x)) == x
assert conjugate(x + y) == conjugate(x) + conjugate(y)
assert conjugate(x - y) == conjugate(x) - conjugate(y)
assert conjugate(x * y) == conjugate(x) * conjugate(y)
assert conjugate(x / y) == conjugate(x) / conjugate(y)
assert conjugate(-x) == -conjugate(x)
a = Symbol('a', algebraic=True)
t = Symbol('t', transcendental=True)
assert re(a).is_algebraic
assert re(x).is_algebraic is None
assert re(t).is_algebraic is False
assert conjugate(z).diff(z) == Derivative(conjugate(z), z)
def test_sign():
assert sign(1.2) == 1
assert sign(-1.2) == -1
assert sign(3*I) == I
assert sign(-3*I) == -I
assert sign(0) == 0
assert sign(nan) == nan
assert sign(2 + 2*I).doit() == sqrt(2)*(2 + 2*I)/4
assert sign(2 + 3*I).simplify() == sign(2 + 3*I)
assert sign(2 + 2*I).simplify() == sign(1 + I)
assert sign(im(sqrt(1 - sqrt(3)))) == 1
assert sign(sqrt(1 - sqrt(3))) == I
x = Symbol('x')
assert sign(x).is_finite is True
assert sign(x).is_complex is True
assert sign(x).is_imaginary is None
assert sign(x).is_integer is None
assert sign(x).is_extended_real is None
assert sign(x).is_zero is None
assert sign(x).doit() == sign(x)
assert sign(1.2*x) == sign(x)
assert sign(2*x) == sign(x)
assert sign(I*x) == I*sign(x)
assert sign(-2*I*x) == -I*sign(x)
assert sign(conjugate(x)) == conjugate(sign(x))
p = Symbol('p', positive=True)
n = Symbol('n', negative=True)
m = Symbol('m', negative=True)
assert sign(2*p*x) == sign(x)
assert sign(n*x) == -sign(x)
assert sign(n*m*x) == sign(x)
x = Symbol('x', imaginary=True)
xn = Symbol('xn', imaginary=True, nonzero=True)
assert sign(x).is_imaginary is True
assert sign(x).is_integer is None
assert sign(x).is_extended_real is None
assert sign(x).is_zero is None
assert sign(x).diff(x) == 2*DiracDelta(-I*x)
assert sign(xn).doit() == xn / Abs(xn)
assert conjugate(sign(x)) == -sign(x)
x = Symbol('x', extended_real=True)
assert sign(x).is_imaginary is None
assert sign(x).is_integer is True
assert sign(x).is_extended_real is True
assert sign(x).is_zero is None
assert sign(x).diff(x) == 2*DiracDelta(x)
assert sign(x).doit() == sign(x)
assert conjugate(sign(x)) == sign(x)
assert sign(sin(x)).nseries(x) == 1
y = Symbol('y')
assert sign(x*y).nseries(x).removeO() == sign(y)
x = Symbol('x', nonzero=True)
assert sign(x).is_imaginary is None
assert sign(x).is_integer is None
assert sign(x).is_extended_real is None
assert sign(x).is_zero is False
assert sign(x).doit() == x / Abs(x)
assert sign(Abs(x)) == 1
assert Abs(sign(x)) == 1
x = Symbol('x', positive=True)
assert sign(x).is_imaginary is False
assert sign(x).is_integer is True
assert sign(x).is_extended_real is True
assert sign(x).is_zero is False
assert sign(x).doit() == x / Abs(x)
assert sign(Abs(x)) == 1
assert Abs(sign(x)) == 1
x = 0
assert sign(x).is_imaginary is True
assert sign(x).is_integer is True
assert sign(x).is_extended_real is True
assert sign(x).is_zero is True
assert sign(x).doit() == 0
assert sign(Abs(x)) == 0
assert Abs(sign(x)) == 0
nz = Symbol('nz', nonzero=True, integer=True)
assert sign(nz).is_imaginary is False
assert sign(nz).is_integer is True
assert sign(nz).is_extended_real is True
assert sign(nz).is_zero is False
assert sign(nz)**2 == 1
assert (sign(nz)**3).args == (sign(nz), 3)
assert sign(Symbol('x', nonnegative=True)).is_nonnegative
assert sign(Symbol('x', nonnegative=True)).is_nonpositive is None
assert sign(Symbol('x', nonpositive=True)).is_nonnegative is None
assert sign(Symbol('x', nonpositive=True)).is_nonpositive
assert sign(Symbol('x', extended_real=True)).is_nonnegative is None
assert sign(Symbol('x', extended_real=True)).is_nonpositive is None
assert sign(Symbol('x', extended_real=True, zero=False)).is_nonpositive is None
x, y = Symbol('x', extended_real=True), Symbol('y')
assert sign(x).rewrite(Piecewise) == \
Piecewise((1, x > 0), (-1, x < 0), (0, True))
assert sign(y).rewrite(Piecewise) == sign(y)
assert sign(x).rewrite(Heaviside) == 2*Heaviside(x)-1
assert sign(y).rewrite(Heaviside) == sign(y)
# evaluate what can be evaluated
assert sign(exp_polar(I*pi)*pi) is Integer(-1)
eq = -sqrt(10 + 6*sqrt(3)) + sqrt(1 + sqrt(3)) + sqrt(3 + 3*sqrt(3))
# if there is a fast way to know when and when you cannot prove an
# expression like this is zero then the equality to zero is ok
assert sign(eq) == 0
q = 1 + sqrt(2) - 2*sqrt(3) + 1331*sqrt(6)
p = cbrt(expand(q**3))
d = p - q
assert sign(d) == 0
assert abs(sign(z)) == Abs(sign(z), evaluate=False)
def test_im():
a, b = symbols('a,b', extended_real=True)
r = Symbol('r', extended_real=True)
i = Symbol('i', imaginary=True)
assert im(nan) == nan
assert im(oo*I) == oo
assert im(-oo*I) == -oo
assert im(0) == 0
assert im(1) == 0
assert im(-1) == 0
assert im(E*I) == E
assert im(-E*I) == -E
assert im(x) == im(x)
assert im(x*I) == re(x)
assert im(r*I) == r
assert im(r) == 0
assert im(i*I) == 0
assert im(i) == -I * i
assert im(x + y) == im(x + y)
assert im(x + r) == im(x)
assert im(x + r*I) == im(x) + r
assert im(im(x)*I) == im(x)
assert im(2 + I) == 1
assert im(x + I) == im(x) + 1
assert im(x + y*I) == im(x) + re(y)
assert im(x + r*I) == im(x) + r
assert im(log(2*I)) == pi/2
assert im((2 + I)**2).expand(complex=True) == 4
assert im(conjugate(x)) == -im(x)
assert conjugate(im(x)) == im(x)
assert im(x).as_real_imag() == (im(x), 0)
assert im(i*r*x).diff(r) == im(i*x)
assert im(i*r*x).diff(i) == -I * re(r*x)
assert im(sqrt(a + b*I)) == root(a**2 + b**2, 4)*sin(arg(a + I*b)/2)
assert im(a * (2 + b*I)) == a*b
assert im((1 + sqrt(a + b*I))/2) == root(a**2 + b**2, 4)*sin(arg(a + I*b)/2)/2
assert im(x).rewrite(re) == -I*(x - re(x)) # sympy/sympy#10897
assert (x + im(y)).rewrite(im, re) == x - I*(y - re(y))
a = Symbol('a', algebraic=True)
t = Symbol('t', transcendental=True)
assert re(a).is_algebraic
assert re(x).is_algebraic is None
assert re(t).is_algebraic is False
assert re(zoo) == nan
def test_Abs():
pytest.raises(TypeError, lambda: Abs(Interval(2, 3))) # issue sympy/sympy#8717
x, y = symbols('x,y')
assert sign(sign(x)) == sign(x)
assert isinstance(sign(x*y), sign)
assert Abs(0) == 0
assert Abs(1) == 1
assert Abs(-1) == 1
assert Abs(I) == 1
assert Abs(-I) == 1
assert Abs(nan) == nan
assert Abs(I * pi) == pi
assert Abs(-I * pi) == pi
assert Abs(I * x) == Abs(x)
assert Abs(-I * x) == Abs(x)
assert Abs(-2*x) == 2*Abs(x)
assert Abs(-2.0*x) == 2.0*Abs(x)
assert Abs(2*pi*x*y) == 2*pi*Abs(x*y)
assert Abs(conjugate(x)) == Abs(x)
assert conjugate(Abs(x)) == Abs(x)
a = cos(1)**2 + sin(1)**2 - 1
assert Abs(a*x).series(x).simplify() == 0
a = Symbol('a', positive=True)
assert Abs(2*pi*x*a) == 2*pi*a*Abs(x)
assert Abs(2*pi*I*x*a) == 2*pi*a*Abs(x)
x = Symbol('x', extended_real=True)
n = Symbol('n', integer=True)
assert Abs((-1)**n) == 1
assert x**(2*n) == Abs(x)**(2*n)
assert Abs(x).diff(x) == sign(x)
assert Abs(-x).fdiff() == sign(x)
assert abs(x) == Abs(x) # Python built-in
assert Abs(x)**3 == x**2*Abs(x)
assert Abs(x)**4 == x**4
assert (
Abs(x)**(3*n)).args == (Abs(x), 3*n) # leave symbolic odd unchanged
assert (1/Abs(x)).args == (Abs(x), -1)
assert 1/Abs(x)**3 == 1/(x**2*Abs(x))
assert Abs(x)**-3 == Abs(x)/(x**4)
assert Abs(x**3) == x**2*Abs(x)
assert Abs(x**pi) == Abs(x**pi, evaluate=False)
x = Symbol('x', imaginary=True)
assert Abs(x).diff(x) == -sign(x)
pytest.raises(ArgumentIndexError, lambda: Abs(z).fdiff(2))
eq = -sqrt(10 + 6*sqrt(3)) + sqrt(1 + sqrt(3)) + sqrt(3 + 3*sqrt(3))
# if there is a fast way to know when you can and when you cannot prove an
# expression like this is zero then the equality to zero is ok
assert abs(eq) == 0
q = 1 + sqrt(2) - 2*sqrt(3) + 1331*sqrt(6)
p = cbrt(expand(q**3))
d = p - q
assert abs(d) == 0
assert Abs(4*exp(pi*I/4)) == 4
assert Abs(3**(2 + I)) == 9
assert Abs((-3)**(1 - I)) == 3*exp(pi)
assert Abs(oo) is oo
assert Abs(-oo) is oo
assert Abs(oo + I) is oo
assert Abs(oo + I*oo) is oo
a = Symbol('a', algebraic=True)
t = Symbol('t', transcendental=True)
x = Symbol('x')
assert re(a).is_algebraic
assert re(x).is_algebraic is None
assert re(t).is_algebraic is False
assert abs(sign(z)) == Abs(sign(z), evaluate=False)
def test_re():
a, b = symbols('a,b', extended_real=True)
r = Symbol('r', extended_real=True)
i = Symbol('i', imaginary=True)
assert re(nan) == nan
assert re(oo) == oo
assert re(-oo) == -oo
assert re(0) == 0
assert re(1) == 1
assert re(-1) == -1
assert re(E) == E
assert re(-E) == -E
assert re(x) == re(x)
assert re(x*I) == -im(x)
assert re(r*I) == 0
assert re(r) == r
assert re(i*I) == I * i
assert re(i) == 0
assert re(x + y) == re(x + y)
assert re(x + r) == re(x) + r
assert re(re(x)) == re(x)
assert re(2 + I) == 2
assert re(x + I) == re(x)
assert re(x + y*I) == re(x) - im(y)
assert re(x + r*I) == re(x)
assert re(log(2*I)) == log(2)
assert re((2 + I)**2).expand(complex=True) == 3
assert re(conjugate(x)) == re(x)
assert conjugate(re(x)) == re(x)
assert re(x).as_real_imag() == (re(x), 0)
assert re(i*r*x).diff(r) == re(i*x)
assert re(i*r*x).diff(i) == I*r*im(x)
assert re(sqrt(a + b*I)) == root(a**2 + b**2, 4)*cos(arg(a + I*b)/2)
assert re(a * (2 + b*I)) == 2*a
assert re((1 + sqrt(a + b*I))/2) == root(a**2 + b**2, 4)*cos(arg(a + I*b)/2)/2 + Rational(1, 2)
assert re(x).rewrite(im) == x - I*im(x) # issue sympy/sympy#10897
assert (x + re(y)).rewrite(re, im) == x + y - I*im(y)
a = Symbol('a', algebraic=True)
t = Symbol('t', transcendental=True)
assert re(a).is_algebraic
assert re(x).is_algebraic is None
assert re(t).is_algebraic is False
assert re(zoo) == nan
