def test_polygon_to_polygon():
'''Polygon to Polygon'''
# XXX: Because of the way the warnings filters work, this will fail if it's
# run more than once in the same session. See issue 2492.
import warnings
# p1.distance(p2) emits a warning
# First, test the warning
warnings.filterwarnings(
"error", "Polygons may intersect producing erroneous output")
raises(UserWarning, lambda: p1.distance(p2))
# now test the actual output
warnings.filterwarnings(
"ignore", "Polygons may intersect producing erroneous output")
assert p1.distance(p2) == half/2
# Keep testing reasonably thread safe, so reset the warning
warnings.filterwarnings(
"default", "Polygons may intersect producing erroneous output")
# Note, in Python 2.6+, this can be done more nicely using the
# warnings.catch_warnings context manager.
# See http://docs.python.org/library/warnings#testing-warnings.
assert p1.distance(p3) == sqrt(2)/2
assert p3.distance(p4) == (sqrt(2)/2 - sqrt(Rational(2)/25)/2)
assert p5.distance(p6) == Rational(7)/10
def test_plan():
assert devise_plan(Hyper_Function([0], ()),
Hyper_Function([0], ()), z) == []
with raises(ValueError):
devise_plan(Hyper_Function([1], ()), Hyper_Function((), ()), z)
with raises(ValueError):
devise_plan(Hyper_Function([2], [1]), Hyper_Function([2], [2]), z)
with raises(ValueError):
devise_plan(Hyper_Function([2], []), Hyper_Function([S("1/2")], []), z)
# We cannot use pi/(10000 + n) because polys is insanely slow.
a1, a2, b1 = map(lambda n: randcplx(n), range(3))
b1 += 2*I
h = hyper([a1, a2], [b1], z)
h2 = hyper((a1 + 1, a2), [b1], z)
assert tn(apply_operators(h,
devise_plan(Hyper_Function((a1 + 1, a2), [b1]),
Hyper_Function((a1, a2), [b1]), z), op),
h2, z)
h2 = hyper((a1 + 1, a2 - 1), [b1], z)
assert tn(apply_operators(h,
devise_plan(Hyper_Function((a1 + 1, a2 - 1), [b1]),
Hyper_Function((a1, a2), [b1]), z), op),
h2, z)
def test_Rational_new():
""""
Test for Rational constructor
"""
_test_rational_new(Rational)
n1 = Rational(1, 2)
assert n1 == Rational(Integer(1), 2)
assert n1 == Rational(Integer(1), Integer(2))
assert n1 == Rational(1, Integer(2))
assert n1 == Rational(Rational(1, 2))
assert n1 == Rational(1.2, 2)
assert n1 == Rational('.5')
assert 1 == Rational(n1, n1)
assert Rational(3, 2) == Rational(Rational(1,2),Rational(1,3))
assert Rational(3, 1) == Rational(1,Rational(1,3))
n3_4 = Rational(3, 4)
assert Rational('3/4') == n3_4
assert -Rational('-3/4') == n3_4
assert Rational('.76').limit_denominator(4) == n3_4
assert Rational(19, 25).limit_denominator(4) == n3_4
assert Rational('19/25').limit_denominator(4) == n3_4
raises(ValueError, "Rational('1/2 + 2/3')")
# handle fractions.Fraction instances
try:
import fractions
assert Rational(fractions.Fraction(1, 2)) == Rational(1, 2)
except ImportError:
pass
def test_var():
var("a")
assert a == Symbol("a")
var("b bb cc zz _x")
assert b == Symbol("b")
assert bb == Symbol("bb")
assert cc == Symbol("cc")
assert zz == Symbol("zz")
assert _x == Symbol("_x")
v = var(['d','e','fg'])
assert d == Symbol('d')
assert e == Symbol('e')
assert fg == Symbol('fg')
# check return value
assert v == (d, e, fg)
# see if var() really injects into global namespace
raises(NameError, "z1")
make_z1()
assert z1 == Symbol("z1")
raises(NameError, "z2")
make_z2()
assert z2 == Symbol("z2")
def test_args():
p = Permutation([(0, 3, 1, 2), (4, 5)])
assert p._cyclic_form is None
assert Permutation(p) == p
assert p.cyclic_form == [[0, 3, 1, 2], [4, 5]]
assert p._array_form == [3, 2, 0, 1, 5, 4]
p = Permutation((0, 3, 1, 2))
assert p._cyclic_form is None
assert p._array_form == [0, 3, 1, 2]
assert Permutation([0]) == Permutation((0, ))
assert Permutation([[0], [1]]) == Permutation(((0, ), (1, ))) == \
Permutation(((0, ), [1]))
assert Permutation([[1, 2]]) == Permutation([0, 2, 1])
assert Permutation([[1], [4, 2]]) == Permutation([0, 1, 4, 3, 2])
assert Permutation([[1], [4, 2]], size=1) == Permutation([0, 1, 4, 3, 2])
assert Permutation(
[[1], [4, 2]], size=6) == Permutation([0, 1, 4, 3, 2, 5])
assert Permutation([], size=3) == Permutation([0, 1, 2])
assert Permutation(3).list(5) == [0, 1, 2, 3, 4]
assert Permutation(3).list(-1) == []
assert Permutation(5)(1, 2).list(-1) == [0, 2, 1]
assert Permutation(5)(1, 2).list() == [0, 2, 1, 3, 4, 5]
raises(TypeError, lambda: Permutation([1, 2], [0]))
# enclosing brackets needed
raises(ValueError, lambda: Permutation([[1, 2], 0]))
# enclosing brackets needed on 0
raises(ValueError, lambda: Permutation([1, 1, 0]))
raises(ValueError, lambda: Permutation([[1], [1, 2]]))
raises(ValueError, lambda: Permutation([4, 5], size=10)) # where are 0-3?
# but this is ok because cycles imply that only those listed moved
assert Permutation(4, 5) == Permutation([0, 1, 2, 3, 5, 4])
def test_getn():
# other lines are tested incidentally by the suite
assert O(x).getn() == 1
assert O(x / log(x)).getn() == 1
assert O(x ** 2 / log(x) ** 2).getn() == 2
assert O(x * log(x)).getn() == 1
raises(NotImplementedError, lambda: (O(x) + O(y)).getn())
def test_Integer_new():
"""
Test for Integer constructor
"""
_test_rational_new(Integer)
raises(ValueError, 'Integer("10.5")')
def test_Rational_new():
""""
Test for Rational constructor
"""
_test_rational_new(Rational)
n1 = Rational(1, 2)
assert n1 == Rational(Integer(1), 2)
assert n1 == Rational(Integer(1), Integer(2))
assert n1 == Rational(1, Integer(2))
assert n1 == Rational(Rational(1, 2))
assert 1 == Rational(n1, n1)
assert Rational(3, 2) == Rational(Rational(1, 2), Rational(1, 3))
assert Rational(3, 1) == Rational(1, Rational(1, 3))
n3_4 = Rational(3, 4)
assert Rational('3/4') == n3_4
assert -Rational('-3/4') == n3_4
assert Rational('.76').limit_denominator(4) == n3_4
assert Rational(19, 25).limit_denominator(4) == n3_4
assert Rational('19/25').limit_denominator(4) == n3_4
assert Rational(1.0, 3) == Rational(1, 3)
assert Rational(1, 3.0) == Rational(1, 3)
assert Rational(Float(0.5)) == Rational(1, 2)
assert Rational('1e2/1e-2') == Rational(10000)
assert Rational(-1, 0) == S.NegativeInfinity
assert Rational(1, 0) == S.Infinity
raises(TypeError, lambda: Rational('3**3'))
raises(TypeError, lambda: Rational('1/2 + 2/3'))
# handle fractions.Fraction instances
try:
import fractions
assert Rational(fractions.Fraction(1, 2)) == Rational(1, 2)
except ImportError:
pass
def test_Routine_argument_order():
a, x, y, z = symbols('a x y z')
expr = (x + y)*z
raises(CodeGenArgumentListError, lambda: make_routine("test", expr,
argument_sequence=[z, x]))
raises(CodeGenArgumentListError, lambda: make_routine("test", Eq(a,
expr), argument_sequence=[z, x, y]))
r = make_routine('test', Eq(a, expr), argument_sequence=[z, x, a, y])
assert [ arg.name for arg in r.arguments ] == [z, x, a, y]
assert [ type(arg) for arg in r.arguments ] == [
InputArgument, InputArgument, OutputArgument, InputArgument ]
r = make_routine('test', Eq(z, expr), argument_sequence=[z, x, y])
assert [ type(arg) for arg in r.arguments ] == [
InOutArgument, InputArgument, InputArgument ]
from sympy.tensor import IndexedBase, Idx
A, B = map(IndexedBase, ['A', 'B'])
m = symbols('m', integer=True)
i = Idx('i', m)
r = make_routine('test', Eq(A[i], B[i]), argument_sequence=[B, A, m])
assert [ arg.name for arg in r.arguments ] == [B.label, A.label, m]
expr = Integral(x*y*z, (x, 1, 2), (y, 1, 3))
r = make_routine('test', Eq(a, expr), argument_sequence=[z, x, a, y])
assert [ arg.name for arg in r.arguments ] == [z, x, a, y]
def test_interval_symbolic():
x = Symbol('x')
e = Interval(0, 1)
assert e.contains(x) == And(0 <= x, x <= 1)
raises(TypeError, lambda: x in e)
e = Interval(0, 1, True, True)
assert e.contains(x) == And(0 < x, x < 1)
def test_product_basic():
H, T = 'H', 'T'
unit_line = Interval(0, 1)
d6 = FiniteSet(1, 2, 3, 4, 5, 6)
d4 = FiniteSet(1, 2, 3, 4)
coin = FiniteSet(H, T)
square = unit_line * unit_line
assert (0, 0) in square
assert 0 not in square
assert (H, T) in coin ** 2
assert (.5, .5, .5) in square * unit_line
assert (H, 3, 3) in coin * d6* d6
HH, TT = sympify(H), sympify(T)
assert set(coin**2) == set(((HH, HH), (HH, TT), (TT, HH), (TT, TT)))
assert (d4*d4).is_subset(d6*d6)
assert square.complement(Interval(-oo, oo)*Interval(-oo, oo)) == Union(
(Interval(-oo, 0, True, True) +
Interval(1, oo, True, True))*Interval(-oo, oo),
Interval(-oo, oo)*(Interval(-oo, 0, True, True) +
Interval(1, oo, True, True)))
assert (Interval(-5, 5)**3).is_subset(Interval(-10, 10)**3)
assert not (Interval(-10, 10)**3).is_subset(Interval(-5, 5)**3)
assert not (Interval(-5, 5)**2).is_subset(Interval(-10, 10)**3)
assert (Interval(.2, .5)*FiniteSet(.5)).is_subset(square) # segment in square
assert len(coin*coin*coin) == 8
assert len(S.EmptySet*S.EmptySet) == 0
assert len(S.EmptySet*coin) == 0
raises(TypeError, lambda: len(coin*Interval(0, 2)))
def test_interval_arguments():
assert Interval(0, oo) == Interval(0, oo, False, True)
assert Interval(0, oo).right_open is true
assert Interval(-oo, 0) == Interval(-oo, 0, True, False)
assert Interval(-oo, 0).left_open is true
assert Interval(oo, -oo) == S.EmptySet
assert Interval(oo, oo) == S.EmptySet
assert Interval(-oo, -oo) == S.EmptySet
assert isinstance(Interval(1, 1), FiniteSet)
e = Sum(x, (x, 1, 3))
assert isinstance(Interval(e, e), FiniteSet)
assert Interval(1, 0) == S.EmptySet
assert Interval(1, 1).measure == 0
assert Interval(1, 1, False, True) == S.EmptySet
assert Interval(1, 1, True, False) == S.EmptySet
assert Interval(1, 1, True, True) == S.EmptySet
assert isinstance(Interval(0, Symbol('a')), Interval)
assert Interval(Symbol('a', real=True, positive=True), 0) == S.EmptySet
raises(ValueError, lambda: Interval(0, S.ImaginaryUnit))
raises(ValueError, lambda: Interval(0, Symbol('z', real=False)))
raises(NotImplementedError, lambda: Interval(0, 1, And(x, y)))
raises(NotImplementedError, lambda: Interval(0, 1, False, And(x, y)))
raises(NotImplementedError, lambda: Interval(0, 1, z, And(x, y)))
def test_is_subset():
assert Interval(0, 1).is_subset(Interval(0, 2)) is True
assert Interval(0, 3).is_subset(Interval(0, 2)) is False
assert FiniteSet(1, 2).is_subset(FiniteSet(1, 2, 3, 4))
assert FiniteSet(4, 5).is_subset(FiniteSet(1, 2, 3, 4)) is False
assert FiniteSet(1).is_subset(Interval(0, 2))
assert FiniteSet(1, 2).is_subset(Interval(0, 2, True, True)) is False
assert (Interval(1, 2) + FiniteSet(3)).is_subset(
(Interval(0, 2, False, True) + FiniteSet(2, 3)))
assert Interval(3, 4).is_subset(Union(Interval(0, 1), Interval(2, 5))) is True
assert Interval(3, 6).is_subset(Union(Interval(0, 1), Interval(2, 5))) is False
assert FiniteSet(1, 2, 3, 4).is_subset(Interval(0, 5)) is True
assert S.EmptySet.is_subset(FiniteSet(1, 2, 3)) is True
assert Interval(0, 1).is_subset(S.EmptySet) is False
assert S.EmptySet.is_subset(S.EmptySet) is True
raises(ValueError, lambda: S.EmptySet.is_subset(1))
# tests for the issubset alias
assert FiniteSet(1, 2, 3, 4).issubset(Interval(0, 5)) is True
assert S.EmptySet.issubset(FiniteSet(1, 2, 3)) is True
def test_evalf_trig_zero_detection():
a = sin(160*pi, evaluate=False)
t = a.evalf(maxn=100)
assert abs(t) < 1e-100
assert t._prec < 2
assert a.evalf(chop=True) == 0
raises(PrecisionExhausted, lambda: a.evalf(strict=True))
def test_intersection():
# iterable
i = Intersection(FiniteSet(1, 2, 3), Interval(2, 5), evaluate=False)
assert i.is_iterable
assert set(i) == {S(2), S(3)}
# challenging intervals
x = Symbol('x', real=True)
i = Intersection(Interval(0, 3), Interval(x, 6))
assert (5 in i) is False
raises(TypeError, lambda: 2 in i)
# Singleton special cases
assert Intersection(Interval(0, 1), S.EmptySet) == S.EmptySet
assert Intersection(Interval(-oo, oo), Interval(-oo, x)) == Interval(-oo, x)
# Products
line = Interval(0, 5)
i = Intersection(line**2, line**3, evaluate=False)
assert (2, 2) not in i
assert (2, 2, 2) not in i
raises(ValueError, lambda: list(i))
assert Intersection(Intersection(S.Integers, S.Naturals, evaluate=False),
S.Reals, evaluate=False) == \
Intersection(S.Integers, S.Naturals, S.Reals, evaluate=False)
assert Intersection(S.Complexes, FiniteSet(S.ComplexInfinity)) == S.EmptySet
def test_solve_args():
#implicit symbol to solve for
assert set(int(tmp) for tmp in solve(x**2-4)) == set([2,-2])
assert solve([x+y-3,x-y-5]) == {x: 4, y: -1}
#no symbol to solve for
assert solve(42) == []
assert solve([1, 2]) is None
#multiple symbols: take the first linear solution
assert solve(x + y - 3, [x, y]) == [{x: 3 - y}]
# unless it is an undetermined coefficients system
assert solve(a + b*x - 2, [a, b]) == {a: 2, b: 0}
# failing undetermined system
assert solve(a*x + b**2/(x + 4) - 3*x - 4/x, a, b) == \
[{a: (-b**2*x + 3*x**3 + 12*x**2 + 4*x + 16)/(x**2*(x + 4))}]
# failed single equation
assert solve(1/(1/x - y + exp(y))) == []
raises(NotImplementedError, 'solve(exp(x) + sin(x) + exp(y) + sin(y))')
# failed system
# -- when no symbols given, 1 fails
assert solve([y, exp(x) + x]) == [{x: -LambertW(1), y: 0}]
# both fail
assert solve((exp(x) - x, exp(y) - y)) == [{x: -LambertW(-1), y: -LambertW(-1)}]
# -- when symbols given
solve([y, exp(x) + x], x, y) == [(-LambertW(1), 0)]
#symbol is not a symbol or function
raises(TypeError, "solve(x**2-pi, pi)")
# no equations
assert solve([], [x]) == []
# overdetermined system
# - nonlinear
assert solve([(x + y)**2 - 4, x + y - 2]) == [{x: -y + 2}]
# - linear
assert solve((x + y - 2, 2*x + 2*y - 4)) == {x: -y + 2}
def test_erf2():
assert erf2(0, 0) == S.Zero
assert erf2(x, x) == S.Zero
assert erf2(nan, 0) == nan
assert erf2(-oo, y) == erf(y) + 1
assert erf2( oo, y) == erf(y) - 1
assert erf2( x, oo) == 1 - erf(x)
assert erf2( x,-oo) == -1 - erf(x)
assert erf2(x, erf2inv(x, y)) == y
assert erf2(-x, -y) == -erf2(x,y)
assert erf2(-x, y) == erf(y) + erf(x)
assert erf2( x, -y) == -erf(y) - erf(x)
assert erf2(x, y).rewrite('fresnels') == erf(y).rewrite(fresnels)-erf(x).rewrite(fresnels)
assert erf2(x, y).rewrite('fresnelc') == erf(y).rewrite(fresnelc)-erf(x).rewrite(fresnelc)
assert erf2(x, y).rewrite('hyper') == erf(y).rewrite(hyper)-erf(x).rewrite(hyper)
assert erf2(x, y).rewrite('meijerg') == erf(y).rewrite(meijerg)-erf(x).rewrite(meijerg)
assert erf2(x, y).rewrite('uppergamma') == erf(y).rewrite(uppergamma) - erf(x).rewrite(uppergamma)
assert erf2(x, y).rewrite('expint') == erf(y).rewrite(expint)-erf(x).rewrite(expint)
assert erf2(I, 0).is_real is False
assert erf2(0, 0).is_real is True
assert expand_func(erf(x) + erf2(x, y)) == erf(y)
assert conjugate(erf2(x, y)) == erf2(conjugate(x), conjugate(y))
assert erf2(x, y).rewrite('erf') == erf(y) - erf(x)
assert erf2(x, y).rewrite('erfc') == erfc(x) - erfc(y)
assert erf2(x, y).rewrite('erfi') == I*(erfi(I*x) - erfi(I*y))
raises(ArgumentIndexError, lambda: erfi(x).fdiff(3))
def test_dup_revert():
f = [-QQ(1, 720), QQ(0), QQ(1, 24), QQ(0), -QQ(1, 2), QQ(0), QQ(1)]
g = [QQ(61, 720), QQ(0), QQ(5, 24), QQ(0), QQ(1, 2), QQ(0), QQ(1)]
assert dup_revert(f, 8, QQ) == g
raises(NotReversible, lambda: dup_revert([QQ(1), QQ(0)], 3, QQ))
def test_dmp_revert():
f = [-QQ(1, 720), QQ(0), QQ(1, 24), QQ(0), -QQ(1, 2), QQ(0), QQ(1)]
g = [QQ(61, 720), QQ(0), QQ(5, 24), QQ(0), QQ(1, 2), QQ(0), QQ(1)]
assert dmp_revert(f, 8, 0, QQ) == g
raises(MultivariatePolynomialError, lambda: dmp_revert([[1]], 2, 1, QQ))
def test_dh_shared_key():
prk = dh_private_key(digit = 100)
p, _, ga = dh_public_key(prk)
b = randrange(2, p)
sk = dh_shared_key((p, _, ga), b)
assert sk == pow(ga, b, p)
raises(ValueError, lambda: dh_shared_key((1031, 14, 565), 2000))
def test_sympify3():
assert sympify("x**3") == x**3
assert sympify("x^3") == x**3
assert sympify("1/2") == Integer(1)/2
raises(SympifyError, lambda: _sympify('x**3'))
raises(SympifyError, lambda: _sympify('1/2'))
def test_erf():
assert erf(nan) == nan
assert erf(oo) == 1
assert erf(-oo) == -1
assert erf(0) == 0
assert erf(I*oo) == oo*I
assert erf(-I*oo) == -oo*I
assert erf(-2) == -erf(2)
assert erf(-x*y) == -erf(x*y)
assert erf(-x - y) == -erf(x + y)
assert erf(I).is_real == False
assert erf(0).is_real == True
assert conjugate(erf(z)) == erf(conjugate(z))
assert erf(x).as_leading_term(x) == x
assert erf(1/x).as_leading_term(x) == erf(1/x)
assert erf(z).rewrite('uppergamma') == sqrt(z**2)*erf(sqrt(z**2))/z
assert limit(exp(x)*exp(x**2)*(erf(x+1/exp(x))-erf(x)), x, oo) == 2/sqrt(pi)
assert limit((1-erf(z))*exp(z**2)*z, z, oo) == 1/sqrt(pi)
assert limit((1-erf(x))*exp(x**2)*sqrt(pi)*x, x, oo) == 1
assert limit(((1-erf(x))*exp(x**2)*sqrt(pi)*x-1)*2*x**2, x, oo) == -1
raises(ArgumentIndexError, 'erf(x).fdiff(2)')
def test_egyptian_fraction():
def test_equality(r, alg="Greedy"):
return r == Add(*[Rational(1, i) for i in egyptian_fraction(r, alg)])
r = random_complex_number(a=0, c=1, b=0, d=0, rational=True)
assert test_equality(r)
assert egyptian_fraction(Rational(4, 17)) == [5, 29, 1233, 3039345]
assert egyptian_fraction(Rational(7, 13), "Greedy") == [2, 26]
assert egyptian_fraction(Rational(23, 101), "Greedy") == \
[5, 37, 1438, 2985448, 40108045937720]
assert egyptian_fraction(Rational(18, 23), "Takenouchi") == \
[2, 6, 12, 35, 276, 2415]
assert egyptian_fraction(Rational(5, 6), "Graham Jewett") == \
[6, 7, 8, 9, 10, 42, 43, 44, 45, 56, 57, 58, 72, 73, 90, 1806, 1807,
1808, 1892, 1893, 1980, 3192, 3193, 3306, 5256, 3263442, 3263443,
3267056, 3581556, 10192056, 10650056950806]
assert egyptian_fraction(Rational(5, 6), "Golomb") == [2, 6, 12, 20, 30]
assert egyptian_fraction(Rational(5, 121), "Golomb") == [25, 1225, 3577, 7081, 11737]
raises(ValueError, lambda: egyptian_fraction(Rational(-4, 9)))
assert egyptian_fraction(Rational(8, 3), "Golomb") == [1, 2, 3, 4, 5, 6, 7,
14, 574, 2788, 6460,
11590, 33062, 113820]
assert egyptian_fraction(Rational(355, 113)) == [1, 2, 3, 4, 5, 6, 7, 8, 9,
10, 11, 12, 27, 744, 893588,
1251493536607,
20361068938197002344405230]
def test_math_lambda():
mpmath.mp.dps = 50
sin02 = mpmath.mpf("0.19866933079506121545941262711838975037020672954020")
f = lambdify(x, sin(x), "math")
prec = 1e-15
assert -prec < f(0.2) - sin02 < prec
raises(TypeError, lambda: f(x))
def test_mpmath_lambda():
mpmath.mp.dps = 50
sin02 = mpmath.mpf("0.19866933079506121545941262711838975037020672954020")
f = lambdify(x, sin(x), "mpmath")
prec = 1e-49 # mpmath precision is around 50 decimal places
assert -prec < f(mpmath.mpf("0.2")) - sin02 < prec
raises(TypeError, lambda: f(x))
def test_Max():
from sympy.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)
assert Max(5, 4) == 5
# lists
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(x, x + 1, x - 1) == 1 + x
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, S(1)/2) == cos(S(1)/2)
raises(ValueError, lambda: Max(cos(x), sin(x)).subs(x, I))
raises(ValueError, lambda: Max(I))
raises(ValueError, lambda: Max(I, x))
raises(ValueError, lambda: Max(S.ComplexInfinity, 1))
def test_lambda():
x = Symbol('x')
assert sympify('lambda : 1') == Lambda((), 1)
assert sympify('lambda x: 2*x') == Lambda(x, 2*x)
assert sympify('lambda x, y: 2*x+y') == Lambda([x, y], 2*x+y)
raises(SympifyError, "_sympify('lambda : 1')")
def test_solve_poly_system():
assert solve_poly_system([x-1], x) == [(S.One,)]
assert solve_poly_system([y - x, y - x - 1], x, y) == None
assert solve_poly_system([y - x**2, y + x**2], x, y) == [(S.Zero, S.Zero)]
assert solve_poly_system([2*x - 3, 3*y/2 - 2*x, z - 5*y], x, y, z) == \
[(Rational(3, 2), Integer(2), Integer(10))]
assert solve_poly_system([x*y - 2*y, 2*y**2 - x**2], x, y) == \
[(0, 0), (2, -sqrt(2)), (2, sqrt(2))]
assert solve_poly_system([y - x**2, y + x**2 + 1], x, y) == \
[(I*sqrt(S.Half), -S.Half), (-I*sqrt(S.Half), -S.Half)]
f_1 = x**2 + y + z - 1
f_2 = x + y**2 + z - 1
f_3 = x + y + z**2 - 1
a, b = -sqrt(2) - 1, sqrt(2) - 1
assert solve_poly_system([f_1, f_2, f_3], x, y, z) == \
[(a, a, a), (0, 0, 1), (0, 1, 0), (b, b, b), (1, 0, 0)]
solution = [(1, -1), (1, 1)]
assert solve_poly_system([Poly(x**2 - y**2), Poly(x - 1)]) == solution
assert solve_poly_system([x**2 - y**2, x - 1], x, y) == solution
assert solve_poly_system([x**2 - y**2, x - 1]) == solution
assert solve_poly_system([x + x*y - 3, y + x*y - 4], x, y) == [(-3, -2), (1, 2)]
raises(NotImplementedError, "solve_poly_system([x**3-y**3], x, y)")
raises(PolynomialError, "solve_poly_system([1/x], x)")
def test_julia_piecewise():
expr = Piecewise((x, x < 1), (x**2, True))
assert julia_code(expr) == "((x < 1) ? (x) : (x.^2))"
assert julia_code(expr, assign_to="r") == (
"r = ((x < 1) ? (x) : (x.^2))")
assert julia_code(expr, assign_to="r", inline=False) == (
"if (x < 1)\n"
" r = x\n"
"else\n"
" r = x.^2\n"
"end")
expr = Piecewise((x**2, x < 1), (x**3, x < 2), (x**4, x < 3), (x**5, True))
expected = ("((x < 1) ? (x.^2) :\n"
"(x < 2) ? (x.^3) :\n"
"(x < 3) ? (x.^4) : (x.^5))")
assert julia_code(expr) == expected
assert julia_code(expr, assign_to="r") == "r = " + expected
assert julia_code(expr, assign_to="r", inline=False) == (
"if (x < 1)\n"
" r = x.^2\n"
"elseif (x < 2)\n"
" r = x.^3\n"
"elseif (x < 3)\n"
" r = x.^4\n"
"else\n"
" r = x.^5\n"
"end")
# Check that Piecewise without a True (default) condition error
expr = Piecewise((x, x < 1), (x**2, x > 1), (sin(x), x > 0))
raises(ValueError, lambda: julia_code(expr))
def test_elgamal():
dk = elgamal_private_key(5)
ek = elgamal_public_key(dk)
P = ek[0]
assert P - 1 == decipher_elgamal(encipher_elgamal(P - 1, ek), dk)
raises(ValueError, lambda: encipher_elgamal(P, dk))
raises(ValueError, lambda: encipher_elgamal(-1, dk))
def test_vector_simple():
f = lambdify((x, y, z), (z, y, x))
assert f(3, 2, 1) == (1, 2, 3)
assert f(1.0, 2.0, 3.0) == (3.0, 2.0, 1.0)
# make sure correct number of args required
raises(TypeError, lambda: f(0))
def test_factorint():
assert primefactors(123456) == [2, 3, 643]
assert factorint(0) == {0: 1}
assert factorint(1) == {}
assert factorint(-1) == {-1: 1}
assert factorint(-2) == {-1: 1, 2: 1}
assert factorint(-16) == {-1: 1, 2: 4}
assert factorint(2) == {2: 1}
assert factorint(126) == {2: 1, 3: 2, 7: 1}
assert factorint(123456) == {2: 6, 3: 1, 643: 1}
assert factorint(5951757) == {3: 1, 7: 1, 29: 2, 337: 1}
assert factorint(64015937) == {7993: 1, 8009: 1}
assert factorint(2**(2**6) + 1) == {274177: 1, 67280421310721: 1}
assert multiproduct(factorint(fac(200))) == fac(200)
for b, e in factorint(fac(150)).items():
assert e == fac_multiplicity(150, b)
assert factorint(103005006059**7) == {103005006059: 7}
assert factorint(31337**191) == {31337: 191}
assert factorint(2**1000 * 3**500 * 257**127 * 383**60) == \
{2: 1000, 3: 500, 257: 127, 383: 60}
assert len(factorint(fac(10000))) == 1229
assert factorint(12932983746293756928584532764589230) == \
{2: 1, 5: 1, 73: 1, 727719592270351: 1, 63564265087747: 1, 383: 1}
assert factorint(727719592270351) == {727719592270351: 1}
assert factorint(2**64 + 1, use_trial=False) == factorint(2**64 + 1)
for n in range(60000):
assert multiproduct(factorint(n)) == n
assert pollard_rho(2**64 + 1, seed=1) == 274177
assert pollard_rho(19, seed=1) is None
assert factorint(3, limit=2) == {3: 1}
assert factorint(12345) == {3: 1, 5: 1, 823: 1}
assert factorint(12345, limit=3) == {
4115: 1,
3: 1
} # the 5 is greater than the limit
assert factorint(1, limit=1) == {}
assert factorint(12, limit=1) == {12: 1}
assert factorint(30, limit=2) == {2: 1, 15: 1}
assert factorint(16, limit=2) == {2: 4}
assert factorint(124, limit=3) == {2: 2, 31: 1}
assert factorint(4 * 31**2, limit=3) == {2: 2, 31: 2}
p1 = nextprime(2**32)
p2 = nextprime(2**16)
p3 = nextprime(p2)
assert factorint(p1 * p2 * p3) == {p1: 1, p2: 1, p3: 1}
assert factorint(13 * 17 * 19, limit=15) == {13: 1, 17 * 19: 1}
assert factorint(1951 * 15013 * 15053, limit=2000) == {
225990689: 1,
1951: 1
}
assert factorint(primorial(17) + 1, use_pm1=0) == \
{19026377261L: 1, 3467: 1, 277: 1, 105229: 1}
# when prime b is closer than approx sqrt(8*p) to prime p then they are
# "close" and have a trivial factorization
a = nextprime(2**2**8) # 78 digits
b = nextprime(a + 2**2**4)
assert 'Fermat' in capture(lambda: factorint(a * b, verbose=1))
raises(ValueError, lambda: pollard_rho(4))
raises(ValueError, lambda: pollard_pm1(3))
raises(ValueError, lambda: pollard_pm1(10, B=2))
# verbose coverage
n = nextprime(2**16) * nextprime(2**17) * nextprime(1901)
assert 'with primes' in capture(lambda: factorint(n, verbose=1))
capture(lambda: factorint(nextprime(2**16) * 1012, verbose=1))
n = nextprime(2**17)
capture(lambda: factorint(n**3, verbose=1)) # perfect power termination
capture(lambda: factorint(2 * n, verbose=1)) # factoring complete msg
# exceed 1st
n = nextprime(2**17)
n *= nextprime(n)
assert '1000' in capture(lambda: factorint(n, limit=1000, verbose=1))
n *= nextprime(n)
assert len(factorint(n)) == 3
assert len(factorint(n, limit=p1)) == 3
n *= nextprime(2 * n)
# exceed 2nd
assert '2001' in capture(lambda: factorint(n, limit=2000, verbose=1))
assert capture(lambda: factorint(n, limit=4000, verbose=1)).count(
'Pollard') == 2
# non-prime pm1 result
n = nextprime(8069)
n *= nextprime(2 * n) * nextprime(2 * n, 2)
capture(lambda: factorint(n, verbose=1)) # non-prime pm1 result
# factor fermat composite
p1 = nextprime(2**17)
p2 = nextprime(2 * p1)
assert factorint((p1 * p2**2)**3) == {p1: 3, p2: 6}
# Test for non integer input
raises(ValueError, lambda: factorint(4.5))
def test_bad_args():
# no vargs given
raises(TypeError, lambda: lambdify(1))
# same with vector exprs
raises(TypeError, lambda: lambdify([1, 2]))
def test_imps_wrong_args():
raises(ValueError, lambda: implemented_function(sin, lambda x: x))
def test_str_args():
f = lambdify('x,y,z', 'z,y,x')
assert f(3, 2, 1) == (1, 2, 3)
assert f(1.0, 2.0, 3.0) == (3.0, 2.0, 1.0)
# make sure correct number of args required
raises(TypeError, lambda: f(0))
def test_no_args():
f = lambdify([], 1)
raises(TypeError, lambda: f(-1))
assert f() == 1
def test_vector_discontinuous():
f = lambdify(x, (-1 / x, 1 / x))
raises(ZeroDivisionError, lambda: f(0))
assert f(1) == (-1.0, 1.0)
assert f(2) == (-0.5, 0.5)
assert f(-2) == (0.5, -0.5)
def test_issue_3952():
f = sin(x)
assert integrate(f, x) == -cos(x)
raises(ValueError, lambda: integrate(f, 2 * x))
def test_issue2337():
raises(NotImplementedError, lambda: limit(exp(x*y), x, oo))
raises(NotImplementedError, lambda: limit(exp(-x*y), x, oo))
def test_integration_variable():
raises(ValueError, lambda: Integral(exp(-x**2), 3))
raises(ValueError, lambda: Integral(exp(-x**2), (3, -oo, oo)))
def test_settings():
raises(TypeError, 'python(x, method="garbage")')
def test_Limit_dir():
raises(TypeError, lambda: Limit(x, x, 0, dir=0))
raises(ValueError, lambda: Limit(x, x, 0, dir='0'))
def test_piecewise_solve():
abs2 = Piecewise((-x, x <= 0), (x, x > 0))
f = abs2.subs(x, x - 2)
assert solve(f, x) == [2]
assert solve(f - 1, x) == [1, 3]
f = Piecewise(((x - 2)**2, x >= 0), (1, True))
assert solve(f, x) == [2]
g = Piecewise(((x - 5)**5, x >= 4), (f, True))
assert solve(g, x) == [2, 5]
g = Piecewise(((x - 5)**5, x >= 4), (f, x < 4))
assert solve(g, x) == [2, 5]
g = Piecewise(((x - 5)**5, x >= 2), (f, x < 2))
assert solve(g, x) == [5]
g = Piecewise(((x - 5)**5, x >= 2), (f, True))
assert solve(g, x) == [5]
g = Piecewise(((x - 5)**5, x >= 2), (f, True), (10, False))
assert solve(g, x) == [5]
g = Piecewise(((x - 5)**5, x >= 2), (-x + 2, x - 2 <= 0),
(x - 2, x - 2 > 0))
assert solve(g, x) == [5]
# if no symbol is given the piecewise detection must still work
assert solve(Piecewise((x - 2, x > 2), (2 - x, True)) - 3) == [-1, 5]
f = Piecewise(((x - 2)**2, x >= 0), (0, True))
raises(NotImplementedError, lambda: solve(f, x))
def nona(ans):
return list(filter(lambda x: x is not S.NaN, ans))
p = Piecewise((x**2 - 4, x < y), (x - 2, True))
ans = solve(p, x)
assert nona([i.subs(y, -2) for i in ans]) == [2]
assert nona([i.subs(y, 2) for i in ans]) == [-2, 2]
assert nona([i.subs(y, 3) for i in ans]) == [-2, 2]
assert ans == [
Piecewise((-2, y > -2), (S.NaN, True)),
Piecewise((2, y <= 2), (S.NaN, True)),
Piecewise((2, y > 2), (S.NaN, True))
]
# issue 6060
absxm3 = Piecewise((x - 3, S(0) <= x - 3), (3 - x, S(0) > x - 3))
assert solve(absxm3 - y, x) == [
Piecewise((-y + 3, -y < 0), (S.NaN, True)),
Piecewise((y + 3, y >= 0), (S.NaN, True))
]
p = Symbol('p', positive=True)
assert solve(absxm3 - p, x) == [-p + 3, p + 3]
# issue 6989
f = Function('f')
assert solve(Eq(-f(x), Piecewise((1, x > 0), (0, True))), f(x)) == \
[Piecewise((-1, x > 0), (0, True))]
# issue 8587
f = Piecewise((2 * x**2, And(S(0) < x, x < 1)), (2, True))
assert solve(f - 1) == [1 / sqrt(2)]
def test_settings():
raises(TypeError, lambda: python(x, method="garbage"))
def test_immutability():
with raises(TypeError):
IM[2, 2] = 5
def test_contains():
assert Order(1, x) not in Order(1)
assert Order(1) in Order(1, x)
raises(TypeError, lambda: Order(x * y**2) in Order(x**2 * y))
def test_continued_fraction():
assert cf_p(1, 1, 10, 0) == cf_p(1, 1, 0, 1)
assert cf_p(1, -1, 10, 1) == cf_p(-1, 1, 10, -1)
t = sqrt(2)
assert cf((1 + t) * (1 - t)) == cf(-1)
for n in [
0, 2,
S(2) / 3,
sqrt(2), 3 * sqrt(2), 1 + 2 * sqrt(3) / 5, (2 - 3 * sqrt(5)) / 7,
1 + sqrt(2), (-5 + sqrt(17)) / 4
]:
assert (cf_r(cf(n)) - n).expand() == 0
assert (cf_r(cf(-n)) + n).expand() == 0
raises(ValueError, lambda: cf(sqrt(2 + sqrt(3))))
raises(ValueError, lambda: cf(sqrt(2) + sqrt(3)))
raises(ValueError, lambda: cf(pi))
raises(ValueError, lambda: cf(.1))
raises(ValueError, lambda: cf_p(1, 0, 0))
raises(ValueError, lambda: cf_p(1, 1, -1))
assert cf_p(4, 3, 0) == [1, 3]
assert cf_p(0, 3, 5) == [0, 1, [2, 1, 12, 1, 2, 2]]
assert cf_p(1, 1, 0) == [1]
assert cf_p(3, 4, 0) == [0, 1, 3]
assert cf_p(4, 5, 0) == [0, 1, 4]
assert cf_p(5, 6, 0) == [0, 1, 5]
assert cf_p(11, 13, 0) == [0, 1, 5, 2]
assert cf_p(16, 19, 0) == [0, 1, 5, 3]
assert cf_p(27, 32, 0) == [0, 1, 5, 2, 2]
assert cf_p(1, 2, 5) == [[1]]
assert cf_p(0, 1, 2) == [1, [2]]
assert cf_p(6, 7, 49) == [1, 1, 6]
assert cf_p(3796, 1387, 0) == [2, 1, 2, 1, 4]
assert cf_p(3245, 10000) == [0, 3, 12, 4, 13]
assert cf_p(1932, 2568) == [0, 1, 3, 26, 2]
assert cf_p(6589, 2569) == [2, 1, 1, 3, 2, 1, 3, 1, 23]
def take(iterator, n=7):
res = []
for i, t in enumerate(cf_i(iterator)):
if i >= n:
break
res.append(t)
return res
assert take(phi) == [1, 1, 1, 1, 1, 1, 1]
assert take(pi) == [3, 7, 15, 1, 292, 1, 1]
assert list(cf_i(S(17) / 12)) == [1, 2, 2, 2]
assert list(cf_i(S(-17) / 12)) == [-2, 1, 1, 2, 2]
assert list(cf_c([1, 6, 1, 8])) == [S(1), S(7) / 6, S(8) / 7, S(71) / 62]
assert list(cf_c([2])) == [S(2)]
assert list(cf_c([1, 1, 1, 1, 1, 1, 1])) == [
S.One,
S(2), S(3) / 2,
S(5) / 3,
S(8) / 5,
S(13) / 8,
S(21) / 13
]
assert list(cf_c([1, 6, S(-1) / 2,
4])) == [S.One, S(7) / 6,
S(5) / 4, S(3) / 2]
assert cf_r([1, 6, 1, 8]) == S(71) / 62
assert cf_r([3]) == S(3)
assert cf_r([-1, 5, 1, 4]) == S(-24) / 29
assert (cf_r([0, 1, 1, 7, [24, 8]]) - (sqrt(3) + 2) / 7).expand() == 0
assert cf_r([1, 5, 9]) == S(55) / 46
assert (cf_r([[1]]) - (sqrt(5) + 1) / 2).expand() == 0
assert cf_r([-3, 1, 1, [2]]) == -1 - sqrt(2)
def test_piecewise():
# Test canonicalization
assert Piecewise((x, x < 1), (0, True)) == Piecewise((x, x < 1), (0, True))
assert Piecewise((x, x < 1), (0, True), (1, True)) == \
Piecewise((x, x < 1), (0, True))
assert Piecewise((x, x < 1), (0, False), (-1, 1 > 2)) == \
Piecewise((x, x < 1))
assert Piecewise((x, x < 1), (0, x < 1), (0, True)) == \
Piecewise((x, x < 1), (0, True))
assert Piecewise((x, x < 1), (0, x < 2), (0, True)) == \
Piecewise((x, x < 1), (0, True))
assert Piecewise((x, x < 1), (x, x < 2), (0, True)) == \
Piecewise((x, Or(x < 1, x < 2)), (0, True))
assert Piecewise((x, x < 1), (x, x < 2), (x, True)) == x
assert Piecewise((x, True)) == x
# False condition is never retained
assert Piecewise((x, False)) == Piecewise(
(x, False), evaluate=False) == Piecewise()
raises(TypeError, lambda: Piecewise(x))
assert Piecewise((x, 1)) == x # 1 and 0 are accepted as True/False
raises(TypeError, lambda: Piecewise((x, 2)))
raises(TypeError, lambda: Piecewise((x, x**2)))
raises(TypeError, lambda: Piecewise(([1], True)))
assert Piecewise(((1, 2), True)) == Tuple(1, 2)
cond = (Piecewise((1, x < 0), (2, True)) < y)
assert Piecewise((1, cond)) == Piecewise((1, ITE(x < 0, y > 1, y > 2)))
assert Piecewise((1, x > 0), (2, And(x <= 0, x > -1))) == Piecewise(
(1, x > 0), (2, x > -1))
# Test subs
p = Piecewise((-1, x < -1), (x**2, x < 0), (log(x), x >= 0))
p_x2 = Piecewise((-1, x**2 < -1), (x**4, x**2 < 0), (log(x**2), x**2 >= 0))
assert p.subs(x, x**2) == p_x2
assert p.subs(x, -5) == -1
assert p.subs(x, -1) == 1
assert p.subs(x, 1) == log(1)
# More subs tests
p2 = Piecewise((1, x < pi), (-1, x < 2 * pi), (0, x > 2 * pi))
p3 = Piecewise((1, Eq(x, 0)), (1 / x, True))
p4 = Piecewise((1, Eq(x, 0)), (2, 1 / x > 2))
assert p2.subs(x, 2) == 1
assert p2.subs(x, 4) == -1
assert p2.subs(x, 10) == 0
assert p3.subs(x, 0.0) == 1
assert p4.subs(x, 0.0) == 1
f, g, h = symbols('f,g,h', cls=Function)
pf = Piecewise((f(x), x < -1), (f(x) + h(x) + 2, x <= 1))
pg = Piecewise((g(x), x < -1), (g(x) + h(x) + 2, x <= 1))
assert pg.subs(g, f) == pf
assert Piecewise((1, Eq(x, 0)), (0, True)).subs(x, 0) == 1
assert Piecewise((1, Eq(x, 0)), (0, True)).subs(x, 1) == 0
assert Piecewise((1, Eq(x, y)), (0, True)).subs(x, y) == 1
assert Piecewise((1, Eq(x, z)), (0, True)).subs(x, z) == 1
assert Piecewise((1, Eq(exp(x), cos(z))), (0, True)).subs(x, z) == \
Piecewise((1, Eq(exp(z), cos(z))), (0, True))
p5 = Piecewise((0, Eq(cos(x) + y, 0)), (1, True))
assert p5.subs(y, 0) == Piecewise((0, Eq(cos(x), 0)), (1, True))
assert Piecewise((-1, y < 1), (0, x < 0), (1, Eq(x, 0)),
(2, True)).subs(x, 1) == Piecewise((-1, y < 1), (2, True))
assert Piecewise((1, Eq(x**2, -1)), (2, x < 0)).subs(x, I) == 1
# Test evalf
assert p.evalf() == p
assert p.evalf(subs={x: -2}) == -1
assert p.evalf(subs={x: -1}) == 1
assert p.evalf(subs={x: 1}) == log(1)
# Test doit
f_int = Piecewise((Integral(x, (x, 0, 1)), x < 1))
assert f_int.doit() == Piecewise((1 / 2, x < 1))
# Test differentiation
f = x
fp = x * p
dp = Piecewise((0, x < -1), (2 * x, x < 0), (1 / x, x >= 0))
fp_dx = x * dp + p
assert diff(p, x) == dp
assert diff(f * p, x) == fp_dx
# Test simple arithmetic
assert x * p == fp
assert x * p + p == p + x * p
assert p + f == f + p
assert p + dp == dp + p
assert p - dp == -(dp - p)
# Test power
dp2 = Piecewise((0, x < -1), (4 * x**2, x < 0), (1 / x**2, x >= 0))
assert dp**2 == dp2
# Test _eval_interval
f1 = x * y + 2
f2 = x * y**2 + 3
peval = Piecewise((f1, x < 0), (f2, x > 0))
peval_interval = f1.subs(x, 0) - f1.subs(x, -1) + f2.subs(x, 1) - f2.subs(
x, 0)
assert peval._eval_interval(x, 0, 0) == 0
assert peval._eval_interval(x, -1, 1) == peval_interval
peval2 = Piecewise((f1, x < 0), (f2, True))
assert peval2._eval_interval(x, 0, 0) == 0
assert peval2._eval_interval(x, 1, -1) == -peval_interval
assert peval2._eval_interval(x, -1, -2) == f1.subs(x, -2) - f1.subs(x, -1)
assert peval2._eval_interval(x, -1, 1) == peval_interval
assert peval2._eval_interval(x, None, 0) == peval2.subs(x, 0)
assert peval2._eval_interval(x, -1, None) == -peval2.subs(x, -1)
# Test integration
assert p.integrate() == Piecewise((-x, x < -1), (x**3 / 3 + 4 / 3, x < 0),
(x * log(x) - x + 4 / 3, True))
p = Piecewise((x, x < 1), (x**2, -1 <= x), (x, 3 < x))
assert integrate(p, (x, -2, 2)) == 5 / 6.0
assert integrate(p, (x, 2, -2)) == -5 / 6.0
p = Piecewise((0, x < 0), (1, x < 1), (0, x < 2), (1, x < 3), (0, True))
assert integrate(p, (x, -oo, oo)) == 2
p = Piecewise((x, x < -10), (x**2, x <= -1), (x, 1 < x))
assert integrate(p, (x, -2, 2)) == Undefined
# Test commutativity
assert isinstance(p, Piecewise) and p.is_commutative is True
def test_m_filename_match_first_fcn():
name_expr = [ ("foo", [2*x, 3*y]), ("bar", [y**2, 4*y]) ]
raises(ValueError, lambda: codegen(name_expr,
"Octave", prefix="bar", header=False, empty=False))
def test_risch_option():
# risch=True only allowed on indefinite integrals
raises(ValueError, lambda: integrate(1/log(x), (x, 0, oo), risch=True))
assert integrate(exp(-x**2), x, risch=True) == NonElementaryIntegral(exp(-x**2), x)
assert integrate(log(1/x)*y, x, y, risch=True) == y**2*(x*log(1/x)/2 + x/2)
assert integrate(erf(x), x, risch=True) == Integral(erf(x), x)
def test_settings():
raises(TypeError, 'latex(x*y, method="garbage")')
def test_localring():
Qxy = QQ.old_frac_field(x, y)
R = QQ.old_poly_ring(x, y, order="ilex")
X = R.convert(x)
Y = R.convert(y)
assert x in R
assert 1 / x not in R
assert 1 / (1 + x) in R
assert Y in R
assert X.ring == R
assert X * (Y**2 + 1) / (1 + X) == R.convert(x * (y**2 + 1) / (1 + x))
assert X * y == X * Y
raises(ExactQuotientFailed, lambda: X / Y)
raises(ExactQuotientFailed, lambda: x / Y)
raises(ExactQuotientFailed, lambda: X / y)
assert X + y == X + Y == R.convert(x + y) == x + Y
assert X - y == X - Y == R.convert(x - y) == x - Y
assert X + 1 == R.convert(x + 1)
assert X**2 / X == X
assert R.from_GlobalPolynomialRing(
ZZ.old_poly_ring(x, y).convert(x), ZZ.old_poly_ring(x, y)) == X
assert R.from_FractionField(Qxy.convert(x), Qxy) == X
raises(CoercionFailed,
lambda: R.from_FractionField(Qxy.convert(x) / y, Qxy))
raises(ExactQuotientFailed, lambda: X / Y)
raises(NotReversible, lambda: X.invert())
assert R._sdm_to_vector(
R._vector_to_sdm([X/(X + 1), Y/(1 + X*Y)], R.order), 2) == \
[X*(1 + X*Y), Y*(1 + X)]
def test_subs():
assert NS('besseli(-x, y) - besseli(x, y)', subs={x: 3.5, y: 20.0}) == \
'-4.92535585957223e-10'
assert NS('Piecewise((x, x>0)) + Piecewise((1-x, x>0))', subs={x: 0.1}) == \
'1.00000000000000'
raises(TypeError, lambda: x.evalf(subs=(x, 1)))
def test_array_permutedims():
sa = symbols('a0:144')
m1 = Array(sa[:6], (2, 3))
assert permutedims(m1, (1, 0)) == transpose(m1)
assert m1.tomatrix().T == permutedims(m1, (1, 0)).tomatrix()
assert m1.tomatrix().T == transpose(m1).tomatrix()
assert m1.tomatrix().C == conjugate(m1).tomatrix()
assert m1.tomatrix().H == adjoint(m1).tomatrix()
assert m1.tomatrix().T == m1.transpose().tomatrix()
assert m1.tomatrix().C == m1.conjugate().tomatrix()
assert m1.tomatrix().H == m1.adjoint().tomatrix()
raises(ValueError, lambda: permutedims(m1, (0, )))
raises(ValueError, lambda: permutedims(m1, (0, 0)))
raises(ValueError, lambda: permutedims(m1, (1, 2, 0)))
# Some tests with random arrays:
dims = 6
shape = [random.randint(1, 5) for i in range(dims)]
elems = [random.random() for i in range(tensorproduct(*shape))]
ra = Array(elems, shape)
perm = list(range(dims))
# Randomize the permutation:
random.shuffle(perm)
# Test inverse permutation:
assert permutedims(permutedims(ra, perm), _af_invert(perm)) == ra
# Test that permuted shape corresponds to action by `Permutation`:
assert permutedims(ra, perm).shape == tuple(Permutation(perm)(shape))
z = Array.zeros(4, 5, 6, 7)
assert permutedims(z, (2, 3, 1, 0)).shape == (6, 7, 5, 4)
assert permutedims(z, [2, 3, 1, 0]).shape == (6, 7, 5, 4)
assert permutedims(z, Permutation([2, 3, 1, 0])).shape == (6, 7, 5, 4)
po = Array(sa, [2, 2, 3, 3, 2, 2])
raises(ValueError, lambda: permutedims(po, (1, 1)))
raises(ValueError, lambda: po.transpose())
raises(ValueError, lambda: po.adjoint())
assert permutedims(po, reversed(range(po.rank()))) == Array(
[[[[[[sa[0], sa[72]], [sa[36], sa[108]]],
[[sa[12], sa[84]], [sa[48], sa[120]]],
[[sa[24], sa[96]], [sa[60], sa[132]]]],
[[[sa[4], sa[76]], [sa[40], sa[112]]],
[[sa[16], sa[88]], [sa[52], sa[124]]],
[[sa[28], sa[100]], [sa[64], sa[136]]]],
[[[sa[8], sa[80]], [sa[44], sa[116]]],
[[sa[20], sa[92]], [sa[56], sa[128]]],
[[sa[32], sa[104]], [sa[68], sa[140]]]]],
[[[[sa[2], sa[74]], [sa[38], sa[110]]],
[[sa[14], sa[86]], [sa[50], sa[122]]],
[[sa[26], sa[98]], [sa[62], sa[134]]]],
[[[sa[6], sa[78]], [sa[42], sa[114]]],
[[sa[18], sa[90]], [sa[54], sa[126]]],
[[sa[30], sa[102]], [sa[66], sa[138]]]],
[[[sa[10], sa[82]], [sa[46], sa[118]]],
[[sa[22], sa[94]], [sa[58], sa[130]]],
[[sa[34], sa[106]], [sa[70], sa[142]]]]]],
[[[[[sa[1], sa[73]], [sa[37], sa[109]]],
[[sa[13], sa[85]], [sa[49], sa[121]]],
[[sa[25], sa[97]], [sa[61], sa[133]]]],
[[[sa[5], sa[77]], [sa[41], sa[113]]],
[[sa[17], sa[89]], [sa[53], sa[125]]],
[[sa[29], sa[101]], [sa[65], sa[137]]]],
[[[sa[9], sa[81]], [sa[45], sa[117]]],
[[sa[21], sa[93]], [sa[57], sa[129]]],
[[sa[33], sa[105]], [sa[69], sa[141]]]]],
[[[[sa[3], sa[75]], [sa[39], sa[111]]],
[[sa[15], sa[87]], [sa[51], sa[123]]],
[[sa[27], sa[99]], [sa[63], sa[135]]]],
[[[sa[7], sa[79]], [sa[43], sa[115]]],
[[sa[19], sa[91]], [sa[55], sa[127]]],
[[sa[31], sa[103]], [sa[67], sa[139]]]],
[[[sa[11], sa[83]], [sa[47], sa[119]]],
[[sa[23], sa[95]], [sa[59], sa[131]]],
[[sa[35], sa[107]], [sa[71], sa[143]]]]]]])
assert permutedims(po,
(1, 0, 2, 3, 4, 5)) == Array([[[[[[sa[0], sa[1]],
[sa[2], sa[3]]],
[[sa[4], sa[5]],
[sa[6], sa[7]]],
[[sa[8], sa[9]],
[sa[10], sa[11]]]],
[[[sa[12], sa[13]],
[sa[14], sa[15]]],
[[sa[16], sa[17]],
[sa[18], sa[19]]],
[[sa[20], sa[21]],
[sa[22], sa[23]]]],
[[[sa[24], sa[25]],
[sa[26], sa[27]]],
[[sa[28], sa[29]],
[sa[30], sa[31]]],
[[sa[32], sa[33]],
[sa[34], sa[35]]]]],
[[[[sa[72], sa[73]],
[sa[74], sa[75]]],
[[sa[76], sa[77]],
[sa[78], sa[79]]],
[[sa[80], sa[81]],
[sa[82], sa[83]]]],
[[[sa[84], sa[85]],
[sa[86], sa[87]]],
[[sa[88], sa[89]],
[sa[90], sa[91]]],
[[sa[92], sa[93]],
[sa[94], sa[95]]]],
[[[sa[96], sa[97]],
[sa[98], sa[99]]],
[[sa[100], sa[101]],
[sa[102], sa[103]]],
[[sa[104], sa[105]],
[sa[106],
sa[107]]]]]],
[[[[[sa[36], sa[37]],
[sa[38], sa[39]]],
[[sa[40], sa[41]],
[sa[42], sa[43]]],
[[sa[44], sa[45]],
[sa[46], sa[47]]]],
[[[sa[48], sa[49]],
[sa[50], sa[51]]],
[[sa[52], sa[53]],
[sa[54], sa[55]]],
[[sa[56], sa[57]],
[sa[58], sa[59]]]],
[[[sa[60], sa[61]],
[sa[62], sa[63]]],
[[sa[64], sa[65]],
[sa[66], sa[67]]],
[[sa[68], sa[69]],
[sa[70], sa[71]]]]],
[[[[sa[108], sa[109]],
[sa[110], sa[111]]],
[[sa[112], sa[113]],
[sa[114], sa[115]]],
[[sa[116], sa[117]],
[sa[118], sa[119]]]],
[[[sa[120], sa[121]],
[sa[122], sa[123]]],
[[sa[124], sa[125]],
[sa[126], sa[127]]],
[[sa[128], sa[129]],
[sa[130], sa[131]]]],
[[[sa[132], sa[133]],
[sa[134], sa[135]]],
[[sa[136], sa[137]],
[sa[138], sa[139]]],
[[sa[140], sa[141]],
[sa[142],
sa[143]]]]]]])
assert permutedims(po,
(0, 2, 1, 4, 3, 5)) == Array([[[[[[sa[0], sa[1]],
[sa[4], sa[5]],
[sa[8], sa[9]]],
[[sa[2], sa[3]],
[sa[6], sa[7]],
[sa[10], sa[11]]]],
[[[sa[36], sa[37]],
[sa[40], sa[41]],
[sa[44], sa[45]]],
[[sa[38], sa[39]],
[sa[42], sa[43]],
[sa[46], sa[47]]]]],
[[[[sa[12], sa[13]],
[sa[16], sa[17]],
[sa[20], sa[21]]],
[[sa[14], sa[15]],
[sa[18], sa[19]],
[sa[22], sa[23]]]],
[[[sa[48], sa[49]],
[sa[52], sa[53]],
[sa[56], sa[57]]],
[[sa[50], sa[51]],
[sa[54], sa[55]],
[sa[58], sa[59]]]]],
[[[[sa[24], sa[25]],
[sa[28], sa[29]],
[sa[32], sa[33]]],
[[sa[26], sa[27]],
[sa[30], sa[31]],
[sa[34], sa[35]]]],
[[[sa[60], sa[61]],
[sa[64], sa[65]],
[sa[68], sa[69]]],
[[sa[62], sa[63]],
[sa[66], sa[67]],
[sa[70], sa[71]]]]]],
[[[[[sa[72], sa[73]],
[sa[76], sa[77]],
[sa[80], sa[81]]],
[[sa[74], sa[75]],
[sa[78], sa[79]],
[sa[82], sa[83]]]],
[[[sa[108], sa[109]],
[sa[112], sa[113]],
[sa[116], sa[117]]],
[[sa[110], sa[111]],
[sa[114], sa[115]],
[sa[118], sa[119]]]]],
[[[[sa[84], sa[85]],
[sa[88], sa[89]],
[sa[92], sa[93]]],
[[sa[86], sa[87]],
[sa[90], sa[91]],
[sa[94], sa[95]]]],
[[[sa[120], sa[121]],
[sa[124], sa[125]],
[sa[128], sa[129]]],
[[sa[122], sa[123]],
[sa[126], sa[127]],
[sa[130], sa[131]]]]],
[[[[sa[96], sa[97]],
[sa[100], sa[101]],
[sa[104], sa[105]]],
[[sa[98], sa[99]],
[sa[102], sa[103]],
[sa[106], sa[107]]]],
[[[sa[132], sa[133]],
[sa[136], sa[137]],
[sa[140], sa[141]]],
[[sa[134], sa[135]],
[sa[138], sa[139]],
[sa[142],
sa[143]]]]]]])
po2 = po.reshape(4, 9, 2, 2)
assert po2 == Array([[[[sa[0], sa[1]], [sa[2], sa[3]]],
[[sa[4], sa[5]], [sa[6], sa[7]]],
[[sa[8], sa[9]], [sa[10], sa[11]]],
[[sa[12], sa[13]], [sa[14], sa[15]]],
[[sa[16], sa[17]], [sa[18], sa[19]]],
[[sa[20], sa[21]], [sa[22], sa[23]]],
[[sa[24], sa[25]], [sa[26], sa[27]]],
[[sa[28], sa[29]], [sa[30], sa[31]]],
[[sa[32], sa[33]], [sa[34], sa[35]]]],
[[[sa[36], sa[37]], [sa[38], sa[39]]],
[[sa[40], sa[41]], [sa[42], sa[43]]],
[[sa[44], sa[45]], [sa[46], sa[47]]],
[[sa[48], sa[49]], [sa[50], sa[51]]],
[[sa[52], sa[53]], [sa[54], sa[55]]],
[[sa[56], sa[57]], [sa[58], sa[59]]],
[[sa[60], sa[61]], [sa[62], sa[63]]],
[[sa[64], sa[65]], [sa[66], sa[67]]],
[[sa[68], sa[69]], [sa[70], sa[71]]]],
[[[sa[72], sa[73]], [sa[74], sa[75]]],
[[sa[76], sa[77]], [sa[78], sa[79]]],
[[sa[80], sa[81]], [sa[82], sa[83]]],
[[sa[84], sa[85]], [sa[86], sa[87]]],
[[sa[88], sa[89]], [sa[90], sa[91]]],
[[sa[92], sa[93]], [sa[94], sa[95]]],
[[sa[96], sa[97]], [sa[98], sa[99]]],
[[sa[100], sa[101]], [sa[102], sa[103]]],
[[sa[104], sa[105]], [sa[106], sa[107]]]],
[[[sa[108], sa[109]], [sa[110], sa[111]]],
[[sa[112], sa[113]], [sa[114], sa[115]]],
[[sa[116], sa[117]], [sa[118], sa[119]]],
[[sa[120], sa[121]], [sa[122], sa[123]]],
[[sa[124], sa[125]], [sa[126], sa[127]]],
[[sa[128], sa[129]], [sa[130], sa[131]]],
[[sa[132], sa[133]], [sa[134], sa[135]]],
[[sa[136], sa[137]], [sa[138], sa[139]]],
[[sa[140], sa[141]], [sa[142], sa[143]]]]])
assert permutedims(po2, (3, 2, 0, 1)) == Array(
[[[[
sa[0], sa[4], sa[8], sa[12], sa[16], sa[20], sa[24], sa[28], sa[32]
],
[
sa[36], sa[40], sa[44], sa[48], sa[52], sa[56], sa[60], sa[64],
sa[68]
],
[
sa[72], sa[76], sa[80], sa[84], sa[88], sa[92], sa[96], sa[100],
sa[104]
],
[
sa[108], sa[112], sa[116], sa[120], sa[124], sa[128], sa[132],
sa[136], sa[140]
]],
[[
sa[2], sa[6], sa[10], sa[14], sa[18], sa[22], sa[26], sa[30],
sa[34]
],
[
sa[38], sa[42], sa[46], sa[50], sa[54], sa[58], sa[62], sa[66],
sa[70]
],
[
sa[74], sa[78], sa[82], sa[86], sa[90], sa[94], sa[98], sa[102],
sa[106]
],
[
sa[110], sa[114], sa[118], sa[122], sa[126], sa[130], sa[134],
sa[138], sa[142]
]]],
[[[
sa[1], sa[5], sa[9], sa[13], sa[17], sa[21], sa[25], sa[29],
sa[33]
],
[
sa[37], sa[41], sa[45], sa[49], sa[53], sa[57], sa[61], sa[65],
sa[69]
],
[
sa[73], sa[77], sa[81], sa[85], sa[89], sa[93], sa[97], sa[101],
sa[105]
],
[
sa[109], sa[113], sa[117], sa[121], sa[125], sa[129], sa[133],
sa[137], sa[141]
]],
[[
sa[3], sa[7], sa[11], sa[15], sa[19], sa[23], sa[27], sa[31],
sa[35]
],
[
sa[39], sa[43], sa[47], sa[51], sa[55], sa[59], sa[63], sa[67],
sa[71]
],
[
sa[75], sa[79], sa[83], sa[87], sa[91], sa[95], sa[99], sa[103],
sa[107]
],
[
sa[111], sa[115], sa[119], sa[123], sa[127], sa[131], sa[135],
sa[139], sa[143]
]]]])
def test_evalf_divergent_series():
raises(ValueError, lambda: Sum(1 / n, (n, 1, oo)).evalf())
raises(ValueError, lambda: Sum(n / (n**2 + 1), (n, 1, oo)).evalf())
raises(ValueError, lambda: Sum((-1)**n, (n, 1, oo)).evalf())
raises(ValueError, lambda: Sum((-1)**n, (n, 1, oo)).evalf())
raises(ValueError, lambda: Sum(n**2, (n, 1, oo)).evalf())
raises(ValueError, lambda: Sum(2**n, (n, 1, oo)).evalf())
raises(ValueError, lambda: Sum((-2)**n, (n, 1, oo)).evalf())
raises(ValueError, lambda: Sum((2 * n + 3) / (3 * n**2 + 4),
(n, 0, oo)).evalf())
raises(ValueError, lambda: Sum((0.5 * n**3) / (n**4 + 1),
(n, 0, oo)).evalf())
def test_has():
assert b21.has(b1)
assert b21.has(b3, b1)
assert b21.has(Basic)
assert not b1.has(b21, b3)
raises(TypeError, "b21.has()")
def test_Lambda_arguments():
raises(TypeError, lambda: Lambda(x, 2*x)(x, y))
raises(TypeError, lambda: Lambda((x, y), x + y)(x))
raises(TypeError, lambda: Lambda((), 42)(x))
def test_evalf_arguments():
raises(TypeError, lambda: pi.evalf(method="garbage"))
def test_negative_counts():
# issue 13873
raises(ValueError, lambda: sin(x).diff(x, -1))
def test_Subs():
assert Subs(1, (), ()) is S.One
# check null subs influence on hashing
assert Subs(x, y, z) != Subs(x, y, 1)
# neutral subs works
assert Subs(x, x, 1).subs(x, y).has(y)
# self mapping var/point
assert Subs(Derivative(f(x), (x, 2)), x, x).doit() == f(x).diff(x, x)
assert Subs(x, x, 0).has(x) # it's a structural answer
assert not Subs(x, x, 0).free_symbols
assert Subs(Subs(x + y, x, 2), y, 1) == Subs(x + y, (x, y), (2, 1))
assert Subs(x, (x,), (0,)) == Subs(x, x, 0)
assert Subs(x, x, 0) == Subs(y, y, 0)
assert Subs(x, x, 0).subs(x, 1) == Subs(x, x, 0)
assert Subs(y, x, 0).subs(y, 1) == Subs(1, x, 0)
assert Subs(f(x), x, 0).doit() == f(0)
assert Subs(f(x**2), x**2, 0).doit() == f(0)
assert Subs(f(x, y, z), (x, y, z), (0, 1, 1)) != \
Subs(f(x, y, z), (x, y, z), (0, 0, 1))
assert Subs(x, y, 2).subs(x, y).doit() == 2
assert Subs(f(x, y), (x, y, z), (0, 1, 1)) != \
Subs(f(x, y) + z, (x, y, z), (0, 1, 0))
assert Subs(f(x, y), (x, y), (0, 1)).doit() == f(0, 1)
assert Subs(Subs(f(x, y), x, 0), y, 1).doit() == f(0, 1)
raises(ValueError, lambda: Subs(f(x, y), (x, y), (0, 0, 1)))
raises(ValueError, lambda: Subs(f(x, y), (x, x, y), (0, 0, 1)))
assert len(Subs(f(x, y), (x, y), (0, 1)).variables) == 2
assert Subs(f(x, y), (x, y), (0, 1)).point == Tuple(0, 1)
assert Subs(f(x), x, 0) == Subs(f(y), y, 0)
assert Subs(f(x, y), (x, y), (0, 1)) == Subs(f(x, y), (y, x), (1, 0))
assert Subs(f(x)*y, (x, y), (0, 1)) == Subs(f(y)*x, (y, x), (0, 1))
assert Subs(f(x)*y, (x, y), (1, 1)) == Subs(f(y)*x, (x, y), (1, 1))
assert Subs(f(x), x, 0).subs(x, 1).doit() == f(0)
assert Subs(f(x), x, y).subs(y, 0) == Subs(f(x), x, 0)
assert Subs(y*f(x), x, y).subs(y, 2) == Subs(2*f(x), x, 2)
assert (2 * Subs(f(x), x, 0)).subs(Subs(f(x), x, 0), y) == 2*y
assert Subs(f(x), x, 0).free_symbols == set([])
assert Subs(f(x, y), x, z).free_symbols == {y, z}
assert Subs(f(x).diff(x), x, 0).doit(), Subs(f(x).diff(x), x, 0)
assert Subs(1 + f(x).diff(x), x, 0).doit(), 1 + Subs(f(x).diff(x), x, 0)
assert Subs(y*f(x, y).diff(x), (x, y), (0, 2)).doit() == \
2*Subs(Derivative(f(x, 2), x), x, 0)
assert Subs(y**2*f(x), x, 0).diff(y) == 2*y*f(0)
e = Subs(y**2*f(x), x, y)
assert e.diff(y) == e.doit().diff(y) == y**2*Derivative(f(y), y) + 2*y*f(y)
assert Subs(f(x), x, 0) + Subs(f(x), x, 0) == 2*Subs(f(x), x, 0)
e1 = Subs(z*f(x), x, 1)
e2 = Subs(z*f(y), y, 1)
assert e1 + e2 == 2*e1
assert e1.__hash__() == e2.__hash__()
assert Subs(z*f(x + 1), x, 1) not in [ e1, e2 ]
assert Derivative(f(x), x).subs(x, g(x)) == Derivative(f(g(x)), g(x))
assert Derivative(f(x), x).subs(x, x + y) == Subs(Derivative(f(x), x),
x, x + y)
assert Subs(f(x)*cos(y) + z, (x, y), (0, pi/3)).n(2) == \
Subs(f(x)*cos(y) + z, (x, y), (0, pi/3)).evalf(2) == \
z + Rational('1/2').n(2)*f(0)
assert f(x).diff(x).subs(x, 0).subs(x, y) == f(x).diff(x).subs(x, 0)
assert (x*f(x).diff(x).subs(x, 0)).subs(x, y) == y*f(x).diff(x).subs(x, 0)
assert Subs(Derivative(g(x)**2, g(x), x), g(x), exp(x)
).doit() == 2*exp(x)
assert Subs(Derivative(g(x)**2, g(x), x), g(x), exp(x)
).doit(deep=False) == 2*Derivative(exp(x), x)
assert Derivative(f(x, g(x)), x).doit() == Derivative(
f(x, g(x)), g(x))*Derivative(g(x), x) + Subs(Derivative(
f(y, g(x)), y), y, x)