def test_sanitize_assumptions():
# issue sympy/sympy#6666
for cls in (Symbol, Dummy, Wild):
x = cls('x', extended_real=1, positive=0)
assert x.is_extended_real is True
assert x.is_positive is False
assert cls('', extended_real=True, positive=None).is_positive is None
pytest.raises(ValueError, lambda: cls('', commutative=None))
pytest.raises(ValueError, lambda: Symbol._sanitize({'commutative': None}))
def test_sympyissue_3449():
# test if powers are simplified correctly
# see also issue sympy/sympy#3995
x = Symbol('x')
assert ((x**Rational(1, 3))**Rational(2)) == x**Rational(2, 3)
assert (
(x**Rational(3))**Rational(2, 5)) == (x**Rational(3))**Rational(2, 5)
a = Symbol('a', extended_real=True)
b = Symbol('b', extended_real=True)
assert (a**2)**b == (abs(a)**b)**2
assert sqrt(1/a) != 1/sqrt(a) # e.g. for a = -1
assert (a**3)**Rational(1, 3) != a
assert (x**a)**b != x**(a*b) # e.g. x = -1, a=2, b=1/2
assert (x**.5)**b == x**(.5*b)
assert (x**.5)**.5 == x**.25
assert (x**2.5)**.5 != x**1.25 # e.g. for x = 5*I
k = Symbol('k', integer=True)
m = Symbol('m', integer=True)
assert (x**k)**m == x**(k*m)
assert Number(5)**Rational(2, 3) == Number(25)**Rational(1, 3)
assert (x**.5)**2 == x**1.0
assert (x**2)**k == (x**k)**2 == x**(2*k)
a = Symbol('a', positive=True)
assert (a**3)**Rational(2, 5) == a**Rational(6, 5)
assert (a**2)**b == (a**b)**2
assert (a**Rational(2, 3))**x == (a**(2*x/3)) != (a**x)**Rational(2, 3)
def test_Add_is_pos_neg():
# these cover lines not covered by the rest of tests in core
n = Symbol('n', negative=True, infinite=True)
nn = Symbol('n', nonnegative=True, infinite=True)
np = Symbol('n', nonpositive=True, infinite=True)
p = Symbol('p', positive=True, infinite=True)
r = Dummy(extended_real=True, finite=False)
x = Symbol('x')
xf = Symbol('xb', finite=True, real=True)
assert (n + p).is_positive is None
assert (n + x).is_positive is None
assert (p + x).is_positive is None
assert (n + p).is_negative is None
assert (n + x).is_negative is None
assert (p + x).is_negative is None
assert (n + xf).is_positive is False
assert (p + xf).is_positive is True
assert (n + xf).is_negative is True
assert (p + xf).is_negative is False
assert (x - S.Infinity).is_negative is None # issue sympy/sympy#7798
# issue sympy/sympy#8046, 16.2
assert (p + nn).is_positive
assert (n + np).is_negative
assert (p + r).is_positive is None
def test_sympyissue_6068():
x = Symbol('x')
assert sqrt(sin(x)).series(x, 0, 8) == \
sqrt(x) - x**Rational(5, 2)/12 + x**Rational(9, 2)/1440 - \
x**Rational(13, 2)/24192 + O(x**8)
assert sqrt(sin(x)).series(x, 0, 10) == \
sqrt(x) - x**Rational(5, 2)/12 + x**Rational(9, 2)/1440 - \
x**Rational(13, 2)/24192 - 67*x**Rational(17, 2)/29030400 + O(x**10)
assert sqrt(sin(x**3)).series(x, 0, 19) == \
x**Rational(3, 2) - x**Rational(15, 2)/12 + x**Rational(27, 2)/1440 + O(x**19)
assert sqrt(sin(x**3)).series(x, 0, 20) == \
x**Rational(3, 2) - x**Rational(15, 2)/12 + x**Rational(27, 2)/1440 - \
x**Rational(39, 2)/24192 + O(x**20)
def test_canonicalize3():
D = Symbol('D')
Spinor = TensorIndexType('Spinor', dim=D, metric=True, dummy_fmt='S')
a0, a1, a2, a3, a4 = tensor_indices('a0:5', Spinor)
chi, psi = tensorhead('chi,psi', [Spinor], [[1]], 1)
t = chi(a1) * psi(a0)
t1 = t.canon_bp()
assert t1 == t
t = psi(a1) * chi(a0)
t1 = t.canon_bp()
assert t1 == -chi(a0) * psi(a1)
def fateman_poly_F_3(n):
"""Fateman's GCD benchmark: sparse inputs (deg f ~ vars f) """
Y = [Symbol('y_' + str(i)) for i in range(0, n + 1)]
y_0 = Y[0]
u = Add(*[y**(n + 1) for y in Y[1:]])
H = Poly((y_0**(n + 1) + u + 1)**2, *Y)
F = Poly((y_0**(n + 1) - u - 2)**2, *Y)
G = Poly((y_0**(n + 1) + u + 2)**2, *Y)
return H * F, H * G, H
def fateman_poly_F_2(n):
"""Fateman's GCD benchmark: linearly dense quartic inputs """
Y = [Symbol('y_' + str(i)) for i in range(0, n + 1)]
y_0 = Y[0]
u = Add(*[y for y in Y[1:]])
H = Poly((y_0 + u + 1)**2, *Y)
F = Poly((y_0 - u - 2)**2, *Y)
G = Poly((y_0 + u + 2)**2, *Y)
return H * F, H * G, H
def __new__(cls, label, shape=None, **kw_args):
if isinstance(label, str):
label = Symbol(label)
elif isinstance(label, (Dummy, Symbol)):
pass
else:
raise TypeError("Base label should be a string or Symbol.")
obj = Expr.__new__(cls, label, **kw_args)
if is_sequence(shape):
obj._shape = Tuple(*shape)
else:
obj._shape = sympify(shape)
return obj
def test_specfun():
n = Symbol('n')
for f in [besselj, bessely, besseli, besselk]:
assert octave_code(f(n, x)) == f.__name__ + '(n, x)'
assert octave_code(hankel1(n, x)) == 'besselh(n, 1, x)'
assert octave_code(hankel2(n, x)) == 'besselh(n, 2, x)'
assert octave_code(airyai(x)) == 'airy(0, x)'
assert octave_code(airyaiprime(x)) == 'airy(1, x)'
assert octave_code(airybi(x)) == 'airy(2, x)'
assert octave_code(airybiprime(x)) == 'airy(3, x)'
assert octave_code(jn(
n, x)) == 'sqrt(2)*sqrt(pi)*sqrt(1./x).*besselj(n + 1/2, x)/2'
assert octave_code(yn(
n, x)) == 'sqrt(2)*sqrt(pi)*sqrt(1./x).*bessely(n + 1/2, x)/2'
def fateman_poly_F_1(n):
"""Fateman's GCD benchmark: trivial GCD """
Y = [Symbol('y_' + str(i)) for i in range(0, n + 1)]
y_0, y_1 = Y[0], Y[1]
u = y_0 + Add(*[y for y in Y[1:]])
v = y_0**2 + Add(*[y**2 for y in Y[1:]])
F = ((u + 1) * (u + 2)).as_poly(*Y)
G = ((v + 1) * (-3 * y_1 * y_0**2 + y_1**2 - 1)).as_poly(*Y)
H = Poly(1, *Y)
return F, G, H
def test_special_is_rational():
i = Symbol('i', integer=True)
i2 = Symbol('i2', integer=True)
ni = Symbol('ni', integer=True, nonzero=True)
r = Symbol('r', rational=True)
rn = Symbol('r', rational=True, nonzero=True)
nr = Symbol('nr', irrational=True)
x = Symbol('x')
assert sqrt(3).is_rational is False
assert (3 + sqrt(3)).is_rational is False
assert (3 * sqrt(3)).is_rational is False
z = Symbol('z', zero=True)
assert exp(z).is_rational
assert exp(0, evaluate=False).is_rational
assert exp(3).is_rational is False
assert exp(ni).is_rational is False
assert exp(rn).is_rational is False
assert exp(x).is_rational is None
assert exp(log(3), evaluate=False).is_rational is True
assert log(exp(3), evaluate=False).is_rational is True
assert log(3).is_rational is False
assert log(ni + 1).is_rational is False
assert log(rn + 1).is_rational is False
assert log(x).is_rational is None
assert (sqrt(3) + sqrt(5)).is_rational is None
assert (sqrt(3) + S.Pi).is_rational is False
assert (x**i).is_rational is None
assert (i**i).is_rational is True
assert (i**i2).is_rational is None
assert (r**i).is_rational is None
assert (r**r).is_rational is None
assert (r**x).is_rational is None
assert (nr**i).is_rational is None # issue sympy/sympy#8598
assert (nr**Symbol('z', zero=True)).is_rational
assert sin(1).is_rational is False
assert sin(ni).is_rational is False
assert sin(rn).is_rational is False
assert sin(x).is_rational is None
assert asin(rn).is_rational is False
assert sin(asin(3), evaluate=False).is_rational is True
def test_TensorIndexType():
D = Symbol('D')
G = Metric('g', False)
Lorentz = TensorIndexType('Lorentz', metric=G, dim=D, dummy_fmt='L')
m0, m1, m2, m3, m4 = tensor_indices('m0:5', Lorentz)
sym2 = tensorsymmetry([1] * 2)
sym2n = tensorsymmetry(*get_symmetric_group_sgs(2))
assert sym2 == sym2n
g = Lorentz.metric
assert str(g) == 'g(Lorentz,Lorentz)'
assert Lorentz.eps_dim == Lorentz.dim
TSpace = TensorIndexType('TSpace')
i0, i1 = tensor_indices('i0 i1', TSpace)
g = TSpace.metric
A = tensorhead('A', [TSpace] * 2, [[1] * 2])
assert str(A(i0, -i0).canon_bp()) == 'A(TSpace_0, -TSpace_0)'
def test_schwarzschild():
m = Manifold('Schwarzschild', 4)
p = Patch('origin', m)
cs = CoordSystem('spherical', p, ['t', 'r', 'theta', 'phi'])
t, r, theta, phi = cs.coord_functions()
dt, dr, dtheta, dphi = cs.base_oneforms()
f, g = symbols('f g', cls=Function)
metric = (exp(2*f(r))*TP(dt, dt) - exp(2*g(r))*TP(dr, dr) -
r**2*TP(dtheta, dtheta) - r**2*sin(theta)**2*TP(dphi, dphi))
ricci = metric_to_Ricci_components(metric)
assert all(ricci[i, j] == 0 for i in range(4) for j in range(4) if i != j)
R = Symbol('R')
eq1 = simplify((ricci[0, 0]/exp(2*f(r) - 2*g(r)) +
ricci[1, 1])*r/2).subs(r, R).doit()
assert eq1 == f(R).diff(R) + g(R).diff(R)
eq2 = simplify(ricci[1, 1].replace(g, lambda x: -f(x)).replace(r, R).doit())
assert eq2 == -2*f(R).diff(R)**2 - f(R).diff(R, 2) - 2*f(R).diff(R)/R
def test_Mul_is_algebraic():
a = Symbol('a', algebraic=True)
b = Symbol('a', algebraic=True)
na = Symbol('na', algebraic=False)
an = Symbol('an', algebraic=True, nonzero=True)
nb = Symbol('nb', algebraic=False)
x = Symbol('x')
assert (a * b).is_algebraic
assert (na * nb).is_algebraic is None
assert (a * na).is_algebraic is None
assert (an * na).is_algebraic is False
assert (a * x).is_algebraic is None
assert (na * x).is_algebraic is None
def test_contract_metric1():
D = Symbol('D')
Lorentz = TensorIndexType('Lorentz', dim=D, dummy_fmt='L')
a, b, c, d, e = tensor_indices('a,b,c,d,e', Lorentz)
g = Lorentz.metric
p = tensorhead('p', [Lorentz], [[1]])
t = g(a, b) * p(-b)
t1 = t.contract_metric(g)
assert t1 == p(a)
A, B = tensorhead('A,B', [Lorentz] * 2, [[1] * 2])
# case with g with all free indices
t1 = A(a, b) * B(-b, c) * g(d, e)
t2 = t1.contract_metric(g)
assert t1 == t2
# case of g(d, -d)
t1 = A(a, b) * B(-b, c) * g(-d, d)
t2 = t1.contract_metric(g)
assert t2 == D * A(a, d) * B(-d, c)
# g with one free index
t1 = A(a, b) * B(-b, -c) * g(c, d)
t2 = t1.contract_metric(g)
assert t2 == A(a, c) * B(-c, d)
# g with both indices contracted with another tensor
t1 = A(a, b) * B(-b, -c) * g(c, -a)
t2 = t1.contract_metric(g)
assert _is_equal(t2, A(a, b) * B(-b, -a))
t1 = A(a, b) * B(-b, -c) * g(c, d) * g(-a, -d)
t2 = t1.contract_metric(g)
assert _is_equal(t2, A(a, b) * B(-b, -a))
t1 = A(a, b) * g(-a, -b)
t2 = t1.contract_metric(g)
assert _is_equal(t2, A(a, -a))
assert not t2.free
Lorentz = TensorIndexType('Lorentz', dummy_fmt='L')
a, b = tensor_indices('a,b', Lorentz)
g = Lorentz.metric
pytest.raises(ValueError, lambda: g(a, -a).contract_metric(g)) # no dim
def test_Max():
n = Symbol('n', negative=True)
n_ = Symbol('n_', negative=True)
p = Symbol('p', positive=True)
r = Symbol('r', extended_real=True)
assert Max(5, 4) == 5
# lists
pytest.raises(ValueError, lambda: Max())
assert Max(x, y) == Max(y, x)
assert Max(x, y, z) == Max(z, y, x)
assert Max(x, Max(y, z)) == Max(z, y, x)
assert Max(x, Min(y, oo)) == Max(x, y)
assert Max(n, -oo, n_, p, 2) == Max(p, 2)
assert Max(n, -oo, n_, p) == p
assert Max(2, x, p, n, -oo, -oo, n_, p, 2) == Max(2, x, p)
assert Max(0, x, 1, y) == Max(1, x, y)
assert Max(r, r + 1, r - 1) == 1 + r
assert Max(1000, 100, -100, x, p, n) == Max(p, x, 1000)
assert Max(cos(x), sin(x)) == Max(sin(x), cos(x))
assert Max(cos(x), sin(x)).subs({x: 1}) == sin(1)
assert Max(cos(x), sin(x)).subs({x: Rational(1, 2)}) == cos(Rational(1, 2))
pytest.raises(ValueError, lambda: Max(cos(x), sin(x)).subs({x: I}))
pytest.raises(ValueError, lambda: Max(I))
pytest.raises(ValueError, lambda: Max(I, x))
pytest.raises(ValueError, lambda: Max(zoo, 1))
# interesting:
# Max(n, -oo, n_, p, 2) == Max(p, 2)
# True
# Max(n, -oo, n_, p, 1000) == Max(p, 1000)
# False
assert Max(1, x).diff(x) == Heaviside(x - 1)
assert Max(x, 1).diff(x) == Heaviside(x - 1)
assert Max(x**2, 1 + x, 1).diff(x) == \
2*x*Heaviside(x**2 - Max(1, x + 1)) \
+ Heaviside(x - Max(1, x**2) + 1)
pytest.raises(ArgumentIndexError, lambda: Max(1, x).fdiff(3))
a, b = Symbol('a', extended_real=True), Symbol('b', extended_real=True)
# a and b are both real, Max(a, b) should be real
assert Max(a, b).is_extended_real
# issue sympy/sympy#7233
e = Max(0, x)
assert e.evalf == e.n
assert e.evalf(strict=False).args == (0, x)
def test_diofant_parser():
x = Symbol('x')
inputs = {
'2*x': 2 * x,
'3.00': Float(3),
'22/7': Rational(22, 7),
'2+3j': 2 + 3*I,
'exp(x)': exp(x),
'-(2)': -Integer(2),
'[-1, -2, 3]': [Integer(-1), Integer(-2), Integer(3)],
'Symbol("x").free_symbols': x.free_symbols,
"Float(Integer(3).evalf(3))": 3.00,
'factorint(12, visual=True)': Mul(
Pow(2, 2, evaluate=False),
Pow(3, 1, evaluate=False),
evaluate=False),
'Limit(sin(x), x, 0, dir="-")': Limit(sin(x), x, 0, dir='-'),
}
for text, result in inputs.items():
assert parse_expr(text) == result
def test_sympyissue_11799():
n = 2
M = Manifold('M', n)
P = Patch('P', M)
coord = CoordSystem('coord', P, ['x%s' % i for i in range(n)])
x = coord.coord_functions()
dx = coord.base_oneforms()
f = Function('f')
g = [[f(x[0], x[1])**2, 0], [0, f(x[0], x[1])**2]]
metric = sum(g[i][j]*TP(dx[i], dx[j]) for i in range(n) for j in range(n))
R = metric_to_Riemann_components(metric)
d = Symbol('d')
assert (R[0, 1, 0, 1] ==
-Subs(Derivative(f(d, x[1]), d, d), (d, x[0]))/f(x[0], x[1]) -
Subs(Derivative(f(x[0], d), d, d), (d, x[1]))/f(x[0], x[1]) +
Subs(Derivative(f(d, x[1]), d), (d, x[0]))**2/f(x[0], x[1])**2 +
Subs(Derivative(f(x[0], d), d), (d, x[1]))**2/f(x[0], x[1])**2)
def test_correct_arguments():
pytest.raises(ValueError, lambda: R2.e_x(R2.e_x))
pytest.raises(ValueError, lambda: R2.e_x(R2.dx))
pytest.raises(ValueError, lambda: Commutator(R2.e_x, R2.x))
pytest.raises(ValueError, lambda: Commutator(R2.dx, R2.e_x))
pytest.raises(ValueError, lambda: Differential(Differential(R2.e_x)))
pytest.raises(ValueError, lambda: R2.dx(R2.x))
pytest.raises(ValueError, lambda: TensorProduct(R2.e_x, R2.dx))
pytest.raises(ValueError, lambda: LieDerivative(R2.dx, R2.dx))
pytest.raises(ValueError, lambda: LieDerivative(R2.x, R2.dx))
pytest.raises(ValueError, lambda: CovarDerivativeOp(R2.dx, []))
pytest.raises(ValueError, lambda: CovarDerivativeOp(R2.x, []))
a = Symbol('a')
pytest.raises(ValueError,
lambda: intcurve_series(R2.dx, a, R2_r.point([1, 2])))
pytest.raises(ValueError,
lambda: intcurve_series(R2.x, a, R2_r.point([1, 2])))
pytest.raises(ValueError,
lambda: intcurve_diffequ(R2.dx, a, R2_r.point([1, 2])))
pytest.raises(ValueError,
lambda: intcurve_diffequ(R2.x, a, R2_r.point([1, 2])))
pytest.raises(ValueError, lambda: contravariant_order(R2.e_x + R2.dx))
pytest.raises(ValueError, lambda: contravariant_order(R2.dx**2))
pytest.raises(ValueError, lambda: covariant_order(R2.e_x + R2.dx))
pytest.raises(ValueError, lambda: contravariant_order(R2.e_x * R2.e_y))
pytest.raises(ValueError, lambda: covariant_order(R2.dx * R2.dy))
assert covariant_order(Integer(0), True) == -1
assert contravariant_order(Integer(0), True) == -1
def __new__(cls, e, z, z0, dir="+"):
e = sympify(e)
z = sympify(z)
z0 = sympify(z0)
if z0 is S.Infinity:
dir = "-"
elif z0 is S.NegativeInfinity:
dir = "+"
if isinstance(dir, str):
dir = Symbol(dir)
elif not isinstance(dir, Symbol):
raise TypeError("direction must be of type str or Symbol, not %s" %
type(dir))
if str(dir) not in ('+', '-', 'real'):
raise ValueError(
"direction must be either '+' or '-' or 'real', not %s" % dir)
obj = Expr.__new__(cls)
obj._args = (e, z, z0, dir)
return obj
def test_canonicalize2():
D = Symbol('D')
Eucl = TensorIndexType('Eucl', metric=0, dim=D, dummy_fmt='E')
i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14 = \
tensor_indices('i0:15', Eucl)
A = tensorhead('A', [Eucl] * 3, [[3]])
# two examples from Cvitanovic, Group Theory page 59
# of identities for antisymmetric tensors of rank 3
# contracted according to the Kuratowski graph eq.(6.59)
t = A(i0, i1, i2) * A(-i1, i3, i4) * A(-i3, i7, i5) * A(-i2, -i5, i6) * A(
-i4, -i6, i8)
t1 = t.canon_bp()
assert t1 == 0
# eq.(6.60)
# t = A(i0,i1,i2)*A(-i1,i3,i4)*A(-i2,i5,i6)*A(-i3,i7,i8)*A(-i6,-i7,i9)*
# A(-i8,i10,i13)*A(-i5,-i10,i11)*A(-i4,-i11,i12)*A(-i3,-i12,i14)
t = A(i0, i1, i2)*A(-i1, i3, i4)*A(-i2, i5, i6)*A(-i3, i7, i8)*A(-i6, -i7, i9) *\
A(-i8, i10, i13)*A(-i5, -i10, i11)*A(-i4, -i11, i12)*A(-i9, -i12, i14)
t1 = t.canon_bp()
assert t1 == 0
def test_contract_delta1():
# see Group Theory by Cvitanovic page 9
n = Symbol('n')
Color = TensorIndexType('Color', metric=None, dim=n, dummy_fmt='C')
a, b, c, d, e, f = tensor_indices('a,b,c,d,e,f', Color)
delta = Color.delta
def idn(a, b, d, c):
assert a.is_up and d.is_up
assert not (b.is_up or c.is_up)
return delta(a, c) * delta(d, b)
def T(a, b, d, c):
assert a.is_up and d.is_up
assert not (b.is_up or c.is_up)
return delta(a, b) * delta(d, c)
def P1(a, b, c, d):
return idn(a, b, c, d) - 1 / n * T(a, b, c, d)
def P2(a, b, c, d):
return 1 / n * T(a, b, c, d)
t = P1(a, -b, e, -f) * P1(f, -e, d, -c)
t1 = t.contract_delta(delta)
assert t1 == P1(a, -b, d, -c)
t = P2(a, -b, e, -f) * P2(f, -e, d, -c)
t1 = t.contract_delta(delta)
assert t1 == P2(a, -b, d, -c)
t = P1(a, -b, e, -f) * P2(f, -e, d, -c)
t1 = t.contract_delta(delta)
assert t1 == 0
t = P1(a, -b, b, -a)
t1 = t.contract_delta(delta)
assert t1.equals(n**2 - 1)
def equation(self, x=None, y=None, z=None):
"""The equation of the Plane.
Examples
========
>>> from diofant import Point3D, Plane
>>> a = Plane(Point3D(1, 1, 2), Point3D(2, 4, 7), Point3D(3, 5, 1))
>>> a.equation()
-23*x + 11*y - 2*z + 16
>>> a = Plane(Point3D(1, 4, 2), normal_vector=(6, 6, 6))
>>> a.equation()
6*x + 6*y + 6*z - 42
"""
x, y, z = [
i if i else Symbol(j, extended_real=True)
for i, j in zip((x, y, z), 'xyz')
]
a = Point3D(x, y, z)
b = self.p1.direction_ratio(a)
c = self.normal_vector
return (sum(i * j for i, j in zip(b, c)))
def _nthroot_solve(p, n, prec):
"""
helper function for ``nthroot``
It denests ``p**Rational(1, n)`` using its minimal polynomial
"""
from diofant.polys.numberfields import _minimal_polynomial_sq
from diofant.solvers import solve
while n % 2 == 0:
p = sqrtdenest(sqrt(p))
n = n // 2
if n == 1:
return p
pn = p**Rational(1, n)
x = Symbol('x')
f = _minimal_polynomial_sq(p, n, x)
if f is None:
return
sols = solve(f, x)
for sol in sols:
if abs(sol - pn).n() < 1. / 10**prec:
sol = sqrtdenest(sol)
if _mexpand(sol**n) == p:
return sol
def test_sympyissue_8642():
x = Symbol('x', extended_real=True, integer=False)
assert (x * 2).is_integer is None
def test_Max():
from diofant.abc import x, y, z
n = Symbol('n', negative=True)
n_ = Symbol('n_', negative=True)
nn = Symbol('nn', nonnegative=True)
nn_ = Symbol('nn_', nonnegative=True)
p = Symbol('p', positive=True)
p_ = Symbol('p_', positive=True)
np = Symbol('np', nonpositive=True)
np_ = Symbol('np_', nonpositive=True)
r = Symbol('r', extended_real=True)
assert Max(5, 4) == 5
# lists
pytest.raises(ValueError, lambda: Max())
assert Max(x, y) == Max(y, x)
assert Max(x, y, z) == Max(z, y, x)
assert Max(x, Max(y, z)) == Max(z, y, x)
assert Max(x, Min(y, oo)) == Max(x, y)
assert Max(n, -oo, n_, p, 2) == Max(p, 2)
assert Max(n, -oo, n_, p) == p
assert Max(2, x, p, n, -oo, S.NegativeInfinity, n_, p, 2) == Max(2, x, p)
assert Max(0, x, 1, y) == Max(1, x, y)
assert Max(r, r + 1, r - 1) == 1 + r
assert Max(1000, 100, -100, x, p, n) == Max(p, x, 1000)
assert Max(cos(x), sin(x)) == Max(sin(x), cos(x))
assert Max(cos(x), sin(x)).subs(x, 1) == sin(1)
assert Max(cos(x), sin(x)).subs(x, Rational(1, 2)) == cos(Rational(1, 2))
pytest.raises(ValueError, lambda: Max(cos(x), sin(x)).subs(x, I))
pytest.raises(ValueError, lambda: Max(I))
pytest.raises(ValueError, lambda: Max(I, x))
pytest.raises(ValueError, lambda: Max(S.ComplexInfinity, 1))
# interesting:
# Max(n, -oo, n_, p, 2) == Max(p, 2)
# True
# Max(n, -oo, n_, p, 1000) == Max(p, 1000)
# False
assert Max(1, x).diff(x) == Heaviside(x - 1)
assert Max(x, 1).diff(x) == Heaviside(x - 1)
assert Max(x**2, 1 + x, 1).diff(x) == \
2*x*Heaviside(x**2 - Max(1, x + 1)) \
+ Heaviside(x - Max(1, x**2) + 1)
a, b = Symbol('a', extended_real=True), Symbol('b', extended_real=True)
# a and b are both real, Max(a, b) should be real
assert Max(a, b).is_extended_real
# issue sympy/sympy#7233
e = Max(0, x)
assert e.evalf == e.n
assert e.n().args == (0, x)
def test_sympyissue_9165():
z = Symbol('z', zero=True)
f = Symbol('f', finite=False)
assert 0 / z == S.NaN
assert 0 * (1 / z) == S.NaN
assert 0 * f == S.NaN
def test_global_dict():
global_dict = {'Symbol': Symbol}
inputs = {'Q & S': And(Symbol('Q'), Symbol('S'))}
for text, result in inputs.items():
assert parse_expr(text, global_dict=global_dict) == result
def test_trigintegrate_symbolic():
n = Symbol('n', integer=True)
assert trigintegrate(cos(x)**n, x) is None
assert trigintegrate(sin(x)**n, x) is None
assert trigintegrate(cot(x)**n, x) is None
from diofant.core import Eq, Rational, Symbol
from diofant.functions import sin, cos, tan, csc, sec, cot, log, Piecewise
from diofant.integrals.trigonometry import trigintegrate
__all__ = ()
x = Symbol('x')
def test_trigintegrate_odd():
assert trigintegrate(Rational(1), x) == x
assert trigintegrate(x, x) is None
assert trigintegrate(x**2, x) is None
assert trigintegrate(sin(x), x) == -cos(x)
assert trigintegrate(cos(x), x) == sin(x)
assert trigintegrate(sin(3 * x), x) == -cos(3 * x) / 3
assert trigintegrate(cos(3 * x), x) == sin(3 * x) / 3
y = Symbol('y')
assert trigintegrate(sin(y*x), x) == \
Piecewise((0, Eq(y, 0)), (-cos(y*x)/y, True))
assert trigintegrate(cos(y*x), x) == \
Piecewise((x, Eq(y, 0)), (sin(y*x)/y, True))
assert trigintegrate(sin(y*x)**2, x) == \
Piecewise((0, Eq(y, 0)), ((x*y/2 - sin(x*y)*cos(x*y)/2)/y, True))
assert trigintegrate(sin(y*x)*cos(y*x), x) == \
Piecewise((0, Eq(y, 0)), (sin(x*y)**2/(2*y), True))
assert trigintegrate(cos(y*x)**2, x) == \
Piecewise((x, Eq(y, 0)), ((x*y/2 + sin(x*y)*cos(x*y)/2)/y, True))
def test_Min():
n = Symbol('n', negative=True)
n_ = Symbol('n_', negative=True)
nn = Symbol('nn', nonnegative=True)
nn_ = Symbol('nn_', nonnegative=True)
p = Symbol('p', positive=True)
p_ = Symbol('p_', positive=True)
np = Symbol('np', nonpositive=True)
np_ = Symbol('np_', nonpositive=True)
assert Min(5, 4) == 4
assert Min(-oo, -oo) == -oo
assert Min(-oo, n) == -oo
assert Min(n, -oo) == -oo
assert Min(-oo, np) == -oo
assert Min(np, -oo) == -oo
assert Min(-oo, 0) == -oo
assert Min(0, -oo) == -oo
assert Min(-oo, nn) == -oo
assert Min(nn, -oo) == -oo
assert Min(-oo, p) == -oo
assert Min(p, -oo) == -oo
assert Min(-oo, oo) == -oo
assert Min(oo, -oo) == -oo
assert Min(n, n) == n
assert Min(n, np) == Min(n, np)
assert Min(np, n) == Min(np, n)
assert Min(n, 0) == n
assert Min(0, n) == n
assert Min(n, nn) == n
assert Min(nn, n) == n
assert Min(n, p) == n
assert Min(p, n) == n
assert Min(n, oo) == n
assert Min(oo, n) == n
assert Min(np, np) == np
assert Min(np, 0) == np
assert Min(0, np) == np
assert Min(np, nn) == np
assert Min(nn, np) == np
assert Min(np, p) == np
assert Min(p, np) == np
assert Min(np, oo) == np
assert Min(oo, np) == np
assert Min(0, 0) == 0
assert Min(0, nn) == 0
assert Min(nn, 0) == 0
assert Min(0, p) == 0
assert Min(p, 0) == 0
assert Min(0, oo) == 0
assert Min(oo, 0) == 0
assert Min(nn, nn) == nn
assert Min(nn, p) == Min(nn, p)
assert Min(p, nn) == Min(p, nn)
assert Min(nn, oo) == nn
assert Min(oo, nn) == nn
assert Min(p, p) == p
assert Min(p, oo) == p
assert Min(oo, p) == p
assert Min(oo, oo) == oo
assert isinstance(Min(n, n_), Min)
assert isinstance(Min(nn, nn_), Min)
assert isinstance(Min(np, np_), Min)
assert isinstance(Min(p, p_), Min)
# lists
pytest.raises(ValueError, lambda: Min())
assert Min(x, y) == Min(y, x)
assert Min(x, y, z) == Min(z, y, x)
assert Min(x, Min(y, z)) == Min(z, y, x)
assert Min(x, Max(y, -oo)) == Min(x, y)
assert Min(p, oo, n, p, p, p_) == n
assert Min(p_, n_, p) == n_
assert Min(n, oo, -7, p, p, 2) == Min(n, -7)
assert Min(2, x, p, n, oo, n_, p, 2, -2, -2) == Min(-2, x, n, n_)
assert Min(0, x, 1, y) == Min(0, x, y)
assert Min(1000, 100, -100, x, p, n) == Min(n, x, -100)
assert Min(cos(x), sin(x)) == Min(cos(x), sin(x))
assert Min(cos(x), sin(x)).subs({x: 1}) == cos(1)
assert Min(cos(x), sin(x)).subs({x: Rational(1, 2)}) == sin(Rational(1, 2))
pytest.raises(ValueError, lambda: Min(cos(x), sin(x)).subs({x: I}))
pytest.raises(ValueError, lambda: Min(I))
pytest.raises(ValueError, lambda: Min(I, x))
pytest.raises(ValueError, lambda: Min(zoo, x))
assert Min(1, x).diff(x) == Heaviside(1 - x)
assert Min(x, 1).diff(x) == Heaviside(1 - x)
assert Min(0, -x, 1 - 2*x).diff(x) == -Heaviside(x + Min(0, -2*x + 1)) \
- 2*Heaviside(2*x + Min(0, -x) - 1)
pytest.raises(ArgumentIndexError, lambda: Min(1, x).fdiff(3))
a, b = Symbol('a', extended_real=True), Symbol('b', extended_real=True)
# a and b are both real, Min(a, b) should be real
assert Min(a, b).is_extended_real
# issue sympy/sympy#7619
f = Function('f')
assert Min(1, 2 * Min(f(1), 2)) # doesn't fail
# issue sympy/sympy#7233
e = Min(0, x)
assert e.evalf == e.n
assert e.evalf(strict=False).args == (0, x)
def test_other_symbol():
x = Symbol('x', integer=True)
assert x.is_integer is True
assert x.is_extended_real is True
x = Symbol('x', integer=True, nonnegative=True)
assert x.is_integer is True
assert x.is_nonnegative is True
assert x.is_negative is False
assert x.is_positive is None
x = Symbol('x', integer=True, nonpositive=True)
assert x.is_integer is True
assert x.is_nonpositive is True
assert x.is_positive is False
assert x.is_negative is None
x = Symbol('x', odd=True)
assert x.is_odd is True
assert x.is_even is False
assert x.is_integer is True
x = Symbol('x', odd=False)
assert x.is_odd is False
assert x.is_even is None
assert x.is_integer is None
x = Symbol('x', even=True)
assert x.is_even is True
assert x.is_odd is False
assert x.is_integer is True
x = Symbol('x', even=False)
assert x.is_even is False
assert x.is_odd is None
assert x.is_integer is None
x = Symbol('x', integer=True, nonnegative=True)
assert x.is_integer is True
assert x.is_nonnegative is True
x = Symbol('x', integer=True, nonpositive=True)
assert x.is_integer is True
assert x.is_nonpositive is True
with pytest.raises(AttributeError):
x.is_extended_real = False
x = Symbol('x', algebraic=True)
assert x.is_transcendental is False
x = Symbol('x', transcendental=True)
assert x.is_algebraic is False
assert x.is_rational is False
assert x.is_integer is False
