def test_real_imag():
x, y, z = symbols('x, y, z')
X, Y, Z = symbols('X, Y, Z', commutative=False)
a = Symbol('a', extended_real=True)
assert (2*a*x).as_real_imag() == (2*a*re(x), 2*a*im(x))
# issue sympy/sympy#5395:
assert (x*x.conjugate()).as_real_imag() == (Abs(x)**2, 0)
assert im(x*x.conjugate()) == 0
assert im(x*y.conjugate()*z*y) == im(x*z)*Abs(y)**2
assert im(x*y.conjugate()*x*y) == im(x**2)*Abs(y)**2
assert im(Z*y.conjugate()*X*y) == im(Z*X)*Abs(y)**2
assert im(X*X.conjugate()) == im(X*X.conjugate(), evaluate=False)
assert (sin(x)*sin(x).conjugate()).as_real_imag() == \
(Abs(sin(x))**2, 0)
# issue sympy/sympy#6573:
assert (x**2).as_real_imag() == (re(x)**2 - im(x)**2, 2*re(x)*im(x))
# issue sympy/sympy#6428:
r = Symbol('r', extended_real=True)
i = Symbol('i', imaginary=True)
assert (i*r*x).as_real_imag() == (I*i*r*im(x), -I*i*r*re(x))
assert (i*r*x*(y + 2)).as_real_imag() == (
I*i*r*(re(y) + 2)*im(x) + I*i*r*re(x)*im(y),
-I*i*r*(re(y) + 2)*re(x) + I*i*r*im(x)*im(y))
# issue sympy/sympy#7106:
assert ((1 + I)/(1 - I)).as_real_imag() == (0, 1)
assert ((1 + 2*I)*(1 + 3*I)).as_real_imag() == (-5, 5)
assert exp(x).as_real_imag(deep=False) == (re(exp(x)), im(exp(x)))
assert (2**x).as_real_imag(deep=False) == (re(2**x), im(2**x))
def test_adjoint():
a = Symbol('a', antihermitian=True)
b = Symbol('b', hermitian=True)
assert adjoint(a) == -a
assert adjoint(I*a) == I*a
assert adjoint(b) == b
assert adjoint(I*b) == -I*b
assert adjoint(a*b) == -b*a
assert adjoint(I*a*b) == I*b*a
x, y = symbols('x y')
assert adjoint(adjoint(x)) == x
assert adjoint(x + y) == adjoint(x) + adjoint(y)
assert adjoint(x - y) == adjoint(x) - adjoint(y)
assert adjoint(x * y) == adjoint(x) * adjoint(y)
assert adjoint(x / y) == adjoint(x) / adjoint(y)
assert adjoint(-x) == -adjoint(x)
x, y = symbols('x y', commutative=False)
assert adjoint(adjoint(x)) == x
assert adjoint(x + y) == adjoint(x) + adjoint(y)
assert adjoint(x - y) == adjoint(x) - adjoint(y)
assert adjoint(x * y) == adjoint(y) * adjoint(x)
assert adjoint(x / y) == 1 / adjoint(y) * adjoint(x)
assert adjoint(-x) == -adjoint(x)
def add_np(doctest_namespace):
for sym in (diofant.symbols('a b c d x y z t') +
diofant.symbols('k m n', integer=True) +
diofant.symbols('f g h', cls=diofant.Function)):
doctest_namespace[str(sym)] = sym
for name in dir(diofant):
doctest_namespace[name] = getattr(diofant, name)
def test_mul_noncommutative():
A, B = symbols('A B', commutative=False)
u, v = symbols('u v', cls=Wild)
w, z = symbols('u v', cls=Wild, commutative=False)
assert x.match(u*v) in ({v: x, u: 1}, {u: x, v: 1})
assert (x*y).match(u*v) in ({v: y, u: x}, {u: y, v: x})
assert A.match(u*v) is None
assert (A*B).match(u*v) is None
assert (x*A).match(u*v) is None
assert (x*y*A).match(u*v) is None
assert (x*A*B).match(u*v) is None
assert (x*y*A*B).match(u*v) is None
assert x.match(v*w) is None
assert (x*y).match(v*w) is None
assert A.match(v*w) == {w: A, v: 1}
assert (A*B).match(v*w) == {w: A*B, v: 1}
assert (x*A).match(v*w) == {w: A, v: x}
assert (x*y*A).match(v*w) == {w: A, v: x*y}
assert (x*A*B).match(v*w) == {w: A*B, v: x}
assert (x*y*A*B).match(v*w) == {w: A*B, v: x*y}
assert (-x).match(v*w) is None
assert (-x*y).match(v*w) is None
assert (-A).match(v*w) == {w: A, v: -1}
assert (-A*B).match(v*w) == {w: A*B, v: -1}
assert (-x*A).match(v*w) == {w: A, v: -x}
assert (-x*y*A).match(v*w) == {w: A, v: -x*y}
assert (-x*A*B).match(v*w) == {w: A*B, v: -x}
assert (-x*y*A*B).match(v*w) == {w: A*B, v: -x*y}
assert (x*y*A).match(u*v*w) == {u: x, v: y, w: A}
assert (x*A).match(w*z) is None
def test_log_assumptions():
p = symbols('p', positive=True)
n = symbols('n', negative=True)
z = symbols('z', zero=True)
nz = symbols('nz', nonzero=True, finite=True)
x = symbols('x', infinite=True, positive=True)
assert log(z).is_positive is False
assert log(x).is_positive is True
assert log(2) > 0
assert log(1, evaluate=False).is_zero
assert log(1 + z).is_zero
assert log(1 + z).is_rational
assert log(1 + z).is_algebraic
assert log(1 + p).is_algebraic is None
assert log(p).is_zero is None
assert log(n).is_zero is False
assert log(0.5).is_negative is True
assert log(exp(p) + 1).is_positive
assert log(z).is_finite is False
assert log(p).is_finite is None
assert log(nz).is_finite
assert log(z).is_complex is False
assert log(1, evaluate=False).is_algebraic
assert log(42, evaluate=False).is_algebraic is False
assert log(1 + z).is_rational
def test_diop_general_sum_of_squares_quick():
for i in range(3, 10):
assert check_solutions(sum(i**2 for i in symbols(':%i' % i)) - i)
pytest.raises(ValueError, lambda: _diop_general_sum_of_squares((x, y), 2))
assert _diop_general_sum_of_squares((x, y, z), -2) == set()
eq = x**2 + y**2 + z**2 - (1 + 4 + 9)
assert diop_general_sum_of_squares(eq) == {(1, 2, 3)}
eq = u**2 + v**2 + x**2 + y**2 + z**2 - 1313
assert len(diop_general_sum_of_squares(eq, 3)) == 3
# issue sympy/sympy#11016
var = symbols(':5') + (symbols('6', negative=True),)
eq = Add(*[i**2 for i in var]) - 112
assert diophantine(eq) == {
(0, 1, 1, 5, 6, -7), (1, 1, 1, 3, 6, -8), (2, 3, 3, 4, 5, -7),
(0, 1, 1, 1, 3, -10), (0, 0, 4, 4, 4, -8), (1, 2, 3, 3, 5, -8),
(0, 1, 2, 3, 7, -7), (2, 2, 4, 4, 6, -6), (1, 1, 3, 4, 6, -7),
(0, 2, 3, 3, 3, -9), (0, 0, 2, 2, 2, -10), (1, 1, 2, 3, 4, -9),
(0, 1, 1, 2, 5, -9), (0, 0, 2, 6, 6, -6), (1, 3, 4, 5, 5, -6),
(0, 2, 2, 2, 6, -8), (0, 3, 3, 3, 6, -7), (0, 2, 3, 5, 5, -7),
(0, 1, 5, 5, 5, -6)}
# handle negated squares with signsimp
assert diophantine(12 - x**2 - y**2 - z**2) == {(2, 2, 2)}
# diophantine handles simplification, so classify_diop should
# not have to look for additional patterns that are removed
# by diophantine
eq = a**2 + b**2 + c**2 + d**2 - 4
pytest.raises(NotImplementedError, lambda: classify_diop(-eq))
def test_take():
X = numbered_symbols()
assert take(X, 5) == list(symbols('x0:5'))
assert take(X, 5) == list(symbols('x5:10'))
assert take([1, 2, 3, 4, 5], 5) == [1, 2, 3, 4, 5]
def test_findrecur():
pytest.raises(ValueError, lambda: Sum(x*y, (x, 0, 2),
(y, 0, 2)).findrecur())
pytest.raises(ValueError, lambda: Sum(x*y, (x, 0, 2)).findrecur())
pytest.raises(ValueError, lambda: Sum(x, (x, 0, oo)).findrecur())
pytest.raises(ValueError, lambda: Sum(sin(x*y)/(x**2 + 1),
(x, 0, oo)).findrecur())
n, k = symbols("n, k", integer=True)
F = symbols("F", cls=Function)
f = Sum(factorial(n)/(factorial(k)*factorial(n - k)), (k, 0, oo))
g = Sum(k*factorial(n)/(factorial(k)*factorial(n - k)), (k, 0, oo))
fa = Sum((-1)**k*binomial(n, k)*binomial(2*n - 2*k, n + a), (k, 0, oo))
fb = Sum(binomial(x, k)*binomial(y, n - k), (k, 0, oo))
assert f.findrecur(F) == -F(n, k) + F(n - 1, k) + F(n - 1, k - 1)
assert (Sum(binomial(n, k), (k, 0, oo)).findrecur(F) ==
-F(n, k) + F(n - 1, k) + F(n - 1, k - 1))
assert (g.findrecur(F) == (-1 + 1/n)*F(n, k) + F(n - 1, k) +
F(n - 1, k - 1))
assert (fa.findrecur(F, n) == F(n - 2, k - 1) -
(2*n - 1)*F(n - 1, k)/(2*n - 2) -
(a**2 - n**2)*F(n, k)/(4*n*(n - 1)))
assert (fb.findrecur(F, n) == -n*F(n, k)/(-n + x + y + 2) +
(-n + x + 1)*F(n - 1, k - 1)/(-n + x + y + 2) +
(-n + y + 1)*F(n - 1, k)/(-n + x + y + 2) + F(n - 2, k - 1))
def test_non_commutative_order():
A, B, C = symbols('A B C', commutative=False)
x0 = symbols('x0', commutative=False)
l = [B+C, A*(B+C)]
assert cse(l) == ([(x0, B+C)], [x0, A*x0])
l = [(A - B)**2 + A - B]
assert cse(l) == ([(x0, A - B)], [x0**2 + x0])
def test_factor_nc():
x, y = symbols('x,y')
k = symbols('k', integer=True)
n, m, o = symbols('n,m,o', commutative=False)
# mul and multinomial expansion is needed
e = x*(1 + y)**2
assert _mexpand(e) == x + x*2*y + x*y**2
def factor_nc_test(e):
ex = _mexpand(e)
assert ex.is_Add
f = factor_nc(ex)
assert not f.is_Add and _mexpand(f) == ex
factor_nc_test(x*(1 + y))
factor_nc_test(n*(x + 1))
factor_nc_test(n*(x + m))
factor_nc_test((x + m)*n)
factor_nc_test(n*m*(x*o + n*o*m)*n)
s = Sum(x, (x, 1, 2))
factor_nc_test(x*(1 + s))
factor_nc_test(x*(1 + s)*s)
factor_nc_test(x*(1 + sin(s)))
factor_nc_test((1 + n)**2)
factor_nc_test((x + n)*(x + m)*(x + y))
factor_nc_test(x*(n*m + 1))
factor_nc_test(x*(n*m + x))
factor_nc_test(x*(x*n*m + 1))
factor_nc_test(x*n*(x*m + 1))
factor_nc_test(x*(m*n + x*n*m))
factor_nc_test(n*(1 - m)*n**2)
factor_nc_test((n + m)**2)
factor_nc_test((n - m)*(n + m)**2)
factor_nc_test((n + m)**2*(n - m))
factor_nc_test((m - n)*(n + m)**2*(n - m))
assert factor_nc(n*(n + n*m)) == n**2*(1 + m)
assert factor_nc(m*(m*n + n*m*n**2)) == m*(m + n*m*n)*n
eq = m*sin(n) - sin(n)*m
assert factor_nc(eq) == eq
eq = (sin(n) + x)*(cos(n) + x)
assert factor_nc(eq.expand()) == eq
# issue sympy/sympy#6534
assert (2*n + 2*m).factor() == 2*(n + m)
# issue sympy/sympy#6701
assert factor_nc(n**k + n**(k + 1)) == n**k*(1 + n)
assert factor_nc((m*n)**k + (m*n)**(k + 1)) == (1 + m*n)*(m*n)**k
# issue sympy/sympy#6918
assert factor_nc(-n*(2*x**2 + 2*x)) == -2*n*x*(x + 1)
assert factor_nc(1 + Mul(Expr(), Expr(), evaluate=False)) == 1 + Expr()**2
def test_powsimp_negated_base():
assert powsimp((-x + y)/sqrt(x - y)) == -sqrt(x - y)
assert powsimp((-x + y)*(-z + y)/sqrt(x - y)/sqrt(z - y)) == sqrt(x - y)*sqrt(z - y)
p = symbols('p', positive=True)
assert powsimp((-p)**a/p**a) == (-1)**a
n = symbols('n', negative=True)
assert powsimp((-n)**a/n**a) == (-1)**a
# if x is 0 then the lhs is 0**a*oo**a which is not (-1)**a
assert powsimp((-x)**a/x**a) != (-1)**a
def test_log_product():
i, j = symbols('i,j', positive=True, integer=True)
x, y = symbols('x,y', positive=True)
assert simplify(log(Product(x**i, (i, 1, n)))) == Sum(i*log(x), (i, 1, n))
assert simplify(log(Product(x**i*y**j, (i, 1, n), (j, 1, m)))) == \
log(Product(x**i*y**j, (i, 1, n), (j, 1, m)))
expr = log(Product(-2, (n, 0, 4)))
assert simplify(expr) == expr
def test_sympyissue_4418():
a, b, c = symbols('a b c', cls=Wild, exclude=(x,))
f, g = symbols('f g', cls=Function)
eq = diff(g(x)*f(x).diff(x), x)
assert eq.match(
g(x).diff(x)*f(x).diff(x) + g(x)*f(x).diff(x, x) + c) == {c: 0}
assert eq.match(a*g(x).diff(
x)*f(x).diff(x) + b*g(x)*f(x).diff(x, x) + c) == {a: 1, b: 1, c: 0}
def test_sympyissue_2787():
n, k = symbols('n k', positive=True, integer=True)
p = symbols('p', positive=True)
binomial_dist = binomial(n, k)*p**k*(1 - p)**(n - k)
s = Sum(binomial_dist*k, (k, 0, n))
res = s.doit().simplify()
assert res == Piecewise(
(n*p, And(Or(-n + 1 < 0, Ne(p/(p - 1), 1)), p/Abs(p - 1) <= 1)),
(Sum(k*p**k*(-p + 1)**(-k)*(-p + 1)**n*binomial(n, k), (k, 0, n)),
True))
def test_kronecker_delta_secondquant():
"""secondquant-specific methods"""
D = KroneckerDelta
i, j, v, w = symbols('i j v w', below_fermi=True, cls=Dummy)
a, b, t, u = symbols('a b t u', above_fermi=True, cls=Dummy)
p, q, r, s = symbols('p q r s', cls=Dummy)
assert D(i, a) == 0
assert D(i, t) == 0
assert D(u, w) == 0
assert D(i, j).is_above_fermi is False
assert D(a, b).is_above_fermi is True
assert D(p, q).is_above_fermi is True
assert D(i, q).is_above_fermi is False
assert D(q, i).is_above_fermi is False
assert D(q, v).is_above_fermi is False
assert D(a, q).is_above_fermi is True
assert D(i, j).is_below_fermi is True
assert D(a, b).is_below_fermi is False
assert D(p, q).is_below_fermi is True
assert D(p, j).is_below_fermi is True
assert D(q, b).is_below_fermi is False
assert D(i, j).is_only_above_fermi is False
assert D(a, b).is_only_above_fermi is True
assert D(p, q).is_only_above_fermi is False
assert D(i, q).is_only_above_fermi is False
assert D(q, i).is_only_above_fermi is False
assert D(a, q).is_only_above_fermi is True
assert D(i, j).is_only_below_fermi is True
assert D(a, b).is_only_below_fermi is False
assert D(p, q).is_only_below_fermi is False
assert D(p, j).is_only_below_fermi is True
assert D(q, b).is_only_below_fermi is False
assert not D(i, q).indices_contain_equal_information
assert not D(a, q).indices_contain_equal_information
assert D(p, q).indices_contain_equal_information
assert D(a, b).indices_contain_equal_information
assert D(i, j).indices_contain_equal_information
assert D(q, b).preferred_index == b
assert D(q, b).killable_index == q
assert D(q, t).preferred_index == t
assert D(q, t).killable_index == q
assert D(q, i).preferred_index == i
assert D(q, i).killable_index == q
assert D(q, v).preferred_index == v
assert D(q, v).killable_index == q
assert D(q, p).preferred_index == p
assert D(q, p).killable_index == q
def test_sympyissue_8514():
a, b, c, = symbols('a b c', positive=True, finite=True)
t = symbols('t', positive=True)
ft = simplify(inverse_laplace_transform(1/(a*s**2 + b*s + c), s, t))
assert ft.rewrite(atan2) == ((exp(t*(exp(I*atan2(0, -4*a*c + b**2)/2) -
exp(-I*atan2(0, -4*a*c + b**2)/2)) *
sqrt(Abs(4*a*c - b**2))/(4*a))*exp(t*cos(atan2(0, -4*a*c + b**2)/2)
* sqrt(Abs(4*a*c - b**2))/a) + I*sin(t*sin(atan2(0, -4*a*c + b**2)/2)
* sqrt(Abs(4*a*c - b**2))/(2*a)) - cos(t*sin(atan2(0, -4*a*c + b**2)/2)
* sqrt(Abs(4*a*c - b**2))/(2*a)))*exp(-t*(b + cos(atan2(0, -4*a*c + b**2)/2)
* sqrt(Abs(4*a*c - b**2)))/(2*a))/sqrt(-4*a*c + b**2))
def test_binomial_symbolic():
n = 10 # Because we're using for loops, can't do symbolic n
p = symbols('p', positive=True)
X = Binomial('X', n, p)
assert simplify(E(X)) == n*p == simplify(moment(X, 1))
assert simplify(variance(X)) == n*p*(1 - p) == simplify(cmoment(X, 2))
assert cancel((skewness(X) - (1-2*p)/sqrt(n*p*(1-p)))) == 0
# Test ability to change success/failure winnings
H, T = symbols('H T')
Y = Binomial('Y', n, p, succ=H, fail=T)
assert simplify(E(Y) - (n*(H*p + T*(1 - p)))) == 0
def test_subs_mixed():
a, b, c, d, K = symbols('a b c d K', commutative=True)
w, x, y, z, L = symbols('w x y z L', commutative=False)
R, S, T, U = symbols('R S T U', cls=Wild)
assert (a*x*y).subs({x*y: L}) == a*L
assert (a*b*x*y*x).subs({x*y: L}) == a*b*L*x
assert (R*x*y*exp(x*y)).subs({x*y: L}) == R*L*exp(L)
assert (a*x*y*y*x - x*y*z*exp(a*b)).subs({x*y: L}) == a*L*y*x - L*z*exp(a*b)
e = c*y*x*y*x**(R*S - a*b) - T*(a*R*b*S)
assert e.subs({x*y: L}).subs({a*b: K}).subs({R*S: U}) == \
c*y*L*x**(U - K) - T*(U*K)
def test_sympyissue_3940():
a, b, c, d = symbols('a:d', positive=True, finite=True)
assert integrate(exp(-x**2 + I*c*x), x) == \
-sqrt(pi)*exp(-c**2/4)*erf(I*c/2 - x)/2
assert integrate(exp(a*x**2 + b*x + c), x) == \
sqrt(pi)*exp(c)*exp(-b**2/(4*a))*erfi(sqrt(a)*x + b/(2*sqrt(a)))/(2*sqrt(a))
assert expand_mul(integrate(exp(-x**2)*exp(I*k*x), (x, -oo, oo))) == \
sqrt(pi)*exp(-k**2/4)
a, d = symbols('a d', positive=True)
assert expand_mul(integrate(exp(-a*x**2 + 2*d*x), (x, -oo, oo))) == \
sqrt(pi)*exp(d**2/a)/sqrt(a)
def test_fcode_complex():
assert fcode(I) == " cmplx(0,1)"
x = symbols('x')
assert fcode(4*I) == " cmplx(0,4)"
assert fcode(3 + 4*I) == " cmplx(3,4)"
assert fcode(3 + 4*I + x) == " cmplx(3,4) + x"
assert fcode(I*x) == " cmplx(0,1)*x"
assert fcode(3 + 4*I - x) == " cmplx(3,4) - x"
x = symbols('x', imaginary=True)
assert fcode(5*x) == " 5*x"
assert fcode(I*x) == " cmplx(0,1)*x"
assert fcode(3 + x) == " x + 3"
def test_assumptions():
"""
Test whether diophantine respects the assumptions.
"""
# Test case taken from the below so question regarding assumptions in diophantine module
# https//stackoverflow.com/questions/23301941/how-can-i-declare-natural-symbols-with-sympy
m, n = symbols('m n', integer=True, positive=True)
diof = diophantine(n ** 2 + m * n - 500)
assert diof == {(5, 20), (40, 10), (95, 5), (121, 4), (248, 2), (499, 1)}
a, b = symbols('a b', integer=True, positive=False)
diof = diophantine(a*b + 2*a + 3*b - 6)
assert diof == {(-15, -3), (-9, -4), (-7, -5), (-6, -6), (-5, -8), (-4, -14)}
def test_subs_constants():
a, b = symbols('a b', commutative=True)
x, y = symbols('x y', commutative=False)
assert (a*b).subs({2*a: 1}) == a*b
assert (1.5*a*b).subs({a: 1}) == 1.5*b
assert (2*a*b).subs({2*a: 1}) == b
assert (2*a*b).subs({4*a: 1}) == 2*a*b
assert (x*y).subs({2*x: 1}) == x*y
assert (1.5*x*y).subs({x: 1}) == 1.5*y
assert (2*x*y).subs({2*x: 1}) == y
assert (2*x*y).subs({4*x: 1}) == 2*x*y
def test_input_value_assertions():
a, b = symbols('a b')
p, q = symbols('p q', positive=True)
pytest.raises(ValueError, lambda: Normal('x', 3, 0))
pytest.raises(ValueError, lambda: Normal('x', a, b))
Normal('X', a, p) # No error raised
pytest.raises(ValueError, lambda: Exponential('x', a))
Exponential('Ex', p) # No error raised
for fn in [Pareto, Weibull, Beta, Gamma]:
pytest.raises(ValueError, lambda: fn('x', a, p))
pytest.raises(ValueError, lambda: fn('x', p, a))
fn('x', p, q) # No error raised
def test_exp_subs():
x = Symbol('x')
e = (exp(3*log(x), evaluate=False)) # evaluates to x**3
assert e.subs({x**3: y**3}) == e
assert e.subs({x**2: 5}) == e
assert (x**3).subs({x**2: y}) != y**Rational(3, 2)
assert exp(exp(x) + exp(x**2)).subs({exp(exp(x)): y}) == y * exp(exp(x**2))
assert exp(x).subs({E: y}) == y**x
x = symbols('x', extended_real=True)
assert exp(5*x).subs({exp(7*x): y}) == y**Rational(5, 7)
assert exp(2*x + 7).subs({exp(3*x): y}) == y**Rational(2, 3) * exp(7)
x = symbols('x', positive=True)
assert exp(3*log(x)).subs({x**2: y}) == y**Rational(3, 2)
def test_piecewise_integrate_inequality_conditions():
x, y = symbols("x y", real=True)
c1, c2 = symbols("c1 c2", positive=True, real=True)
g = Piecewise((0, c1*x > 1), (1, c1*x > 0), (0, True))
assert integrate(g, (x, -oo, 0)) == 0
assert integrate(g, (x, -5, 0)) == 0
assert integrate(g, (x, 0, 5)) == Min(5, 1/c1)
assert integrate(g, (x, 0, oo)) == 1/c1
g = Piecewise((0, c1*x + c2*y > 1), (1, c1*x + c2*y > 0), (0, True))
assert integrate(g, (x, -oo, 0)).subs({y: 0}) == 0
assert integrate(g, (x, -5, 0)).subs({y: 0}) == 0
assert integrate(g, (x, 0, 5)).subs({y: 0}) == Min(5, 1/c1)
assert integrate(g, (x, 0, oo)).subs({y: 0}) == 1/c1
def test_sympyissue_12769():
r, z, x = symbols('r,z,x', real=True)
a, b, s0, K, F0, s, T = symbols('a,b,s0,K,F0,s,T',
positive=True, real=True)
fx = (F0**b*K**b*r*s0 -
sqrt((F0**2*K**(2*b)*a**2*(b - 1) +
F0**(2*b)*K**2*a**2*(b - 1) +
F0**(2*b)*K**(2*b)*s0**2*(b - 1)*(b**2 - 2*b + 1) -
2*F0**(2*b)*K**(b + 1)*a*r*s0*(b**2 - 2*b + 1) +
2*F0**(b + 1)*K**(2*b)*a*r*s0*(b**2 - 2*b + 1) -
2*F0**(b + 1)*K**(b + 1)*a**2*(b - 1))/((b - 1)*(b**2 - 2*b + 1))))*(b*r - b - r + 1)
assert limit(fx, K, F0) == (F0**(2*b)*b*r**2*s0 - 2*F0**(2*b)*b*r*s0 +
F0**(2*b)*b*s0 - F0**(2*b)*r**2*s0 +
2*F0**(2*b)*r*s0 - F0**(2*b)*s0)
def test_subs_simple():
a = symbols('a', commutative=True)
x = symbols('x', commutative=False)
assert (2*a).subs({1: 3}) == 2*a
assert (2*a).subs({2: 3}) == 3*a
assert (2*a).subs({a: 3}) == 6
assert sin(2).subs({1: 3}) == sin(2)
assert sin(2).subs({2: 3}) == sin(3)
assert sin(a).subs({a: 3}) == sin(3)
assert (2*x).subs({1: 3}) == 2*x
assert (2*x).subs({2: 3}) == 3*x
assert (2*x).subs({x: 3}) == 6
assert sin(x).subs({x: 3}) == sin(3)
def test_subs_basic_funcs():
a, b, c, d, K = symbols('a b c d K', commutative=True)
w, x, y, z, L = symbols('w x y z L', commutative=False)
assert (x + y).subs({x + y: L}) == L
assert (x - y).subs({x - y: L}) == L
assert (x/y).subs({x: L}) == L/y
assert (x**y).subs({x: L}) == L**y
assert (x**y).subs({y: L}) == x**L
assert ((a - c)/b).subs({b: K}) == (a - c)/K
assert (exp(x*y - z)).subs({x*y: L}) == exp(L - z)
assert (a*exp(x*y - w*z) + b*exp(x*y + w*z)).subs({z: 0}) == \
a*exp(x*y) + b*exp(x*y)
assert ((a - b)/(c*d - a*b)).subs({c*d - a*b: K}) == (a - b)/K
assert (w*exp(a*b - c)*x*y/4).subs({x*y: L}) == w*exp(a*b - c)*L/4
def test_fourier_transform():
FT = fourier_transform
IFT = inverse_fourier_transform
def simp(x):
return simplify(expand_trig(expand_complex(expand(x))))
def sinc(x):
return sin(pi*x)/(pi*x)
k = symbols('k', extended_real=True)
f = Function("f")
# TODO for this to work with real a, need to expand abs(a*x) to abs(a)*abs(x)
a = symbols('a', positive=True)
b = symbols('b', positive=True)
posk = symbols('posk', positive=True)
# Test unevaluated form
assert fourier_transform(f(x), x, k) == FourierTransform(f(x), x, k)
assert inverse_fourier_transform(
f(k), k, x) == InverseFourierTransform(f(k), k, x)
# basic examples from wikipedia
assert simp(FT(Heaviside(1 - abs(2*a*x)), x, k)) == sinc(k/a)/a
# TODO IFT is a *mess*
assert simp(FT(Heaviside(1 - abs(a*x))*(1 - abs(a*x)), x, k)) == sinc(k/a)**2/a
# TODO IFT
assert factor(FT(exp(-a*x)*Heaviside(x), x, k), extension=I) == \
1/(a + 2*pi*I*k)
# NOTE: the ift comes out in pieces
assert IFT(1/(a + 2*pi*I*x), x, posk,
noconds=False) == (exp(-a*posk), True)
assert IFT(1/(a + 2*pi*I*x), x, -posk,
noconds=False) == (0, True)
assert IFT(1/(a + 2*pi*I*x), x, symbols('k', negative=True),
noconds=False) == (0, True)
# TODO IFT without factoring comes out as meijer g
assert factor(FT(x*exp(-a*x)*Heaviside(x), x, k), extension=I) == \
1/(a + 2*pi*I*k)**2
assert FT(exp(-a*x)*sin(b*x)*Heaviside(x), x, k) == \
b/(b**2 + (a + 2*I*pi*k)**2)
assert FT(exp(-a*x**2), x, k) == sqrt(pi)*exp(-pi**2*k**2/a)/sqrt(a)
assert IFT(sqrt(pi/a)*exp(-(pi*k)**2/a), k, x) == exp(-a*x**2)
assert FT(exp(-a*abs(x)), x, k) == 2*a/(a**2 + 4*pi**2*k**2)
def test_unrad0():
s = symbols('s', cls=Dummy)
# checkers to deal with possibility of answer coming
# back with a sign change (cf issue sympy/sympy#5203)
def check(rv, ans):
assert bool(rv[1]) == bool(ans[1])
if ans[1]:
return s_check(rv, ans)
e = rv[0].expand()
a = ans[0].expand()
return e in [a, -a] and rv[1] == ans[1]
def s_check(rv, ans):
# get the dummy
rv = list(rv)
d = rv[0].atoms(Dummy)
reps = list(zip(d, [s]*len(d)))
# replace s with this dummy
rv = (rv[0].subs(reps).expand(), [rv[1][0].subs(reps), rv[1][1].subs(reps)])
ans = (ans[0].subs(reps).expand(), [ans[1][0].subs(reps), ans[1][1].subs(reps)])
return str(rv[0]) in [str(ans[0]), str(-ans[0])] and \
str(rv[1]) == str(ans[1])
assert check(unrad(sqrt(x) - root(x + 1, 3)*sqrt(x + 2) + 2),
(s**10 + 8*s**8 + 24*s**6 - 12*s**5 - 22*s**4 - 160*s**3 - 212*s**2 -
192*s - 56, [s, s**2 - x]))
def test_line_color():
x, y = symbols('x, y')
p = plot_implicit(x**2 + y**2 - 1, line_color="green", show=False)
assert p._series[0].line_color == "green"
p = plot_implicit(x**2 + y**2 - 1, line_color='r', show=False)
assert p._series[0].line_color == "r"
matrix
$ python fem.py
[ 1/60, 0, -1/360, 0, -1/90, -1/360]
[ 0, 4/45, 0, 2/45, 2/45, -1/90]
[-1/360, 0, 1/60, -1/90, 0, -1/360]
[ 0, 2/45, -1/90, 4/45, 2/45, 0]
[ -1/90, 2/45, 0, 2/45, 4/45, 0]
[-1/360, -1/90, -1/360, 0, 0, 1/60]
"""
from diofant import (symbols, Symbol, factorial, Rational, zeros, eye,
integrate, diff, pprint, reduced)
x, y, z = symbols('x,y,z')
class ReferenceSimplex:
def __init__(self, nsd):
self.nsd = nsd
if nsd <= 3:
coords = symbols('x,y,z')[:nsd]
else:
coords = [Symbol("x_%d" % d) for d in range(nsd)]
self.coords = coords
def integrate(self, f):
coords = self.coords
nsd = self.nsd
def test_sympyissue_8016():
n, m = symbols('n, m', integer=True, positive=True)
k = symbols('k', integer=True)
s = Sum(binomial(m, k)*binomial(m, n-k)*(-1)**k, (k, 0, n))
assert s.doit().simplify() == \
cos(pi*n/2)*gamma(m + 1)/gamma(n/2 + 1)/gamma(m - n/2 + 1)
def test_cos():
x, y = symbols('x y')
assert cos.nargs == FiniteSet(1)
assert cos(nan) == nan
assert cos(oo) == cos(oo, evaluate=False)
assert cos(oo*I) == oo
assert cos(-oo*I) == oo
assert cos(0) == 1
assert cos(acos(x)) == x
assert cos(atan(x)) == 1 / sqrt(1 + x**2)
assert cos(asin(x)) == sqrt(1 - x**2)
assert cos(acot(x)) == 1 / sqrt(1 + 1 / x**2)
assert cos(atan2(y, x)) == x / sqrt(x**2 + y**2)
assert cos(pi*I) == cosh(pi)
assert cos(-pi*I) == cosh(pi)
assert cos(-2*I) == cosh(2)
assert cos(pi/2) == 0
assert cos(-pi/2) == 0
assert cos(pi/2) == 0
assert cos(-pi/2) == 0
assert cos((-3*10**73 + 1)*pi/2) == 0
assert cos((7*10**103 + 1)*pi/2) == 0
n = symbols('n', integer=True, even=False)
e = symbols('e', even=True)
assert cos(pi*n/2) == 0
assert cos(pi*e/2) == (-1)**(e/2)
assert cos(pi) == -1
assert cos(-pi) == -1
assert cos(2*pi) == 1
assert cos(5*pi) == -1
assert cos(8*pi) == 1
assert cos(pi/3) == Rational(1, 2)
assert cos(-2*pi/3) == Rational(-1, 2)
assert cos(pi/4) == sqrt(2)/2
assert cos(-pi/4) == sqrt(2)/2
assert cos(11*pi/4) == -sqrt(2)/2
assert cos(-3*pi/4) == -sqrt(2)/2
assert cos(pi/6) == sqrt(3)/2
assert cos(-pi/6) == sqrt(3)/2
assert cos(7*pi/6) == -sqrt(3)/2
assert cos(-5*pi/6) == -sqrt(3)/2
assert cos(1*pi/5) == (sqrt(5) + 1)/4
assert cos(2*pi/5) == (sqrt(5) - 1)/4
assert cos(3*pi/5) == -cos(2*pi/5)
assert cos(4*pi/5) == -cos(1*pi/5)
assert cos(6*pi/5) == -cos(1*pi/5)
assert cos(8*pi/5) == cos(2*pi/5)
assert cos(-1273*pi/5) == -cos(2*pi/5)
assert cos(pi/8) == sqrt((2 + sqrt(2))/4)
assert cos(pi/12) == sqrt(2)/4 + sqrt(6)/4
assert cos(5*pi/12) == -sqrt(2)/4 + sqrt(6)/4
assert cos(7*pi/12) == sqrt(2)/4 - sqrt(6)/4
assert cos(11*pi/12) == -sqrt(2)/4 - sqrt(6)/4
assert cos(104*pi/105) == -cos(pi/105)
assert cos(106*pi/105) == -cos(pi/105)
assert cos(-104*pi/105) == -cos(pi/105)
assert cos(-106*pi/105) == -cos(pi/105)
assert cos(x*I) == cosh(x)
assert cos(k*pi*I) == cosh(k*pi)
assert cos(r).is_real
assert cos(c).is_complex
assert cos(0, evaluate=False).is_algebraic
assert cos(a).is_algebraic is None
assert cos(na).is_algebraic is False
q = Symbol('q', rational=True)
assert cos(pi*q).is_algebraic
assert cos(2*pi/7).is_algebraic
qz = Symbol('qz', zero=True)
qn = Symbol('qn', rational=True, nonzero=True)
assert cos(qz).is_rational
assert cos(0, evaluate=False).is_rational
assert cos(qn).is_rational is False
assert cos(q).is_rational is None
assert cos(k*pi) == (-1)**k
assert cos(2*k*pi) == 1
for d in list(range(1, 22)) + [60, 85]:
for n in range(2*d + 1):
x = n*pi/d
e = abs( float(cos(x)) - cos(float(x)) )
assert e < 1e-12
assert cos(z).taylor_term(2, z, *(1, 0)) == -z**2/2
pytest.raises(ArgumentIndexError, lambda: cos(z).fdiff(2))
def test_sec():
x = symbols('x', extended_real=True)
z = symbols('z')
assert sec.nargs == FiniteSet(1)
assert sec(0) == 1
assert sec(pi) == -1
assert sec(pi/2) == zoo
assert sec(-pi/2) == zoo
assert sec(pi/6) == 2*sqrt(3)/3
assert sec(pi/3) == 2
assert sec(5*pi/2) == zoo
assert sec(9*pi/7) == -sec(2*pi/7)
assert sec(3*pi/4) == -sqrt(2) # issue sympy/sympy#8421
assert sec(I) == sech(1)
assert sec(x*I) == sech(x)
assert sec(-x) == sec(x)
assert sec(asec(x)) == x
assert sec(x).rewrite(exp) == 1/(exp(I*x)/2 + exp(-I*x)/2)
assert sec(x).rewrite(sin) == sec(x)
assert sec(x).rewrite(cos) == 1/cos(x)
assert sec(x).rewrite(tan) == (tan(x/2)**2 + 1)/(-tan(x/2)**2 + 1)
assert sec(x).rewrite(sqrt) == sec(x)
assert sec(z).rewrite(cot) == (cot(z/2)**2 + 1)/(cot(z/2)**2 - 1)
assert sec(z).conjugate() == sec(conjugate(z))
assert (sec(z).as_real_imag() ==
(cos(re(z))*cosh(im(z))/(sin(re(z))**2*sinh(im(z))**2 +
cos(re(z))**2*cosh(im(z))**2),
sin(re(z))*sinh(im(z))/(sin(re(z))**2*sinh(im(z))**2 +
cos(re(z))**2*cosh(im(z))**2)))
assert sec(x).expand(trig=True) == 1/cos(x)
assert sec(2*x).expand(trig=True) == 1/(2*cos(x)**2 - 1)
assert sec(a).is_algebraic is None
assert sec(na).is_algebraic is False
assert sec(x).as_leading_term() == sec(x)
assert sec(0).is_finite
assert sec(x).is_finite is None
assert sec(pi/2).is_finite is False
assert series(sec(x), x, x0=0, n=6) == 1 + x**2/2 + 5*x**4/24 + O(x**6)
# https://github.com/sympy/sympy/issues/7166
assert series(sqrt(sec(x))) == 1 + x**2/4 + 7*x**4/96 + O(x**6)
# https://github.com/sympy/sympy/issues/7167
assert (series(sqrt(sec(x)), x, x0=pi*3/2, n=4) ==
1/sqrt(x - 3*pi/2) + (x - 3*pi/2)**Rational(3, 2)/12 +
(x - 3*pi/2)**Rational(7, 2)/160 + O((x - 3*pi/2)**4, (x, 3*pi/2)))
assert sec(x).diff(x) == tan(x)*sec(x)
# Taylor Term checks
assert sec(z).taylor_term(4, z) == 5*z**4/24
assert sec(z).taylor_term(6, z) == 61*z**6/720
assert sec(z).taylor_term(5, z) == 0
pytest.raises(ArgumentIndexError, lambda: sec(x).fdiff(2))
import pytest
from diofant import Abs, Eq, I, Integer, Integral, Mul
from diofant import Rational as Q # noqa: N814
from diofant import cos, erf, exp, integrate, pi, sin, sqrt, symbols
from diofant.domains import ZZ
from diofant.polys import factor
from diofant.polys.polyerrors import GeneratorsNeeded, PolynomialError
from diofant.polys.polyutils import (_analyze_gens, _nsort, _sort_factors,
_sort_gens, _unify_gens, dict_from_expr,
parallel_dict_from_expr)
__all__ = ()
x, y, z, p, q, r, s, t, u, v, w = symbols('x,y,z,p,q,r,s,t,u,v,w')
A, B = symbols('A,B', commutative=False)
def test__nsort():
# issue sympy/sympy#6137
r = ([
Q(3, 2) + sqrt(
Q(-14, 3) - 2 * (Q(-415, 216) + 13 * I / 12)**Q(1, 3) - 4 / sqrt(
Q(-7, 3) + 61 / (18 *
(Q(-415, 216) + 13 * I / 12)**Q(1, 3)) + 2 *
(Q(-415, 216) + 13 * I / 12)**Q(1, 3)) - 61 /
(18 * (Q(-415, 216) + 13 * I / 12)**Q(1, 3))) / 2 -
sqrt(-7 / 3 + 61 / (18 * (Q(-415, 216) + 13 * I / 12)**Q(1, 3)) + 2 *
(Q(-415, 216) + 13 * I / 12)**Q(1, 3)) / 2,
Q(3, 2) - sqrt(
def test_atan2():
assert atan2.nargs == FiniteSet(2)
assert atan2(0, 0) == nan
assert atan2(0, 1) == 0
assert atan2(1, 1) == pi/4
assert atan2(1, 0) == pi/2
assert atan2(1, -1) == 3*pi/4
assert atan2(0, -1) == pi
assert atan2(-1, -1) == -3*pi/4
assert atan2(-1, 0) == -pi/2
assert atan2(-1, 1) == -pi/4
i = symbols('i', imaginary=True)
r = symbols('r', extended_real=True)
eq = atan2(r, i)
ans = -I*log((i + I*r)/sqrt(i**2 + r**2))
reps = ((r, 2), (i, I))
assert eq.subs(reps) == ans.subs(reps)
x = Symbol('x', negative=True)
y = Symbol('y', negative=True)
assert atan2(y, x) == atan(y/x) - pi
y = Symbol('y', nonnegative=True)
assert atan2(y, x) == atan(y/x) + pi
y = Symbol('y')
assert atan2(y, x) == atan2(y, x, evaluate=False)
u = Symbol('u', positive=True)
assert atan2(0, u) == 0
u = Symbol('u', negative=True)
assert atan2(0, u) == pi
assert atan2(y, oo) == 0
assert atan2(y, -oo) == 2*pi*Heaviside(re(y)) - pi
assert atan2(y, x).rewrite(log) == -I*log((x + I*y)/sqrt(x**2 + y**2))
assert atan2(y, x).rewrite(atan) == 2*atan(y/(x + sqrt(x**2 + y**2)))
ex = atan2(y, x) - arg(x + I*y)
assert ex.subs({x: 2, y: 3}).rewrite(arg) == 0
assert ex.subs({x: 2, y: 3*I}).rewrite(arg) == -pi - I*log(sqrt(5)*I/5)
assert ex.subs({x: 2*I, y: 3}).rewrite(arg) == -pi/2 - I*log(sqrt(5)*I)
assert ex.subs({x: 2*I, y: 3*I}).rewrite(arg) == -pi + atan(Rational(2, 3)) + atan(Rational(3, 2))
i = symbols('i', imaginary=True)
r = symbols('r', extended_real=True)
e = atan2(i, r)
rewrite = e.rewrite(arg)
reps = {i: I, r: -2}
assert rewrite == -I*log(abs(I*i + r)/sqrt(abs(i**2 + r**2))) + arg((I*i + r)/sqrt(i**2 + r**2))
assert (e - rewrite).subs(reps).equals(0)
r1 = Symbol('r1', real=True, nonzero=True)
r2 = Symbol('r2', real=True, nonzero=True)
assert atan2(r1, r2).is_real
assert atan2(0, r1) == pi*(-Heaviside(r1) + 1)
r1 = Symbol('r1', real=True)
r2 = Symbol('r2', real=True)
assert atan2(r1, r2).is_real is None
assert atan2(r1, r2).rewrite(arg) == arg(I*r1 + r2)
assert conjugate(atan2(x, y)) == atan2(conjugate(x), conjugate(y))
assert diff(atan2(y, x), x) == -y/(x**2 + y**2)
assert diff(atan2(y, x), y) == x/(x**2 + y**2)
assert simplify(diff(atan2(y, x).rewrite(log), x)) == -y/(x**2 + y**2)
assert simplify(diff(atan2(y, x).rewrite(log), y)) == x/(x**2 + y**2)
pytest.raises(ArgumentIndexError, lambda: atan2(x, y).fdiff(3))
def test_meijerint():
from diofant import symbols, expand, arg
s, t, mu = symbols('s t mu', extended_real=True)
assert integrate(
meijerg([], [], [0], [], s * t) *
meijerg([], [], [mu / 2], [-mu / 2], t**2 / 4),
(t, 0, oo)).is_Piecewise
s = symbols('s', positive=True)
assert integrate(x**s*meijerg([[], []], [[0], []], x), (x, 0, oo)) == \
gamma(s + 1)
assert integrate(x**s * meijerg([[], []], [[0], []], x), (x, 0, oo),
meijerg=True) == gamma(s + 1)
assert isinstance(
integrate(x**s * meijerg([[], []], [[0], []], x), (x, 0, oo),
meijerg=False), Integral)
assert meijerint_indefinite(exp(x), x) == exp(x)
# TODO what simplifications should be done automatically?
# This tests "extra case" for antecedents_1.
a, b = symbols('a b', positive=True)
assert simplify(meijerint_definite(x**a, x, 0, b)[0]) == \
b**(a + 1)/(a + 1)
# This tests various conditions and expansions:
meijerint_definite((x + 1)**3 * exp(-x), x, 0, oo) == (16, True)
# Again, how about simplifications?
sigma, mu = symbols('sigma mu', positive=True)
i, c = meijerint_definite(exp(-((x - mu) / (2 * sigma))**2), x, 0, oo)
assert simplify(i) == sqrt(pi) * sigma * (erf(mu / (2 * sigma)) + 1)
assert c
i, _ = meijerint_definite(exp(-mu * x) * exp(sigma * x), x, 0, oo)
# TODO it would be nice to test the condition
assert simplify(i) == 1 / (mu - sigma)
# Test substitutions to change limits
assert meijerint_definite(exp(x), x, -oo, 2) == (exp(2), True)
# Note: causes a NaN in _check_antecedents
assert expand(meijerint_definite(exp(x), x, 0, I)[0]) == exp(I) - 1
assert expand(meijerint_definite(exp(-x), x, 0, x)[0]) == \
1 - exp(-exp(I*arg(x))*abs(x))
# Test -oo to oo
assert meijerint_definite(exp(-x**2), x, -oo, oo) == (sqrt(pi), True)
assert meijerint_definite(exp(-abs(x)), x, -oo, oo) == (2, True)
assert meijerint_definite(exp(-(2*x - 3)**2), x, -oo, oo) == \
(sqrt(pi)/2, True)
assert meijerint_definite(exp(-abs(2 * x - 3)), x, -oo, oo) == (1, True)
assert meijerint_definite(
exp(-((x - mu) / sigma)**2 / 2) / sqrt(2 * pi * sigma**2), x, -oo,
oo) == (1, True)
# Test one of the extra conditions for 2 g-functinos
assert meijerint_definite(exp(-x) * sin(x), x, 0,
oo) == (Rational(1, 2), True)
# Test a bug
def res(n):
return (1 / (1 + x**2)).diff(x, n).subs(x, 1) * (-1)**n
for n in range(6):
assert integrate(exp(-x)*sin(x)*x**n, (x, 0, oo), meijerg=True) == \
res(n)
# This used to test trigexpand... now it is done by linear substitution
assert simplify(integrate(exp(-x) * sin(x + a), (x, 0, oo),
meijerg=True)) == sqrt(2) * sin(a + pi / 4) / 2
# Test the condition 14 from prudnikov.
# (This is besselj*besselj in disguise, to stop the product from being
# recognised in the tables.)
a, b, s = symbols('a b s')
from diofant import And, re
assert meijerint_definite(meijerg([], [], [a/2], [-a/2], x/4)
* meijerg([], [], [b/2], [-b/2], x/4)*x**(s - 1), x, 0, oo) == \
(4*2**(2*s - 2)*gamma(-2*s + 1)*gamma(a/2 + b/2 + s)
/ (gamma(-a/2 + b/2 - s + 1)*gamma(a/2 - b/2 - s + 1)
* gamma(a/2 + b/2 - s + 1)),
And(0 < -2*re(4*s) + 8, 0 < re(a/2 + b/2 + s), re(2*s) < 1))
# test a bug
assert integrate(sin(x**a)*sin(x**b), (x, 0, oo), meijerg=True) == \
Integral(sin(x**a)*sin(x**b), (x, 0, oo))
# test better hyperexpand
assert integrate(exp(-x**2)*log(x), (x, 0, oo), meijerg=True) == \
(sqrt(pi)*polygamma(0, Rational(1, 2))/4).expand()
# Test hyperexpand bug.
from diofant import lowergamma
n = symbols('n', integer=True)
assert simplify(integrate(exp(-x)*x**n, x, meijerg=True)) == \
lowergamma(n + 1, x)
# Test a bug with argument 1/x
alpha = symbols('alpha', positive=True)
assert meijerint_definite((2 - x)**alpha*sin(alpha/x), x, 0, 2) == \
(sqrt(pi)*alpha*gamma(alpha + 1)*meijerg(((), (alpha/2 + Rational(1, 2),
alpha/2 + 1)), ((0, 0, Rational(1, 2)), (-Rational(1, 2),)), alpha**Integer(2)/16)/4, True)
# test a bug related to 3016
a, s = symbols('a s', positive=True)
assert simplify(integrate(x**s*exp(-a*x**2), (x, -oo, oo))) == \
a**(-s/2 - Rational(1, 2))*((-1)**s + 1)*gamma(s/2 + Rational(1, 2))/2
def test_floor():
x = Symbol('x')
i = Symbol('i', imaginary=True)
y = Symbol('y', extended_real=True)
r = Symbol('r', real=True)
k, n = symbols('k,n', integer=True)
assert floor(y).is_extended_real
assert floor(x).is_extended_real is None
assert floor(r).is_finite
assert floor(y).is_finite is None
assert floor(r).is_integer
assert floor(y).is_integer is None
assert floor(nan) == nan
assert floor(oo) == oo
assert floor(-oo) == -oo
assert floor(0) == 0
assert floor(1) == 1
assert floor(-1) == -1
assert floor(E) == 2
assert floor(-E) == -3
assert floor(2 * E) == 5
assert floor(-2 * E) == -6
assert floor(pi) == 3
assert floor(-pi) == -4
assert floor(Rational(1, 2)) == 0
assert floor(-Rational(1, 2)) == -1
assert floor(Rational(7, 3)) == 2
assert floor(-Rational(7, 3)) == -3
assert floor(Float(17.0)) == 17
assert floor(-Float(17.0)) == -17
assert floor(Float(7.69)) == 7
assert floor(-Float(7.69)) == -8
assert floor(I) == I
assert floor(-I) == -I
e = floor(i)
assert e.func is floor and e.args[0] == i
assert floor(oo * I) == oo * I
assert floor(-oo * I) == -oo * I
assert floor(2 * I) == 2 * I
assert floor(-2 * I) == -2 * I
assert floor(I / 2) == 0
assert floor(-I / 2) == -I
assert floor(E + 17) == 19
assert floor(pi + 2) == 5
assert floor(E + pi) == floor(E + pi)
assert floor(I + pi) == floor(I + pi)
assert floor(floor(pi)) == 3
assert floor(floor(y)) == floor(y)
assert floor(floor(x)) == floor(floor(x))
assert floor(x) == floor(x)
assert floor(2 * x) == floor(2 * x)
assert floor(k * x) == floor(k * x)
assert floor(k) == k
assert floor(2 * k) == 2 * k
assert floor(k * n) == k * n
assert floor(k / 2) == floor(k / 2)
assert floor(x + y) == floor(x + y)
assert floor(x + 3) == floor(x + 3)
assert floor(x + k) == floor(x + k)
assert floor(y + 3) == floor(y) + 3
assert floor(y + k) == floor(y) + k
assert floor(3 + I * y + pi) == 6 + floor(y) * I
assert floor(k + n) == k + n
assert floor(x * I) == floor(x * I)
assert floor(k * I) == k * I
assert floor(Rational(23, 10) - E * I) == 2 - 3 * I
assert floor(sin(1)) == 0
assert floor(sin(-1)) == -1
assert floor(exp(2)) == 7
assert floor(log(8) / log(2)) != 2
assert int(floor(log(8) / log(2)).evalf(chop=True)) == 3
assert floor(factorial(50)/exp(1)) == \
11188719610782480504630258070757734324011354208865721592720336800
assert (floor(y) <= y) is S.true
assert (floor(y) > y) is S.false
assert (floor(x) <= x).is_Relational # x could be non-real
assert (floor(x) > x).is_Relational
assert (floor(x) <= y).is_Relational # arg is not same as rhs
assert (floor(x) > y).is_Relational
assert floor(x).as_leading_term(x) == floor(x)
import pytest
from diofant import (Add, Derivative, Ei, Eq, Function, I, Integral, LambertW,
Piecewise, Rational, Sum, Symbol, acos, asin, asinh,
besselj, cos, cosh, diff, erf, exp, li, log, pi, ratsimp,
root, simplify, sin, sinh, sqrt, symbols, tan)
from diofant.integrals.heurisch import components, heurisch, heurisch_wrapper
__all__ = ()
x, y, z, nu = symbols('x,y,z,nu')
f = Function('f')
def test_components():
assert components(x * y, x) == {x}
assert components(1 / (x + y), x) == {x}
assert components(sin(x), x) == {sin(x), x}
assert components(sin(x)*sqrt(log(x)), x) == \
{log(x), sin(x), sqrt(log(x)), x}
assert components(x*sin(exp(x)*y), x) == \
{sin(y*exp(x)), x, exp(x)}
assert components(x**Rational(17, 54)/sqrt(sin(x)), x) == \
{sin(x), root(x, 54), sqrt(sin(x)), x}
assert components(f(x), x) == \
{x, f(x)}
assert components(Derivative(f(x), x), x) == \
{x, f(x), Derivative(f(x), x)}
assert components(f(x)*diff(f(x), x), x) == \
{x, f(x), Derivative(f(x), x), Derivative(f(x), x)}
def test_probability():
# various integrals from probability theory
from diofant.abc import x, y
from diofant import symbols, Symbol, Abs, expand_mul, combsimp, powsimp, sin
mu1, mu2 = symbols('mu1 mu2', real=True, nonzero=True)
sigma1, sigma2 = symbols('sigma1 sigma2',
real=True,
nonzero=True,
positive=True)
rate = Symbol('lambda', real=True, positive=True)
def normal(x, mu, sigma):
return 1 / sqrt(2 * pi * sigma**2) * exp(-(x - mu)**2 / 2 / sigma**2)
def exponential(x, rate):
return rate * exp(-rate * x)
assert integrate(normal(x, mu1, sigma1), (x, -oo, oo), meijerg=True) == 1
assert integrate(x*normal(x, mu1, sigma1), (x, -oo, oo), meijerg=True) == \
mu1
assert integrate(x**2*normal(x, mu1, sigma1), (x, -oo, oo), meijerg=True) \
== mu1**2 + sigma1**2
assert integrate(x**3*normal(x, mu1, sigma1), (x, -oo, oo), meijerg=True) \
== mu1**3 + 3*mu1*sigma1**2
assert integrate(normal(x, mu1, sigma1) * normal(y, mu2, sigma2),
(x, -oo, oo), (y, -oo, oo),
meijerg=True) == 1
assert integrate(x * normal(x, mu1, sigma1) * normal(y, mu2, sigma2),
(x, -oo, oo), (y, -oo, oo),
meijerg=True) == mu1
assert integrate(y * normal(x, mu1, sigma1) * normal(y, mu2, sigma2),
(x, -oo, oo), (y, -oo, oo),
meijerg=True) == mu2
assert integrate(x * y * normal(x, mu1, sigma1) * normal(y, mu2, sigma2),
(x, -oo, oo), (y, -oo, oo),
meijerg=True) == mu1 * mu2
assert integrate(
(x + y + 1) * normal(x, mu1, sigma1) * normal(y, mu2, sigma2),
(x, -oo, oo), (y, -oo, oo),
meijerg=True) == 1 + mu1 + mu2
assert integrate((x + y - 1)*normal(x, mu1, sigma1)*normal(y, mu2, sigma2),
(x, -oo, oo), (y, -oo, oo), meijerg=True) == \
-1 + mu1 + mu2
i = integrate(x**2 * normal(x, mu1, sigma1) * normal(y, mu2, sigma2),
(x, -oo, oo), (y, -oo, oo),
meijerg=True)
assert not i.has(Abs)
assert simplify(i) == mu1**2 + sigma1**2
assert integrate(y**2*normal(x, mu1, sigma1)*normal(y, mu2, sigma2),
(x, -oo, oo), (y, -oo, oo), meijerg=True) == \
sigma2**2 + mu2**2
assert integrate(exponential(x, rate), (x, 0, oo), meijerg=True) == 1
assert integrate(x*exponential(x, rate), (x, 0, oo), meijerg=True) == \
1/rate
assert integrate(x**2*exponential(x, rate), (x, 0, oo), meijerg=True) == \
2/rate**2
def E(expr):
res1 = integrate(expr * exponential(x, rate) * normal(y, mu1, sigma1),
(x, 0, oo), (y, -oo, oo),
meijerg=True)
res2 = integrate(expr * exponential(x, rate) * normal(y, mu1, sigma1),
(y, -oo, oo), (x, 0, oo),
meijerg=True)
assert expand_mul(res1) == expand_mul(res2)
return res1
assert E(1) == 1
assert E(x * y) == mu1 / rate
assert E(x * y**2) == mu1**2 / rate + sigma1**2 / rate
ans = sigma1**2 + 1 / rate**2
assert simplify(E((x + y + 1)**2) - E(x + y + 1)**2) == ans
assert simplify(E((x + y - 1)**2) - E(x + y - 1)**2) == ans
assert simplify(E((x + y)**2) - E(x + y)**2) == ans
# Beta' distribution
alpha, beta = symbols('alpha beta', positive=True)
betadist = x**(alpha - 1)*(1 + x)**(-alpha - beta)*gamma(alpha + beta) \
/ gamma(alpha)/gamma(beta)
assert integrate(betadist, (x, 0, oo), meijerg=True) == 1
i = integrate(x * betadist, (x, 0, oo), meijerg=True, conds='separate')
assert (combsimp(i[0]), i[1]) == (alpha / (beta - 1), 1 < beta)
j = integrate(x**2 * betadist, (x, 0, oo), meijerg=True, conds='separate')
assert j[1] == (1 < beta - 1)
assert combsimp(j[0] - i[0]**2) == (alpha + beta - 1)*alpha \
/ (beta - 2)/(beta - 1)**2
# Beta distribution
# NOTE: this is evaluated using antiderivatives. It also tests that
# meijerint_indefinite returns the simplest possible answer.
a, b = symbols('a b', positive=True)
betadist = x**(a - 1) * (-x + 1)**(b - 1) * gamma(a + b) / (gamma(a) *
gamma(b))
assert simplify(integrate(betadist, (x, 0, 1), meijerg=True)) == 1
assert simplify(integrate(x*betadist, (x, 0, 1), meijerg=True)) == \
a/(a + b)
assert simplify(integrate(x**2*betadist, (x, 0, 1), meijerg=True)) == \
a*(a + 1)/(a + b)/(a + b + 1)
assert simplify(integrate(x**y*betadist, (x, 0, 1), meijerg=True)) == \
gamma(a + b)*gamma(a + y)/gamma(a)/gamma(a + b + y)
# Chi distribution
k = Symbol('k', integer=True, positive=True)
chi = 2**(1 - k / 2) * x**(k - 1) * exp(-x**2 / 2) / gamma(k / 2)
assert powsimp(integrate(chi, (x, 0, oo), meijerg=True)) == 1
assert simplify(integrate(x*chi, (x, 0, oo), meijerg=True)) == \
sqrt(2)*gamma((k + 1)/2)/gamma(k/2)
assert simplify(integrate(x**2 * chi, (x, 0, oo), meijerg=True)) == k
# Chi^2 distribution
chisquared = 2**(-k / 2) / gamma(k / 2) * x**(k / 2 - 1) * exp(-x / 2)
assert powsimp(integrate(chisquared, (x, 0, oo), meijerg=True)) == 1
assert simplify(integrate(x * chisquared, (x, 0, oo), meijerg=True)) == k
assert simplify(integrate(x**2*chisquared, (x, 0, oo), meijerg=True)) == \
k*(k + 2)
assert combsimp(
integrate(((x - k) / sqrt(2 * k))**3 * chisquared, (x, 0, oo),
meijerg=True)) == 2 * sqrt(2) / sqrt(k)
# Dagum distribution
a, b, p = symbols('a b p', positive=True)
# XXX (x/b)**a does not work
dagum = a * p / x * (x / b)**(a * p) / (1 + x**a / b**a)**(p + 1)
assert simplify(integrate(dagum, (x, 0, oo), meijerg=True)) == 1
# XXX conditions are a mess
arg = x * dagum
assert simplify(integrate(
arg, (x, 0, oo), meijerg=True,
conds='none')) == a * b * gamma(1 - 1 / a) * gamma(p + 1 + 1 / a) / (
(a * p + 1) * gamma(p))
assert simplify(integrate(
x * arg, (x, 0, oo), meijerg=True,
conds='none')) == a * b**2 * gamma(1 -
2 / a) * gamma(p + 1 + 2 / a) / (
(a * p + 2) * gamma(p))
# F-distribution
d1, d2 = symbols('d1 d2', positive=True)
f = sqrt(((d1*x)**d1 * d2**d2)/(d1*x + d2)**(d1 + d2))/x \
/ gamma(d1/2)/gamma(d2/2)*gamma((d1 + d2)/2)
assert simplify(integrate(f, (x, 0, oo), meijerg=True)) == 1
# TODO conditions are a mess
assert simplify(integrate(x * f, (x, 0, oo), meijerg=True,
conds='none')) == d2 / (d2 - 2)
assert simplify(
integrate(x**2 * f, (x, 0, oo), meijerg=True,
conds='none')) == d2**2 * (d1 + 2) / d1 / (d2 - 4) / (d2 - 2)
# TODO gamma, rayleigh
# inverse gaussian
lamda, mu = symbols('lamda mu', positive=True)
dist = sqrt(lamda / 2 / pi) * x**(-Rational(3, 2)) * exp(
-lamda * (x - mu)**2 / x / 2 / mu**2)
def mysimp(expr):
return simplify(expr.rewrite(exp))
assert mysimp(integrate(dist, (x, 0, oo))) == 1
assert mysimp(integrate(x * dist, (x, 0, oo))) == mu
assert mysimp(integrate((x - mu)**2 * dist, (x, 0, oo))) == mu**3 / lamda
assert mysimp(integrate((x - mu)**3 * dist,
(x, 0, oo))) == 3 * mu**5 / lamda**2
# Levi
c = Symbol('c', positive=True)
assert integrate(
sqrt(c / 2 / pi) * exp(-c / 2 / (x - mu)) / (x - mu)**Rational(3, 2),
(x, mu, oo)) == 1
# higher moments oo
# log-logistic
distn = (beta/alpha)*x**(beta - 1)/alpha**(beta - 1) / \
(1 + x**beta/alpha**beta)**2
assert simplify(integrate(distn, (x, 0, oo))) == 1
# NOTE the conditions are a mess, but correctly state beta > 1
assert simplify(integrate(x*distn, (x, 0, oo), conds='none')) == \
pi*alpha/beta/sin(pi/beta)
# (similar comment for conditions applies)
assert simplify(integrate(x**y*distn, (x, 0, oo), conds='none')) == \
pi*alpha**y*y/beta/sin(pi*y/beta)
# weibull
k = Symbol('k', positive=True)
n = Symbol('n', positive=True)
distn = k / lamda * (x / lamda)**(k - 1) * exp(-(x / lamda)**k)
assert simplify(integrate(distn, (x, 0, oo))) == 1
assert simplify(integrate(x**n*distn, (x, 0, oo))) == \
lamda**n*gamma(1 + n/k)
# rice distribution
from diofant import besseli
nu, sigma = symbols('nu sigma', positive=True)
rice = x / sigma**2 * exp(-(x**2 + nu**2) / 2 / sigma**2) * besseli(
0, x * nu / sigma**2)
assert integrate(rice, (x, 0, oo), meijerg=True) == 1
# can someone verify higher moments?
# Laplace distribution
mu = Symbol('mu', extended_real=True)
b = Symbol('b', positive=True)
laplace = exp(-abs(x - mu) / b) / 2 / b
assert integrate(laplace, (x, -oo, oo), meijerg=True) == 1
assert integrate(x * laplace, (x, -oo, oo), meijerg=True) == mu
assert integrate(x**2*laplace, (x, -oo, oo), meijerg=True) == \
2*b**2 + mu**2
# TODO are there other distributions supported on (-oo, oo) that we can do?
# misc tests
k = Symbol('k', positive=True)
assert combsimp(
expand_mul(
integrate(log(x) * x**(k - 1) * exp(-x) / gamma(k),
(x, 0, oo)))) == polygamma(0, k)
from diofant import (DiracDelta, Function, Heaviside, Integer, Rational, cos,
exp, pi, sin, symbols)
from diofant.integrals.deltafunctions import change_mul, deltaintegrate
__all__ = ()
f = Function("f")
x_1, x_2, x, y, z = symbols("x_1 x_2 x y z")
def test_change_mul():
assert change_mul(x, x) == x
assert change_mul(x*y, x) == (None, None)
assert change_mul(x*y*DiracDelta(x), x) == (DiracDelta(x), x*y)
assert change_mul(x*y*DiracDelta(x)*DiracDelta(y), x) == \
(DiracDelta(x), x*y*DiracDelta(y))
assert change_mul(DiracDelta(x)**2, x) == \
(DiracDelta(x), DiracDelta(x))
assert change_mul(y*DiracDelta(x)**2, x) == \
(DiracDelta(x), y*DiracDelta(x))
def test_deltaintegrate():
assert deltaintegrate(x, x) is None
assert deltaintegrate(x + DiracDelta(x), x) is None
assert deltaintegrate(DiracDelta(x, 0), x) == Heaviside(x)
for n in range(10):
assert deltaintegrate(DiracDelta(x, n + 1), x) == DiracDelta(x, n)
assert deltaintegrate(DiracDelta(x), x) == Heaviside(x)
assert deltaintegrate(DiracDelta(-x), x) == Heaviside(x)
import pytest
from diofant import (Adjoint, FunctionMatrix, Identity, ImmutableMatrix,
Lambda, MatAdd, MatMul, MatPow, Matrix, MatrixExpr,
MatrixSymbol, ShapeError, Sum, Trace, ZeroMatrix, adjoint,
conjugate, eye, symbols, trace, transpose)
__all__ = ()
n = symbols('n', integer=True)
A = MatrixSymbol('A', n, n)
B = MatrixSymbol('B', n, n)
C = MatrixSymbol('C', 3, 4)
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)
A / Trace(A) # Make sure this is possible
# Some easy simplifications
assert trace(Identity(5)) == 5
def test_line_geom():
p1 = Point(0, 0)
p2 = Point(1, 1)
p3 = Point(x1, x1)
p4 = Point(y1, y1)
p5 = Point(x1, 1 + x1)
p6 = Point(1, 0)
p7 = Point(0, 1)
p8 = Point(2, 0)
p9 = Point(2, 1)
l1 = Line(p1, p2)
l2 = Line(p3, p4)
l3 = Line(p3, p5)
l4 = Line(p1, p6)
l5 = Line(p1, p7)
l6 = Line(p8, p9)
l7 = Line(p2, p9)
pytest.raises(ValueError, lambda: Line(Point(0, 0), Point(0, 0)))
# Basic stuff
assert Line((1, 1), slope=1) == Line((1, 1), (2, 2))
assert Line((1, 1), slope=oo) == Line((1, 1), (1, 2))
assert Line((1, 1), slope=-oo) == Line((1, 1), (1, 2))
pytest.raises(ValueError, lambda: Line((1, 1), 1))
assert Line(p1, p2) == Line(p1, p2)
assert Line(p1, p2) != Line(p2, p1)
assert l1 != l2
assert l1 != l3
assert l1.slope == 1
assert l1.length == oo
assert l3.slope == oo
assert l4.slope == 0
assert l4.coefficients == (0, 1, 0)
assert l4.equation(x=x, y=y) == y
assert l5.slope == oo
assert l5.coefficients == (1, 0, 0)
assert l5.equation() == x
assert l6.equation() == x - 2
assert l7.equation() == y - 1
assert p1 in l1 # is p1 on the line l1?
assert p1 not in l3
assert Line((-x, x), (-x + 1, x - 1)).coefficients == (1, 1, 0)
assert simplify(l1.equation()) in (x - y, y - x)
assert simplify(l3.equation()) in (x - x1, x1 - x)
assert Line(p1, p2).scale(2, 1) == Line(p1, p9)
assert l2.arbitrary_point() in l2
for _ in range(5):
assert l3.random_point() in l3
pytest.raises(ValueError, lambda: l3.arbitrary_point('x1'))
assert Line(Point(0, 0), Point(1, 0)).is_similar(
Line(Point(1, 0), Point(2, 0))) is True
assert l1.equal(l1) is True
assert l1.equal(l2) is True
assert l1.equal(l3) is False
assert l1.equal(object()) is False
# Orthogonality
p1_1 = Point(-x1, x1)
l1_1 = Line(p1, p1_1)
assert l1.perpendicular_line(p1.args) == Line(Point(0, 0), Point(1, -1))
assert l1.perpendicular_line(p1) == Line(Point(0, 0), Point(1, -1))
assert Line.is_perpendicular(l1, l1_1)
assert Line.is_perpendicular(l1, l2) is False
p = l1.random_point()
assert l1.perpendicular_segment(p) == p
assert l4.perpendicular_line(p2) == Line(Point(1, 1), Point(1, 0))
# Parallelity
l2_1 = Line(p3, p5)
assert l2.parallel_line(p1_1) == Line(Point(-x1, x1),
Point(-y1, 2 * x1 - y1))
assert l2_1.parallel_line(p1.args) == Line(Point(0, 0), Point(0, -1))
assert l2_1.parallel_line(p1) == Line(Point(0, 0), Point(0, -1))
assert Line.is_parallel(l1, l2)
assert Line.is_parallel(l2, l3) is False
assert Line.is_parallel(l2, l2.parallel_line(p1_1))
assert Line.is_parallel(l2_1, l2_1.parallel_line(p1))
# Intersection
assert intersection(l1, p1) == [p1]
assert intersection(l1, p5) == []
assert intersection(l1, l2) in [[l1], [l2]]
assert intersection(l1, l1.parallel_line(p5)) == []
# Concurrency
l3_1 = Line(Point(5, x1), Point(-Rational(3, 5), x1))
assert Line.are_concurrent(l1) is False
assert Line.are_concurrent(l1, l3)
assert Line.are_concurrent(l1, l3, l3_1)
assert Line.are_concurrent(l1, l1_1, l3) is False
# Projection
assert l2.projection(p4) == p4
assert l1.projection(p1_1) == p1
assert l3.projection(p2) == Point(x1, 1)
pytest.raises(
GeometryError, lambda: Line(Point(0, 0), Point(1, 0)).projection(
Circle(Point(0, 0), 1)))
# Finding angles
l1_1 = Line(p1, Point(5, 0))
assert feq(Line.angle_between(l1, l1_1).evalf(), pi.evalf() / 4)
# Testing Rays and Segments (very similar to Lines)
pytest.raises(ValueError, lambda: Ray((1, 1), I))
pytest.raises(ValueError, lambda: Ray(p1, p1))
pytest.raises(ValueError, lambda: Ray(p1))
assert Ray((1, 1), angle=pi / 4) == Ray((1, 1), (2, 2))
assert Ray((1, 1), angle=pi / 2) == Ray((1, 1), (1, 2))
assert Ray((1, 1), angle=-pi / 2) == Ray((1, 1), (1, 0))
assert Ray((1, 1), angle=-3 * pi / 2) == Ray((1, 1), (1, 2))
assert Ray((1, 1), angle=5 * pi / 2) == Ray((1, 1), (1, 2))
assert Ray((1, 1), angle=5.0 * pi / 2) == Ray((1, 1), (1, 2))
assert Ray((1, 1), angle=pi) == Ray((1, 1), (0, 1))
assert Ray((1, 1), angle=3.0 * pi) == Ray((1, 1), (0, 1))
assert Ray((1, 1), angle=4.0 * pi) == Ray((1, 1), (2, 1))
assert Ray((1, 1), angle=0) == Ray((1, 1), (2, 1))
assert Ray((1, 1), angle=4.05 * pi) == Ray(
Point(1, 1),
Point(
2, -sqrt(5) * sqrt(2 * sqrt(5) + 10) / 4 -
sqrt(2 * sqrt(5) + 10) / 4 + 2 + sqrt(5)))
assert Ray((1, 1), angle=4.02 * pi) == Ray(Point(1, 1),
Point(2, 1 + tan(4.02 * pi)))
assert Ray((1, 1), angle=5) == Ray((1, 1), (2, 1 + tan(5)))
pytest.raises(ValueError, lambda: Ray((1, 1), 1))
# issue sympy/sympy#7963
r = Ray((0, 0), angle=x)
assert r.subs({x: 3 * pi / 4}) == Ray((0, 0), (-1, 1))
assert r.subs({x: 5 * pi / 4}) == Ray((0, 0), (-1, -1))
assert r.subs({x: -pi / 4}) == Ray((0, 0), (1, -1))
assert r.subs({x: pi / 2}) == Ray((0, 0), (0, 1))
assert r.subs({x: -pi / 2}) == Ray((0, 0), (0, -1))
r1 = Ray(p1, Point(-1, 5))
r2 = Ray(p1, Point(-1, 1))
r3 = Ray(p3, p5)
r4 = Ray(p1, p2)
r5 = Ray(p2, p1)
r6 = Ray(Point(0, 1), Point(1, 2))
r7 = Ray(Point(0.5, 0.5), Point(1, 1))
assert l1.projection(r1) == Ray(Point(0, 0), Point(2, 2))
assert l1.projection(r2) == p1
assert r3 != r1
t = Symbol('t', extended_real=True)
assert Ray((1, 1), angle=pi/4).arbitrary_point() == \
Point(t + 1, t + 1)
r8 = Ray(Point(0, 0), Point(0, 4))
r9 = Ray(Point(0, 1), Point(0, -1))
assert r8.intersection(r9) == [Segment(Point(0, 0), Point(0, 1))]
s1 = Segment(p1, p2)
s2 = Segment(p1, p1_1)
assert s1.midpoint == Point(Rational(1, 2), Rational(1, 2))
assert s2.length == sqrt(2 * (x1**2))
assert Segment((1, 1), (2, 3)).arbitrary_point() == Point(1 + t, 1 + 2 * t)
assert s1.perpendicular_bisector() == \
Line(Point(1/2, 1/2), Point(3/2, -1/2))
# intersections
assert s1.intersection(Line(p6, p9)) == []
s3 = Segment(Point(0.25, 0.25), Point(0.5, 0.5))
assert s1.intersection(s3) == [s1]
assert s3.intersection(s1) == [s3]
assert r4.intersection(s3) == [s3]
assert r4.intersection(Segment(Point(2, 3), Point(3, 4))) == []
assert r4.intersection(Segment(Point(-1, -1), Point(0.5, 0.5))) == \
[Segment(p1, Point(0.5, 0.5))]
s3 = Segment(Point(1, 1), Point(2, 2))
assert s1.intersection(s3) == [Point(1, 1)]
s3 = Segment(Point(0.5, 0.5), Point(1.5, 1.5))
assert s1.intersection(s3) == [Segment(Point(0.5, 0.5), p2)]
assert s1.intersection(Segment(Point(4, 4), Point(5, 5))) == []
assert s1.intersection(Segment(Point(-1, -1), p1)) == [p1]
assert s1.intersection(Segment(Point(-1, -1), Point(0.5, 0.5))) == \
[Segment(p1, Point(0.5, 0.5))]
assert r4.intersection(r5) == [s1]
assert r5.intersection(r6) == []
assert r4.intersection(r7) == r7.intersection(r4) == [r7]
# Segment contains
a, b = symbols('a,b')
s = Segment((0, a), (0, b))
assert Point(0, (a + b) / 2) in s
s = Segment((a, 0), (b, 0))
assert Point((a + b) / 2, 0) in s
pytest.raises(Undecidable, lambda: Point(2 * a, 0) in s)
# Testing distance from a Segment to an object
s1 = Segment(Point(0, 0), Point(1, 1))
s2 = Segment(Point(0.5, 0.5), Point(1, 0))
pt1 = Point(0, 0)
pt2 = Point(Rational(3, 2), Rational(3, 2))
assert s1.distance(pt1) == 0
assert s1.distance((0, 0)) == 0
assert s2.distance(pt1) == sqrt(2) / 2
assert s2.distance(pt2) == sqrt(2)
# Line to point
p1, p2 = Point(0, 0), Point(1, 1)
s = Line(p1, p2)
assert s.distance(Point(-1, 1)) == sqrt(2)
assert s.distance(Point(1, -1)) == sqrt(2)
assert s.distance(Point(2, 2)) == 0
assert s.distance((-1, 1)) == sqrt(2)
assert Line((0, 0), (0, 1)).distance(p1) == 0
assert Line((0, 0), (0, 1)).distance(p2) == 1
assert Line((0, 0), (1, 0)).distance(p1) == 0
assert Line((0, 0), (1, 0)).distance(p2) == 1
m = symbols('m')
l = Line((0, 5), slope=m)
p = Point(2, 3)
assert l.distance(p) == 2 * abs(m + 1) / sqrt(m**2 + 1)
# Ray to point
r = Ray(p1, p2)
assert r.distance(Point(-1, -1)) == sqrt(2)
assert r.distance(Point(1, 1)) == 0
assert r.distance(Point(-1, 1)) == sqrt(2)
assert Ray((1, 1), (2, 2)).distance(Point(1.5, 3)) == 3 * sqrt(2) / 4
assert r.distance((1, 1)) == 0
assert r.distance((-1, Rational(1, 2))) == sqrt(5) / 2
# Line contains
p1, p2 = Point(0, 1), Point(3, 4)
l = Line(p1, p2)
assert l.contains(p1) is True
assert l.contains((0, 1)) is True
assert l.contains((0, 0)) is False
assert l.contains(Circle(p1, 1)) is False
assert l.contains(Ray(p1, p1 + p2)) is False
# Ray contains
p1, p2 = Point(0, 0), Point(4, 4)
r = Ray(p1, p2)
assert r.contains(p1) is True
assert r.contains((1, 1)) is True
assert r.contains((1, 3)) is False
assert r.contains(object()) is False
s = Segment((1, 1), (2, 2))
assert r.contains(s) is True
s = Segment((1, 2), (2, 5))
assert r.contains(s) is False
r1 = Ray((2, 2), (3, 3))
assert r.contains(r1) is True
r1 = Ray((2, 2), (3, 5))
assert r.contains(r1) is False
r1 = Ray(p1, angle=-pi)
assert r1.contains(Point(1, 0)) is False
r1 = Ray(p1, angle=-pi / 2)
assert r1.contains(Point(0, 1)) is False
pytest.raises(Undecidable, lambda: r1.contains(Point(0, x)))
# Special cases of projection and intersection
r1 = Ray(Point(1, 1), Point(2, 2))
r2 = Ray(Point(2, 2), Point(0, 0))
r3 = Ray(Point(1, 1), Point(-1, -1))
r4 = Ray(Point(0, 4), Point(-1, -5))
r5 = Ray(Point(2, 2), Point(3, 3))
assert intersection(r1, r2) == [Segment(Point(1, 1), Point(2, 2))]
assert intersection(r1, r3) == [Point(1, 1)]
assert r1.projection(r3) == Point(1, 1)
assert r1.projection(r4) == Segment(Point(1, 1), Point(2, 2))
r5 = Ray(Point(0, 0), Point(0, 1))
r6 = Ray(Point(0, 0), Point(0, 2))
assert r5 in r6
assert r6 in r5
s1 = Segment(Point(0, 0), Point(2, 2))
s2 = Segment(Point(-1, 5), Point(-5, -10))
s3 = Segment(Point(0, 4), Point(-2, 2))
assert intersection(r1, s1) == [Segment(Point(1, 1), Point(2, 2))]
assert r1.projection(s2) == Segment(Point(1, 1), Point(2, 2))
assert s3.projection(r1) == Segment(Point(0, 4), Point(-1, 3))
l1 = Line(Point(0, 0), Point(3, 4))
r1 = Ray(Point(0, 0), Point(3, 4))
s1 = Segment(Point(0, 0), Point(3, 4))
assert intersection(l1, l1) == [l1]
assert intersection(l1, r1) == [r1]
assert intersection(l1, s1) == [s1]
assert intersection(r1, l1) == [r1]
assert intersection(s1, l1) == [s1]
entity1 = Segment(Point(-10, 10), Point(10, 10))
entity2 = Segment(Point(-5, -5), Point(-5, 5))
assert intersection(entity1, entity2) == []
r1 = Ray(p1, Point(0, 1))
r2 = Ray(Point(0, 1), p1)
r3 = Ray(p1, p2)
r4 = Ray(p2, p1)
s1 = Segment(p1, Point(0, 1))
assert Line(r1.source, r1.random_point()).slope == r1.slope
assert Line(r2.source, r2.random_point()).slope == r2.slope
assert Segment(Point(0, -1), s1.random_point()).slope == s1.slope
p_r3 = r3.random_point()
p_r4 = r4.random_point()
assert p_r3.x >= p1.x and p_r3.y >= p1.y
assert p_r4.x <= p2.x and p_r4.y <= p2.y
p10 = Point(2000, 2000)
s1 = Segment(p1, p10)
p_s1 = s1.random_point()
assert p1.x <= p_s1.x and p_s1.x <= p10.x and \
p1.y <= p_s1.y and p_s1.y <= p10.y
s2 = Segment(p10, p1)
assert hash(s1) == hash(s2)
p11 = p10.scale(2, 2)
assert s1.is_similar(Segment(p10, p11))
assert s1.is_similar(r1) is False
assert (r1 in s1) is False
assert Segment(p1, p2) in s1
assert s1.plot_interval() == [t, 0, 1]
assert s1 in Line(p1, p10)
assert Line(p1, p10) != Line(p10, p1)
assert Line(p1, p10) != p1
assert Line(p1, p10).plot_interval() == [t, -5, 5]
assert Ray((0, 0), angle=pi/4).plot_interval() == \
[t, 0, 10]
p1, p2 = Point(0, 0), Point(4, 1)
r1 = Ray(p1, p2)
assert r1.direction == p2
p1, p2, p3 = Point(0, 0), Point(-1, -1), Point(-1, 0)
r1, r2 = Ray(p1, p2), Ray(p1, p3)
assert r1.ydirection == -oo
assert r2.ydirection == 0
p1, p2, p3 = Point(0, 0), Point(6, 6), Point(5, 1)
s1 = Segment(p1, p2)
assert s1.perpendicular_bisector() == Line(Point(3, 3), Point(9, -3))
assert s1.perpendicular_bisector(p3) == Segment(Point(3, 3), Point(5, 1))
def test_normality():
X, Y = Normal('X', 0, 1), Normal('Y', 0, 1)
x, z = symbols('x, z', real=True)
dens = density(X - Y, Eq(X + Y, z))
assert integrate(dens(x), (x, -oo, oo)) == 1
def test_ceiling():
x = Symbol('x')
i = Symbol('i', imaginary=True)
y = Symbol('y', extended_real=True)
k, n = symbols('k,n', integer=True)
assert ceiling(nan) == nan
assert ceiling(oo) == oo
assert ceiling(-oo) == -oo
assert ceiling(0) == 0
assert ceiling(1) == 1
assert ceiling(-1) == -1
assert ceiling(E) == 3
assert ceiling(-E) == -2
assert ceiling(2 * E) == 6
assert ceiling(-2 * E) == -5
assert ceiling(pi) == 4
assert ceiling(-pi) == -3
assert ceiling(Rational(1, 2)) == 1
assert ceiling(-Rational(1, 2)) == 0
assert ceiling(Rational(7, 3)) == 3
assert ceiling(-Rational(7, 3)) == -2
assert ceiling(Float(17.0)) == 17
assert ceiling(-Float(17.0)) == -17
assert ceiling(Float(7.69)) == 8
assert ceiling(-Float(7.69)) == -7
assert ceiling(I) == I
assert ceiling(-I) == -I
e = ceiling(i)
assert e.func is ceiling and e.args[0] == i
assert ceiling(oo * I) == oo * I
assert ceiling(-oo * I) == -oo * I
assert ceiling(2 * I) == 2 * I
assert ceiling(-2 * I) == -2 * I
assert ceiling(I / 2) == I
assert ceiling(-I / 2) == 0
assert ceiling(E + 17) == 20
assert ceiling(pi + 2) == 6
assert ceiling(E + pi) == ceiling(E + pi)
assert ceiling(I + pi) == ceiling(I + pi)
assert ceiling(ceiling(pi)) == 4
assert ceiling(ceiling(y)) == ceiling(y)
assert ceiling(ceiling(x)) == ceiling(ceiling(x))
assert ceiling(x) == ceiling(x)
assert ceiling(2 * x) == ceiling(2 * x)
assert ceiling(k * x) == ceiling(k * x)
assert ceiling(k) == k
assert ceiling(2 * k) == 2 * k
assert ceiling(k * n) == k * n
assert ceiling(k / 2) == ceiling(k / 2)
assert ceiling(x + y) == ceiling(x + y)
assert ceiling(x + 3) == ceiling(x + 3)
assert ceiling(x + k) == ceiling(x + k)
assert ceiling(y + 3) == ceiling(y) + 3
assert ceiling(y + k) == ceiling(y) + k
assert ceiling(3 + pi + y * I) == 7 + ceiling(y) * I
assert ceiling(k + n) == k + n
assert ceiling(x * I) == ceiling(x * I)
assert ceiling(k * I) == k * I
assert ceiling(Rational(23, 10) - E * I) == 3 - 2 * I
assert ceiling(sin(1)) == 1
assert ceiling(sin(-1)) == 0
assert ceiling(exp(2)) == 8
assert ceiling(-log(8) / log(2)) != -2
assert int(ceiling(-log(8) / log(2)).evalf(chop=True)) == -3
assert ceiling(factorial(50)/exp(1)) == \
11188719610782480504630258070757734324011354208865721592720336801
assert (ceiling(y) >= y) is S.true
assert (ceiling(y) < y) is S.false
assert (ceiling(x) >= x).is_Relational # x could be non-real
assert (ceiling(x) < x).is_Relational
assert (ceiling(x) >= y).is_Relational # arg is not same as rhs
assert (ceiling(x) < y).is_Relational
def test_sympyissue_10161():
x = symbols('x', real=True)
h = (2 * x * (-2 * x + Abs(x)) * (x**2 - 1) / Abs(x**2 - 1) +
(x / Abs(x) - 2) * Abs(x**2 - 1))
assert (h - factor(h)).simplify() == 0
"""Tests for tools for manipulation of rational expressions. """
from diofant.polys.rationaltools import together
from diofant import S, symbols, Rational, sin, exp, Eq, Integral, Mul
from diofant.abc import x, y, z
__all__ = ()
A, B = symbols('A,B', commutative=False)
def test_together():
assert together(0) == 0
assert together(1) == 1
assert together(x * y * z) == x * y * z
assert together(x + y) == x + y
assert together(1 / x) == 1 / x
assert together(1 / x + 1) == (x + 1) / x
assert together(1 / x + 3) == (3 * x + 1) / x
assert together(1 / x + x) == (x**2 + 1) / x
assert together((1 / x + 1, 1 / x + 3)) == ((x + 1) / x, (3 * x + 1) / x)
assert together(1 / x + Rational(1, 2)) == (x + 2) / (2 * x)
assert together(Rational(1, 2) + x / 2) == Mul(S.Half,
x + 1,
evaluate=False)
from diofant import (And, Eq, Integer, Piecewise, Sum, exp, oo, piecewise_fold,
symbols)
from diofant.concrete.delta import deltaproduct as dp
from diofant.concrete.delta import deltasummation as ds
from diofant.functions import KroneckerDelta as Kd
__all__ = ()
i, j, k, l, m = symbols('i j k l m', integer=True, finite=True)
x, y = symbols('x y', commutative=False)
def test_deltaproduct_trivial():
assert dp(x, (j, 1, 0)) == 1
assert dp(x, (j, 1, 3)) == x**3
assert dp(x + y, (j, 1, 3)) == (x + y)**3
assert dp(x * y, (j, 1, 3)) == (x * y)**3
assert dp(Kd(i, j), (k, 1, 3)) == Kd(i, j)
assert dp(x * Kd(i, j), (k, 1, 3)) == x**3 * Kd(i, j)
assert dp(x * y * Kd(i, j), (k, 1, 3)) == (x * y)**3 * Kd(i, j)
def test_deltaproduct_basic():
assert dp(Kd(i, j), (j, 1, 3)) == 0
assert dp(Kd(i, j), (j, 1, 1)) == Kd(i, 1)
assert dp(Kd(i, j), (j, 2, 2)) == Kd(i, 2)
assert dp(Kd(i, j), (j, 3, 3)) == Kd(i, 3)
assert dp(Kd(i, j), (j, 1, k)) == Kd(i, 1) * Kd(k, 1) + Kd(k, 0)
assert dp(Kd(i, j), (j, k, 3)) == Kd(i, 3) * Kd(k, 3) + Kd(k, 4)
assert dp(Kd(i, j), (j, k, l)) == Kd(i, l) * Kd(k, l) + Kd(k, l + 1)
assert dp(Kd(i, 1), (i, j**2, k**2)) == (Kd(1, j**2) * Kd(j**2, k**2) +
def test_sympyissue_from_PR1599():
n1, n2, n3, n4 = symbols('n1 n2 n3 n4', negative=True)
assert simplify(I*sqrt(n1)) == -sqrt(-n1)
def test_sin():
x, y = symbols('x y')
assert sin.nargs == FiniteSet(1)
assert sin(nan) == nan
assert sin(oo*I) == oo*I
assert sin(-oo*I) == -oo*I
assert sin(oo).args[0] == oo
assert sin(0) == 0
assert sin(asin(x)) == x
assert sin(atan(x)) == x / sqrt(1 + x**2)
assert sin(acos(x)) == sqrt(1 - x**2)
assert sin(acot(x)) == 1 / (sqrt(1 + 1 / x**2) * x)
assert sin(atan2(y, x)) == y / sqrt(x**2 + y**2)
assert sin(pi*I) == sinh(pi)*I
assert sin(-pi*I) == -sinh(pi)*I
assert sin(-2*I) == -sinh(2)*I
assert sin(pi) == 0
assert sin(-pi) == 0
assert sin(2*pi) == 0
assert sin(-2*pi) == 0
assert sin(-3*10**73*pi) == 0
assert sin(7*10**103*pi) == 0
assert sin(pi/2) == 1
assert sin(-pi/2) == -1
assert sin(5*pi/2) == 1
assert sin(7*pi/2) == -1
ne = symbols('ne', integer=True, even=False)
e = symbols('e', even=True)
assert sin(pi*ne/2) == (-1)**(ne/2 - Rational(1, 2))
assert sin(pi*k/2).func == sin
assert sin(pi*e/2) == 0
assert sin(pi*k) == 0
assert sin(pi*k).subs({k: 3}) == sin(pi*k/2).subs({k: 6}) # issue sympy/sympy#8298
assert sin(pi/2*cos(k*pi)) == (-1)**k
assert sin(pi/3) == sqrt(3)/2
assert sin(-2*pi/3) == -sqrt(3)/2
assert sin(pi/4) == sqrt(2)/2
assert sin(-pi/4) == -sqrt(2)/2
assert sin(17*pi/4) == sqrt(2)/2
assert sin(-3*pi/4) == -sqrt(2)/2
assert sin(pi/6) == Rational(1, 2)
assert sin(-pi/6) == Rational(-1, 2)
assert sin(7*pi/6) == Rational(-1, 2)
assert sin(-5*pi/6) == Rational(-1, 2)
assert sin(1*pi/5) == sqrt((5 - sqrt(5)) / 8)
assert sin(2*pi/5) == sqrt((5 + sqrt(5)) / 8)
assert sin(3*pi/5) == sin(2*pi/5)
assert sin(4*pi/5) == sin(1*pi/5)
assert sin(6*pi/5) == -sin(1*pi/5)
assert sin(8*pi/5) == -sin(2*pi/5)
assert sin(-1273*pi/5) == -sin(2*pi/5)
assert sin(pi/8) == sqrt((2 - sqrt(2))/4)
assert sin(pi/10) == -Rational(1, 4) + sqrt(5)/4
assert sin(pi/12) == -sqrt(2)/4 + sqrt(6)/4
assert sin(5*pi/12) == sqrt(2)/4 + sqrt(6)/4
assert sin(-7*pi/12) == -sqrt(2)/4 - sqrt(6)/4
assert sin(-11*pi/12) == sqrt(2)/4 - sqrt(6)/4
assert sin(104*pi/105) == sin(pi/105)
assert sin(106*pi/105) == -sin(pi/105)
assert sin(-104*pi/105) == -sin(pi/105)
assert sin(-106*pi/105) == sin(pi/105)
assert sin(x*I) == sinh(x)*I
assert sin(k*pi) == 0
assert sin(17*k*pi) == 0
assert sin(k*pi*I) == sinh(k*pi)*I
assert sin(r).is_real
assert sin(c).is_complex
assert sin(0, evaluate=False).is_algebraic
assert sin(a).is_algebraic is None
assert sin(na).is_algebraic is False
q = Symbol('q', rational=True)
assert sin(pi*q).is_algebraic
qz = Symbol('qz', zero=True)
qn = Symbol('qn', rational=True, nonzero=True)
assert sin(qz).is_rational
assert sin(0, evaluate=False).is_rational
assert sin(qn).is_rational is False
assert sin(q).is_rational is None # issue sympy/sympy#8653
assert isinstance(sin( re(x) - im(y)), sin) is True
assert isinstance(sin(-re(x) + im(y)), sin) is False
for d in list(range(1, 22)) + [60, 85]:
for n in range(d*2 + 1):
x = n*pi/d
e = abs( float(sin(x)) - sin(float(x)) )
assert e < 1e-12
assert sin(z).taylor_term(3, z, *(z, 0)) == -z**3/6
def test_sympyissue_5652():
assert simplify(E + exp(-E)) == exp(-E) + E
n = symbols('n', commutative=False)
assert simplify(n + n**(-n)) == n + n**(-n)
def test_csc():
x = symbols('x', extended_real=True)
z = symbols('z')
# https://github.com/sympy/sympy/issues/6707
cosecant = csc('x')
alternate = 1/sin('x')
assert cosecant.equals(alternate)
assert alternate.equals(cosecant)
assert csc.nargs == FiniteSet(1)
assert csc(0) == zoo
assert csc(pi) == zoo
assert csc(pi/2) == 1
assert csc(-pi/2) == -1
assert csc(pi/6) == 2
assert csc(pi/3) == 2*sqrt(3)/3
assert csc(5*pi/2) == 1
assert csc(9*pi/7) == -csc(2*pi/7)
assert csc(3*pi/4) == sqrt(2) # issue sympy/sympy#8421
assert csc(I) == -I*csch(1)
assert csc(x*I) == -I*csch(x)
assert csc(-x) == -csc(x)
assert csc(acsc(x)) == x
assert csc(x).rewrite(exp) == 2*I/(exp(I*x) - exp(-I*x))
assert csc(x).rewrite(sin) == 1/sin(x)
assert csc(x).rewrite(cos) == csc(x)
assert csc(x).rewrite(tan) == (tan(x/2)**2 + 1)/(2*tan(x/2))
assert csc(x).rewrite(cot) == (cot(x/2)**2 + 1)/(2*cot(x/2))
assert csc(z).conjugate() == csc(conjugate(z))
assert (csc(z).as_real_imag() ==
(sin(re(z))*cosh(im(z))/(sin(re(z))**2*cosh(im(z))**2 +
cos(re(z))**2*sinh(im(z))**2),
-cos(re(z))*sinh(im(z))/(sin(re(z))**2*cosh(im(z))**2 +
cos(re(z))**2*sinh(im(z))**2)))
assert csc(x).expand(trig=True) == 1/sin(x)
assert csc(2*x).expand(trig=True) == 1/(2*sin(x)*cos(x))
assert csc(a).is_algebraic is None
assert csc(na).is_algebraic is False
assert csc(x).as_leading_term() == csc(x)
assert csc(0).is_finite is False
assert csc(x).is_finite is None
assert csc(pi/2).is_finite
assert series(csc(x), x, x0=pi/2, n=6) == \
1 + (x - pi/2)**2/2 + 5*(x - pi/2)**4/24 + O((x - pi/2)**6, (x, pi/2))
assert series(csc(x), x, x0=0, n=6) == \
1/x + x/6 + 7*x**3/360 + 31*x**5/15120 + O(x**6)
assert csc(x).diff(x) == -cot(x)*csc(x)
assert csc(x).taylor_term(0, x) == 1/x
assert csc(x).taylor_term(2, x) == 0
assert csc(x).taylor_term(3, x) == 7*x**3/360
assert csc(x).taylor_term(5, x) == 31*x**5/15120
pytest.raises(ArgumentIndexError, lambda: csc(x).fdiff(2))
def test_trace_new():
a, b, c, d = symbols('a b c d')
A, B, C, D = symbols('A B C D', commutative=False)
assert Tr(a + b) == a + b
assert Tr(A + B) == Tr(A) + Tr(B)
# check trace args not implicitly permuted
assert Tr(C * D * A * B).args[0].args == (C, D, A, B)
# check for mul and adds
assert Tr((a * b) + (c * d)) == (a * b) + (c * d)
# Tr(scalar*A) = scalar*Tr(A)
assert Tr(a * A) == a * Tr(A)
assert Tr(a * A * B * b) == a * b * Tr(A * B)
# since A is symbol and not commutative
assert isinstance(Tr(A), Tr)
# POW
assert Tr(pow(a, b)) == a**b
assert isinstance(Tr(pow(A, a)), Tr)
# Matrix
M = Matrix([[1, 1], [2, 2]])
assert Tr(M) == 3
# test indices in different forms
# no index
t = Tr(A)
assert t.args[1] == Tuple()
# single index
t = Tr(A, 0)
assert t.args[1] == Tuple(0)
# index in a list
t = Tr(A, [0])
assert t.args[1] == Tuple(0)
t = Tr(A, [0, 1, 2])
assert t.args[1] == Tuple(0, 1, 2)
# index is tuple
t = Tr(A, (0))
assert t.args[1] == Tuple(0)
t = Tr(A, (1, 2))
assert t.args[1] == Tuple(1, 2)
# trace indices test
t = Tr((A + B), [2])
assert t.args[0].args[1] == Tuple(2) and t.args[1].args[1] == Tuple(2)
t = Tr(a * A, [2, 3])
assert t.args[1].args[1] == Tuple(2, 3)
# class with trace method defined
# to simulate numpy objects
class Foo:
def trace(self):
return 1
assert Tr(Foo()) == 1
# argument test
# check for value error, when either/both arguments are not provided
pytest.raises(ValueError, Tr)
pytest.raises(ValueError, lambda: Tr(A, 1, 2))
# non-Expr objects
assert isinstance(Tr(None), Tr)
from diofant import sin, cos, exp, cot, I, symbols, Pow
x, y, z, n = symbols('x,y,z,n')
__all__ = ()
def test_has():
assert cot(x).has(x)
assert cot(x).has(cot)
assert not cot(x).has(sin)
assert sin(x).has(x)
assert sin(x).has(sin)
assert not sin(x).has(cot)
def test_sin_exp_rewrite():
assert sin(x).rewrite(sin, exp) == -I / 2 * (exp(I * x) - exp(-I * x))
assert sin(x).rewrite(sin, exp).rewrite(Pow, sin) == sin(x)
assert cos(x).rewrite(cos, exp).rewrite(Pow, cos) == cos(x)
assert (sin(5 * y) - sin(2 * x)).rewrite(sin, exp).rewrite(
Pow, sin) == sin(5 * y) - sin(2 * x)
assert sin(x + y).rewrite(sin, exp).rewrite(Pow, sin) == sin(x + y)
assert cos(x + y).rewrite(cos, exp).rewrite(Pow, cos) == cos(x + y)
# This next test currently passes... not clear whether it should or not?
assert cos(x).rewrite(cos, exp).rewrite(Pow, sin) == cos(x)
import pytest
from diofant import (BlockMatrix, Identity, ImmutableMatrix, MatPow,
MatrixSymbol, Sum, ZeroMatrix, eye, symbols)
__all__ = ()
i, j, k, l, m, n = symbols('i j k l m n', integer=True)
W = MatrixSymbol('W', k, l)
X = MatrixSymbol('X', l, m)
Y = MatrixSymbol('Y', l, m)
Z = MatrixSymbol('Z', m, n)
A = MatrixSymbol('A', 2, 2)
B = MatrixSymbol('B', 2, 2)
x = MatrixSymbol('x', 1, 2)
y = MatrixSymbol('x', 2, 1)
def test_symbolic_indexing():
x12 = X[1, 2]
assert all(s in str(x12) for s in ['1', '2', X.name])
# We don't care about the exact form of this. We do want to make sure
# that all of these features are present
def test_add_index():
assert (X + Y)[i, j] == X[i, j] + Y[i, j]
def test_evalf_symbolic():
f, g = symbols('f g', cls=Function)
# issue sympy/sympy#6328
expr = Sum(f(x), (x, 1, 3)) + Sum(g(x), (x, 1, 3))
assert expr.evalf(strict=False) == expr
def test_sympyissue_11407():
a, b, c = symbols('a, b, c')
assert sqrt(a + b + c * x).series(x, 0, 1) == sqrt(a + b) + O(x)
assert sqrt(a + b + c + c * x).series(x, 0, 1) == sqrt(a + b + c) + O(x)
def test_conjugate_transpose():
A, B = symbols('A B', commutative=False)
p = Sum(A*B**n, (n, 1, 3))
assert p.adjoint().doit() == p.doit().adjoint()
assert p.conjugate().doit() == p.doit().conjugate()
assert p.transpose().doit() == p.doit().transpose()
def test_exp_product_positive_factors():
a, b = symbols('a, b', positive=True)
x = a * b
assert series(exp(x), x, n=8) == 1 + a*b + a**2*b**2/2 + \
a**3*b**3/6 + a**4*b**4/24 + a**5*b**5/120 + a**6*b**6/720 + \
a**7*b**7/5040 + O(a**8*b**8)
