def test_sympyissue_8245(): a = Rational(6506833320952669167898688709329, 5070602400912917605986812821504) q = a.evalf(10) assert (a == q) is True assert (a != q) is False assert (a > q) is false assert (a < q) is false assert (a >= q) is true assert (a <= q) is true a = sqrt(2) r = Rational(str(a.evalf(30))) assert (r == a) is False assert (r != a) is True assert (r > a) is true assert (r < a) is false assert (r >= a) is true assert (r <= a) is false a = sqrt(2) r = Rational(str(a.evalf(29))) assert (r == a) is False assert (r != a) is True assert (r > a) is false assert (r < a) is true assert (r >= a) is false assert (r <= a) is true
def test_roots_binomial(): assert roots_binomial(Poly(5*x, x)) == [0] assert roots_binomial(Poly(5*x**4, x)) == [0, 0, 0, 0] assert roots_binomial(Poly(5*x + 2, x)) == [-Rational(2, 5)] A = 10**Rational(3, 4)/10 assert roots_binomial(Poly(5*x**4 + 2, x)) == \ [-A - A*I, -A + A*I, A - A*I, A + A*I] a1 = Symbol('a1', nonnegative=True) b1 = Symbol('b1', nonnegative=True) r0 = roots_quadratic(Poly(a1*x**2 + b1, x)) r1 = roots_binomial(Poly(a1*x**2 + b1, x)) assert powsimp(r0[0]) == powsimp(r1[0]) assert powsimp(r0[1]) == powsimp(r1[1]) for a, b, s, n in itertools.product((1, 2), (1, 2), (-1, 1), (2, 3, 4, 5)): if a == b and a != 1: # a == b == 1 is sufficient continue p = Poly(a*x**n + s*b) ans = roots_binomial(p) assert ans == _nsort(ans) # issue sympy/sympy#8813 assert roots(Poly(2*x**3 - 16*y**3, x)) == { 2*y*(-Rational(1, 2) - sqrt(3)*I/2): 1, 2*y: 1, 2*y*(-Rational(1, 2) + sqrt(3)*I/2): 1}
def test_cse_single(): # Simple substitution. e = Add(Pow(x + y, 2), sqrt(x + y)) substs, reduced = cse([e]) assert substs == [(x0, x + y)] assert reduced == [sqrt(x0) + x0**2] assert cse([e], order='none') == cse([e])
def test_Pow_is_algebraic(): e = Symbol('e', algebraic=True) assert Pow(1, e, evaluate=False).is_algebraic assert Pow(0, e, evaluate=False).is_algebraic a = Symbol('a', algebraic=True) na = Symbol('na', algebraic=False) ia = Symbol('ia', algebraic=True, irrational=True) ib = Symbol('ib', algebraic=True, irrational=True) r = Symbol('r', rational=True, nonzero=True) x = Symbol('x') assert (a**r).is_algebraic assert (a**x).is_algebraic is None assert (na**r).is_algebraic is False assert (ia**r).is_algebraic assert (ia**ib).is_algebraic is False assert (a**e).is_algebraic is None # Gelfond-Schneider constant: assert Pow(2, sqrt(2), evaluate=False).is_algebraic is False assert Pow(GoldenRatio, sqrt(3), evaluate=False).is_algebraic is False # sympy/sympy#8649 t = Symbol('t', real=True, transcendental=True) n = Symbol('n', integer=True) assert (t**n).is_algebraic is None assert (t**n).is_integer is None
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_residue_reduce(): a = Poly(2*t**2 - t - x**2, t) d = Poly(t**3 - x**2*t, t) DE = DifferentialExtension(extension={'D': [Poly(1, x), Poly(1/x, t)], 'Tfuncs': [log]}) assert residue_reduce(a, d, DE, z, invert=False) == \ ([(Poly(z**2 - Rational(1, 4), z), Poly((1 + 3*x*z - 6*z**2 - 2*x**2 + 4*x**2*z**2)*t - x*z + x**2 + 2*x**2*z**2 - 2*z*x**3, t))], False) assert residue_reduce(a, d, DE, z, invert=True) == \ ([(Poly(z**2 - Rational(1, 4), z), Poly(t + 2*x*z, t))], False) assert residue_reduce(Poly(-2/x, t), Poly(t**2 - 1, t,), DE, z, invert=False) == \ ([(Poly(z**2 - 1, z), Poly(-2*z*t/x - 2/x, t))], True) ans = residue_reduce(Poly(-2/x, t), Poly(t**2 - 1, t), DE, z, invert=True) assert ans == ([(Poly(z**2 - 1, z), Poly(t + z, t))], True) assert residue_reduce_to_basic(ans[0], DE, z) == -log(-1 + log(x)) + log(1 + log(x)) DE = DifferentialExtension(extension={'D': [Poly(1, x), Poly(-t**2 - t/x - (1 - nu**2/x**2), t)]}) # TODO: Skip or make faster assert residue_reduce(Poly((-2*nu**2 - x**4)/(2*x**2)*t - (1 + x**2)/x, t), Poly(t**2 + 1 + x**2/2, t), DE, z) == \ ([(Poly(z + Rational(1, 2), z, domain='QQ'), Poly(t**2 + 1 + x**2/2, t, domain='EX'))], True) DE = DifferentialExtension(extension={'D': [Poly(1, x), Poly(1 + t**2, t)]}) assert residue_reduce(Poly(-2*x*t + 1 - x**2, t), Poly(t**2 + 2*x*t + 1 + x**2, t), DE, z) == \ ([(Poly(z**2 + Rational(1, 4), z), Poly(t + x + 2*z, t))], True) DE = DifferentialExtension(extension={'D': [Poly(1, x), Poly(t, t)]}) assert residue_reduce(Poly(t, t), Poly(t + sqrt(2), t), DE, z) == \ ([(Poly(z - 1, z), Poly(t + sqrt(2), t))], True)
def test_add(): assert (a**2 - b - c).subs({a**2 - b: d}) in [d - c, a**2 - b - c] assert (a**2 - c).subs({a**2 - c: d}) == d assert (a**2 - b - c).subs({a**2 - c: d}) in [d - b, a**2 - b - c] assert (a**2 - x - c).subs({a**2 - c: d}) in [d - x, a**2 - x - c] assert (a**2 - b - sqrt(a)).subs({a**2 - sqrt(a): c}) == c - b assert (a + b + exp(a + b)).subs({a + b: c}) == c + exp(c) assert (c + b + exp(c + b)).subs({c + b: a}) == a + exp(a) assert (a + b + c + d).subs({b + c: x}) == a + d + x assert (a + b + c + d).subs({-b - c: x}) == a + d - x assert ((x + 1)*y).subs({x + 1: t}) == t*y assert ((-x - 1)*y).subs({x + 1: t}) == -t*y assert ((x - 1)*y).subs({x + 1: t}) == y*(t - 2) assert ((-x + 1)*y).subs({x + 1: t}) == y*(-t + 2) # this should work everytime: e = a**2 - b - c assert e.subs({Add(*e.args[:2]): d}) == d + e.args[2] assert e.subs({a**2 - c: d}) == d - b # the fallback should recognize when a change has # been made; while .1 == Rational(1, 10) they are not the same # and the change should be made assert (0.1 + a).subs({0.1: Rational(1, 10)}) == Rational(1, 10) + a e = (-x*(-y + 1) - y*(y - 1)) ans = (-x*x - y*(-x)).expand() assert e.subs({-y + 1: x}) == ans
def test_rayleigh(): sigma = Symbol("sigma", positive=True) X = Rayleigh('x', sigma) assert density(X)(x) == x*exp(-x**2/(2*sigma**2))/sigma**2 assert E(X) == sqrt(2)*sqrt(pi)*sigma/2 assert variance(X) == -pi*sigma**2/2 + 2*sigma**2
def test_sympyissue_7383(): x, z, R, a = symbols('x z R a') r = sqrt(x**2 + z**2) u = erf(a*r/sqrt(2))/r Ec = u.diff(z, z).subs({x: sqrt(R*R - z*z)}) assert integrate(Ec, (z, -R, R)).simplify() == \ -2*sqrt(2)*R*a**3*exp(-R**2*a**2/2)/(3*sqrt(pi))
def test_evalf_integer_parts(): a = floor(log(8)/log(2) - exp(-1000), evaluate=False) b = floor(log(8)/log(2), evaluate=False) assert a.evalf() == 3 assert b.evalf() == 3 # equals, as a fallback, can still fail but it might succeed as here assert ceiling(10*(sin(1)**2 + cos(1)**2)) == 10 assert int(floor(factorial(50)/E, evaluate=False).evalf(70)) == \ int(11188719610782480504630258070757734324011354208865721592720336800) assert int(ceiling(factorial(50)/E, evaluate=False).evalf(70)) == \ int(11188719610782480504630258070757734324011354208865721592720336801) assert int(floor((GoldenRatio**999 / sqrt(5) + Rational(1, 2))) .evalf(1000)) == fibonacci(999) assert int(floor((GoldenRatio**1000 / sqrt(5) + Rational(1, 2))) .evalf(1000)) == fibonacci(1000) assert ceiling(x).evalf(subs={x: 3}) == 3 assert ceiling(x).evalf(subs={x: 3*I}) == 3*I assert ceiling(x).evalf(subs={x: 2 + 3*I}) == 2 + 3*I # issue sympy/sympy#10323 l = 1206577996382235787095214 y = ceiling(sqrt(l)) assert y == 1098443442506 assert y**2 >= l def check(x): c, f = ceiling(sqrt(x)), floor(sqrt(x)) assert (c - 1)**2 < x and c**2 >= x assert (f + 1)**2 > x and f**2 <= x check(2**30 + 1) check(2**100 + 1) check(2**112 + 2)
def test_polarify(): z = Symbol('z', polar=True) f = Function('f') ES = {} assert polarify(-1) == (polar_lift(-1), ES) assert polarify(1 + I) == (polar_lift(1 + I), ES) assert polarify(exp(x), subs=False) == exp(x) assert polarify(1 + x, subs=False) == 1 + x assert polarify(f(I) + x, subs=False) == f(polar_lift(I)) + x assert polarify(x, lift=True) == polar_lift(x) assert polarify(z, lift=True) == z assert polarify(f(x), lift=True) == f(polar_lift(x)) assert polarify(1 + x, lift=True) == polar_lift(1 + x) assert polarify(1 + f(x), lift=True) == polar_lift(1 + f(polar_lift(x))) newex, subs = polarify(f(x) + z) assert newex.subs(subs) == f(x) + z mu = Symbol("mu") sigma = Symbol("sigma", positive=True) # Make sure polarify(lift=True) doesn't try to lift the integration # variable assert polarify( Integral(sqrt(2)*x*exp(-(-mu + x)**2/(2*sigma**2))/(2*sqrt(pi)*sigma), (x, -oo, oo)), lift=True) == Integral(sqrt(2)*(sigma*exp_polar(0))**exp_polar(I*pi) * exp((sigma*exp_polar(0))**(2*exp_polar(I*pi))*exp_polar(I*pi)*polar_lift(-mu + x) ** (2*exp_polar(0))/2)*exp_polar(0)*polar_lift(x)/(2*sqrt(pi)), (x, -oo, oo))
def test_rootcomplex(): R = Rational assert ((+1 + I)**R(1, 2)).expand( complex=True) == 2**R(1, 4)*cos( pi/8) + 2**R(1, 4)*sin( pi/8)*I assert ((-1 - I)**R(1, 2)).expand( complex=True) == 2**R(1, 4)*cos(3*pi/8) - 2**R(1, 4)*sin(3*pi/8)*I assert (sqrt(-10)*I).as_real_imag() == (-sqrt(10), 0)
def test_python_functions(): # Simple assert python((2*x + exp(x))) in "x = Symbol('x')\ne = E**x + 2*x" assert python(sqrt(2)) == 'e = sqrt(2)' assert python(cbrt(2)) == 'e = 2**Rational(1, 3)' assert python(sqrt(2 + pi)) == 'e = sqrt(2 + pi)' assert python(cbrt(2 + pi)) == 'e = (2 + pi)**Rational(1, 3)' assert python(root(2, 4)) == 'e = 2**Rational(1, 4)' assert python(Abs(x)) == "x = Symbol('x')\ne = Abs(x)" assert python( Abs(x/(x**2 + 1))) in ["x = Symbol('x')\ne = Abs(x/(1 + x**2))", "x = Symbol('x')\ne = Abs(x/(x**2 + 1))"] # Univariate/Multivariate functions f = Function('f') assert python(f(x)) == "x = Symbol('x')\nf = Function('f')\ne = f(x)" assert python(f(x, y)) == "x = Symbol('x')\ny = Symbol('y')\nf = Function('f')\ne = f(x, y)" assert python(f(x/(y + 1), y)) in [ "x = Symbol('x')\ny = Symbol('y')\nf = Function('f')\ne = f(x/(1 + y), y)", "x = Symbol('x')\ny = Symbol('y')\nf = Function('f')\ne = f(x/(y + 1), y)"] # Nesting of square roots assert python(sqrt((sqrt(x + 1)) + 1)) in [ "x = Symbol('x')\ne = sqrt(1 + sqrt(1 + x))", "x = Symbol('x')\ne = sqrt(sqrt(x + 1) + 1)"] # Nesting of powers assert python(cbrt(cbrt(x + 1) + 1)) in [ "x = Symbol('x')\ne = (1 + (1 + x)**Rational(1, 3))**Rational(1, 3)", "x = Symbol('x')\ne = ((x + 1)**Rational(1, 3) + 1)**Rational(1, 3)"] # Function powers assert python(sin(x)**2) == "x = Symbol('x')\ne = sin(x)**2"
def test_messy(): assert laplace_transform(Si(x), x, s) == ((-atan(s) + pi/2)/s, 0, True) assert laplace_transform(Shi(x), x, s) == (acoth(s)/s, 1, True) # where should the logs be simplified? assert laplace_transform(Chi(x), x, s) == \ ((log(s**(-2)) - log((s**2 - 1)/s**2))/(2*s), 1, True) # TODO maybe simplify the inequalities? assert laplace_transform(besselj(a, x), x, s)[1:] == \ (0, And(Integer(0) < re(a/2) + Rational(1, 2), Integer(0) < re(a/2) + 1)) # NOTE s < 0 can be done, but argument reduction is not good enough yet assert fourier_transform(besselj(1, x)/x, x, s, noconds=False) == \ (Piecewise((0, 4*abs(pi**2*s**2) > 1), (2*sqrt(-4*pi**2*s**2 + 1), True)), s > 0) # TODO FT(besselj(0,x)) - conditions are messy (but for acceptable reasons) # - folding could be better assert integrate(E1(x)*besselj(0, x), (x, 0, oo), meijerg=True) == \ log(1 + sqrt(2)) assert integrate(E1(x)*besselj(1, x), (x, 0, oo), meijerg=True) == \ log(Rational(1, 2) + sqrt(2)/2) assert integrate(1/x/sqrt(1 - x**2), x, meijerg=True) == \ Piecewise((-acosh(1/x), 1 < abs(x**(-2))), (I*asin(1/x), True))
def test_expand(): f = (16 - 2*sqrt(29))**2 assert f.expand() == 372 - 64*sqrt(29) f = (Rational(1, 2) + I/2)**10 assert f.expand() == I/32 f = (Rational(1, 2) + I)**10 assert f.expand() == Rational(237, 1024) - 779*I/256
def test_evalf_ramanujan(): assert NS(exp(pi*sqrt(163)) - 640320**3 - 744, 10) == '-7.499274028e-13' # A related identity A = 262537412640768744*exp(-pi*sqrt(163)) B = 196884*exp(-2*pi*sqrt(163)) C = 103378831900730205293632*exp(-3*pi*sqrt(163)) assert NS(1 - A - B + C, 10) == '1.613679005e-59'
def test_RootOf_all_roots(): assert Poly(x**5 + x + 1).all_roots() == [ RootOf(x**3 - x**2 + 1, 0), -Rational(1, 2) - sqrt(3)*I/2, -Rational(1, 2) + sqrt(3)*I/2, RootOf(x**3 - x**2 + 1, 1), RootOf(x**3 - x**2 + 1, 2), ] assert Poly(x**5 + x + 1).all_roots(radicals=False) == [ RootOf(x**3 - x**2 + 1, 0), RootOf(x**2 + x + 1, 0, radicals=False), RootOf(x**2 + x + 1, 1, radicals=False), RootOf(x**3 - x**2 + 1, 1), RootOf(x**3 - x**2 + 1, 2), ] r = Poly((x**3 + x + 20)*(x**3 + x + 21)).all_roots() assert r[0].is_real and r[1].is_real assert all(not _.is_real for _ in r[2:]) assert r == [RootOf(x**3 + x + 21, 0), RootOf(x**3 + x + 20, 0), RootOf(x**3 + x + 20, 1), RootOf(x**3 + x + 20, 2), RootOf(x**3 + x + 21, 1), RootOf(x**3 + x + 21, 2)]
def test_solve_univariate_inequality(): assert isolve(x**2 >= 4, x, relational=False) == Union(Interval(-oo, -2, True), Interval(2, oo, False, True)) assert isolve(x**2 >= 4, x) == Or(And(Le(2, x), Lt(x, oo)), And(Le(x, -2), Lt(-oo, x))) assert isolve((x - 1)*(x - 2)*(x - 3) >= 0, x, relational=False) == \ Union(Interval(1, 2), Interval(3, oo, False, True)) assert isolve((x - 1)*(x - 2)*(x - 3) >= 0, x) == \ Or(And(Le(1, x), Le(x, 2)), And(Le(3, x), Lt(x, oo))) # issue sympy/sympy#2785: assert isolve(x**3 - 2*x - 1 > 0, x, relational=False) == \ Union(Interval(-1, -sqrt(5)/2 + Rational(1, 2), True, True), Interval(Rational(1, 2) + sqrt(5)/2, oo, True, True)) # issue sympy/sympy#2794: assert isolve(x**3 - x**2 + x - 1 > 0, x, relational=False) == \ Interval(1, oo, True, True) # XXX should be limited in domain, e.g. between 0 and 2*pi assert isolve(sin(x) < Rational(1, 2), x) == \ Or(And(-oo < x, x < pi/6), And(5*pi/6 < x, x < oo)) assert isolve(sin(x) > Rational(1, 2), x) == And(pi/6 < x, x < 5*pi/6) # numerical testing in valid() is needed assert isolve(x**7 - x - 2 > 0, x) == \ And(RootOf(x**7 - x - 2, 0) < x, x < oo) # handle numerator and denominator; although these would be handled as # rational inequalities, these test confirm that the right thing is done # when the domain is EX (e.g. when 2 is replaced with sqrt(2)) assert isolve(1/(x - 2) > 0, x) == And(Integer(2) < x, x < oo) den = ((x - 1)*(x - 2)).expand() assert isolve((x - 1)/den <= 0, x) == \ Or(And(-oo < x, x < 1), And(Integer(1) < x, x < 2)) assert isolve(x > oo, x) is false
def test_matplotlib_advanced(): """Examples from the 'advanced' notebook.""" try: name = 'test' tmp_file = TmpFileManager.tmp_file s = summation(1/x**y, (x, 1, oo)) p = plot(s, (y, 2, 10)) p.save(tmp_file('%s_advanced_inf_sum' % name)) p = plot(summation(1/x, (x, 1, y)), (y, 2, 10), show=False) p[0].only_integers = True p[0].steps = True p.save(tmp_file('%s_advanced_fin_sum' % name)) ### # Test expressions that can not be translated to np and # generate complex results. ### plot(sin(x) + I*cos(x)).save(tmp_file()) plot(sqrt(sqrt(-x))).save(tmp_file()) plot(LambertW(x)).save(tmp_file()) plot(sqrt(LambertW(x))).save(tmp_file()) # Characteristic function of a StudentT distribution with nu=10 plot((meijerg(((1 / 2,), ()), ((5, 0, 1 / 2), ()), 5 * x**2 * exp_polar(-I*pi)/2) + meijerg(((1/2,), ()), ((5, 0, 1/2), ()), 5*x**2 * exp_polar(I*pi)/2)) / (48 * pi), (x, 1e-6, 1e-2)).save(tmp_file()) finally: TmpFileManager.cleanup()
def test_rewrite(): assert besselj(n, z).rewrite(jn) == sqrt(2*z/pi)*jn(n - Rational(1, 2), z) assert bessely(n, z).rewrite(yn) == sqrt(2*z/pi)*yn(n - Rational(1, 2), z) assert besseli(n, z).rewrite(besselj) == \ exp(-I*n*pi/2)*besselj(n, polar_lift(I)*z) assert besselj(n, z).rewrite(besseli) == \ exp(I*n*pi/2)*besseli(n, polar_lift(-I)*z) assert besselj(2, z).rewrite(bessely) == besselj(2, z) assert bessely(2, z).rewrite(besselj) == bessely(2, z) assert bessely(2, z).rewrite(besseli) == bessely(2, z) assert besselk(2, z).rewrite(besseli) == besselk(2, z) assert besselk(2, z).rewrite(besselj) == besselk(2, z) assert besselk(2, z).rewrite(bessely) == besselk(2, z) nu = randcplx() assert tn(besselj(nu, z), besselj(nu, z).rewrite(besseli), z) assert tn(besselj(nu, z), besselj(nu, z).rewrite(bessely), z) assert tn(besseli(nu, z), besseli(nu, z).rewrite(besselj), z) assert tn(besseli(nu, z), besseli(nu, z).rewrite(bessely), z) assert tn(bessely(nu, z), bessely(nu, z).rewrite(besselj), z) assert tn(bessely(nu, z), bessely(nu, z).rewrite(besseli), z) assert tn(besselk(nu, z), besselk(nu, z).rewrite(besselj), z) assert tn(besselk(nu, z), besselk(nu, z).rewrite(besseli), z) assert tn(besselk(nu, z), besselk(nu, z).rewrite(bessely), z)
def test_lognormal(): mean = Symbol('mu', real=True) std = Symbol('sigma', positive=True, real=True) X = LogNormal('x', mean, std) # The diofant integrator can't do this too well # assert E(X) == exp(mean+std**2/2) # assert variance(X) == (exp(std**2)-1) * exp(2*mean + std**2) # Right now, only density function and sampling works # Test sampling: Only e^mean in sample std of 0 for i in range(3): X = LogNormal('x', i, 0) assert sample(X) == N(exp(i)) # The diofant integrator can't do this too well # assert E(X) == mu = Symbol("mu", extended_real=True) sigma = Symbol("sigma", positive=True) X = LogNormal('x', mu, sigma) assert density(X)(x) == (sqrt(2)*exp(-(-mu + log(x))**2 / (2*sigma**2))/(2*x*sqrt(pi)*sigma)) X = LogNormal('x', 0, 1) # Mean 0, standard deviation 1 assert density(X)(x) == sqrt(2)*exp(-log(x)**2/2)/(2*x*sqrt(pi))
def test_unevaluated(): X = Normal('x', 0, 1) assert E(X, evaluate=False) == ( Integral(sqrt(2)*x*exp(-x**2/2)/(2*sqrt(pi)), (x, -oo, oo))) assert E(X + 1, evaluate=False) == ( Integral(sqrt(2)*x*exp(-x**2/2)/(2*sqrt(pi)), (x, -oo, oo)) + 1)
def test_evalf_fast_series(): # Euler transformed series for sqrt(1+x) assert NS(Sum(fac(2*n + 1)/fac(n)**2/2**(3*n + 1), (n, 0, oo)), 100, strict=False) == NS(sqrt(2), 100) # Some series for exp(1) estr = NS(E, 100) assert NS(Sum(1/fac(n), (n, 0, oo)), 100, strict=False) == estr assert NS(1/Sum((1 - 2*n)/fac(2*n), (n, 0, oo)), 100) == estr assert NS(Sum((2*n + 1)/fac(2*n), (n, 0, oo)), 100, strict=False) == estr assert NS(Sum((4*n + 3)/2**(2*n + 1)/fac(2*n + 1), (n, 0, oo))**2, 100, strict=False) == estr pistr = NS(pi, 100) # Ramanujan series for pi assert NS(9801/sqrt(8)/Sum(fac(4*n)*(1103 + 26390*n)/fac(n)**4/396**(4*n), (n, 0, oo)), 100, strict=False) == pistr assert NS(1/Sum( binomial(2*n, n)**3 * (42*n + 5)/2**(12*n + 4), (n, 0, oo)), 100) == pistr # Machin's formula for pi assert NS(16*Sum((-1)**n/(2*n + 1)/5**(2*n + 1), (n, 0, oo)) - 4*Sum((-1)**n/(2*n + 1)/239**(2*n + 1), (n, 0, oo)), 100) == pistr # Apery's constant astr = NS(zeta(3), 100) P = 126392*n**5 + 412708*n**4 + 531578*n**3 + 336367*n**2 + 104000 * \ n + 12463 assert NS(Sum((-1)**n * P / 24 * (fac(2*n + 1)*fac(2*n)*fac(n))**3 / fac(3*n + 2) / fac(4*n + 3)**3, (n, 0, oo)), 100, strict=False) == astr assert NS(Sum((-1)**n * (205*n**2 + 250*n + 77)/64 * fac(n)**10 / fac(2*n + 1)**5, (n, 0, oo)), 100, strict=False) == astr pytest.raises(ValueError, lambda: Sum(factorial(n), (n, 0, oo)).evalf())
def test_expand_modulus(): assert ((x + y)**11).expand(modulus=11) == x**11 + y**11 assert ((x + sqrt(2)*y)**11).expand(modulus=11) == x**11 + 10*sqrt(2)*y**11 assert (x + y/2).expand(modulus=1) == y/2 pytest.raises(ValueError, lambda: ((x + y)**11).expand(modulus=0)) pytest.raises(ValueError, lambda: ((x + y)**11).expand(modulus=x))
def test_sympyissue_6559(): assert (-12*x + y).subs({-x: 1}) == 12 + y # though this involves cse it generated a failure in Mul._eval_subs x0, x1 = symbols('x0 x1') e = -log(-12*sqrt(2) + 17)/24 - log(-2*sqrt(2) + 3)/12 + sqrt(2)/3 # XXX modify cse so x1 is eliminated and x0 = -sqrt(2)? assert cse(e) == ( [(x0, sqrt(2))], [x0/3 - log(-12*x0 + 17)/24 - log(-2*x0 + 3)/12])
def test_noncommutative(): A, B, C = symbols('A,B,C', commutative=False) assert sstr(A*B*C**-1) == "A*B*C**(-1)" assert sstr(C**-1*A*B) == "C**(-1)*A*B" assert sstr(A*C**-1*B) == "A*C**(-1)*B" assert sstr(sqrt(A)) == "sqrt(A)" assert sstr(1/sqrt(A)) == "A**(-1/2)"
def test_sqrt(): assert str(sqrt(x)) == "sqrt(x)" assert str(sqrt(x**2)) == "sqrt(x**2)" assert str(1/sqrt(x)) == "1/sqrt(x)" assert str(1/sqrt(x**2)) == "1/sqrt(x**2)" assert str(y/sqrt(x)) == "y/sqrt(x)" assert str(x**(1/2)) == "x**0.5" assert str(1/x**(1/2)) == "x**(-0.5)"
def test_cse_single2(): # Simple substitution, test for being able to pass the expression directly e = Add(Pow(x + y, 2), sqrt(x + y)) substs, reduced = cse(e) assert substs == [(x0, x + y)] assert reduced == [sqrt(x0) + x0**2] substs, reduced = cse(Matrix([[1]])) assert isinstance(reduced[0], Matrix)
def test_pow_sympyissue_4823(): e = cbrt(-1) assert e.conjugate().evalf() == e.evalf().conjugate() e = (Rational(-2, 3) - cbrt(Rational(-29, 54) + sqrt(93)/18) - 1/(9*cbrt(Rational(-29, 54) + sqrt(93)/18))) assert e.conjugate().evalf() == e.evalf().conjugate() e = 2**I assert e.conjugate().evalf() == e.evalf().conjugate()
def test_assemble_partfrac_list(): f = 36 / (x**5 - 2*x**4 - 2*x**3 + 4*x**2 + x - 2) pfd = apart_list(f) assert assemble_partfrac_list(pfd) == -4/(x + 1) - 3/(x + 1)**2 - 9/(x - 1)**2 + 4/(x - 2) a = Dummy("a") pfd = (1, Poly(0, x, domain='ZZ'), [([sqrt(2), -sqrt(2)], Lambda(a, a/2), Lambda(a, -a + x), 1)]) assert assemble_partfrac_list(pfd) == -1/(sqrt(2)*(x + sqrt(2))) + 1/(sqrt(2)*(x - sqrt(2)))
def test_sympyissue_5728(): b = x*sqrt(y) a = sqrt(b) c = sqrt(sqrt(x)*y) assert powsimp(a*b) == sqrt(b)**3 assert powsimp(a*b**2*sqrt(y)) == sqrt(y)*a**5 assert powsimp(a*x**2*c**3*y) == c**3*a**5 assert powsimp(a*x*c**3*y**2) == c**7*a assert powsimp(x*c**3*y**2) == c**7 assert powsimp(x*c**3*y) == x*y*c**3 assert powsimp(sqrt(x)*c**3*y) == c**5 assert powsimp(sqrt(x)*a**3*sqrt(y)) == sqrt(x)*sqrt(y)*a**3 assert powsimp(Mul(sqrt(x)*c**3*sqrt(y), y, evaluate=False)) == \ sqrt(x)*sqrt(y)**3*c**3 assert powsimp(a**2*a*x**2*y) == a**7 # symbolic powers work, too b = x**y*y a = b*sqrt(b) assert a.is_Mul is True assert powsimp(a) == sqrt(b)**3 # as does exp a = x*exp(2*y/3) assert powsimp(a*sqrt(a)) == sqrt(a)**3 assert powsimp(a**2*sqrt(a)) == sqrt(a)**5 assert powsimp(a**2*sqrt(sqrt(a))) == sqrt(sqrt(a))**9
def test_sqrtdenest(): d = { sqrt(5 + 2 * r6): r2 + r3, sqrt(5. + 2 * r6): sqrt(5. + 2 * r6), sqrt(5. + 4 * sqrt(5 + 2 * r6)): sqrt(5.0 + 4 * r2 + 4 * r3), sqrt(r2): sqrt(r2), sqrt(5 + r7): sqrt(5 + r7), sqrt(3 + sqrt(5 + 2 * r7)): 3 * r2 * root(5 + 2 * r7, 4) / (2 * sqrt(6 + 3 * r7)) + r2 * sqrt(6 + 3 * r7) / (2 * root(5 + 2 * r7, 4)), sqrt(3 + 2 * r3): 3**Rational(3, 4) * (r6 / 2 + 3 * r2 / 2) / 3 } for i in d: assert sqrtdenest(i) == d[i]
def test_unrad1(): pytest.raises(NotImplementedError, lambda: unrad(sqrt(x) + sqrt(x + 1) + sqrt(1 - sqrt(x)) + 3)) pytest.raises(NotImplementedError, lambda: unrad(sqrt(x) + cbrt(x + 1) + 2 * sqrt(y))) 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)), (x, [])) assert check(unrad(sqrt(x) + 1), (x - 1, [])) assert check(unrad(sqrt(x) + root(x, 3) + 2), (s**3 + s**2 + 2, [s, s**6 - x])) assert check(unrad(sqrt(x) * root(x, 3) + 2), (x**5 - 64, [])) assert check(unrad(sqrt(x) + cbrt(x + 1)), (x**3 - (x + 1)**2, [])) assert check(unrad(sqrt(x) + sqrt(x + 1) + sqrt(2 * x)), (-2 * sqrt(2) * x - 2 * x + 1, [])) assert check(unrad(sqrt(x) + sqrt(x + 1) + 2), (16 * x - 9, [])) assert check(unrad(sqrt(x) + sqrt(x + 1) + sqrt(1 - x)), (5 * x**2 - 4 * x, [])) assert check(unrad(a * sqrt(x) + b * sqrt(x) + c * sqrt(y) + d * sqrt(y)), ((a * sqrt(x) + b * sqrt(x))**2 - (c * sqrt(y) + d * sqrt(y))**2, [])) assert check(unrad(sqrt(x) + sqrt(1 - x)), (2 * x - 1, [])) assert check(unrad(sqrt(x) + sqrt(1 - x) + sqrt(2 + x)), (5 * x**2 - 2 * x + 1, [])) assert unrad(sqrt(x) + sqrt(1 - x) + sqrt(2 + x) - 3) in [ (25 * x**4 + 376 * x**3 + 1256 * x**2 - 2272 * x + 784, []), (25 * x**8 - 476 * x**6 + 2534 * x**4 - 1468 * x**2 + 169, []) ] assert unrad(sqrt(x) + sqrt(1 - x) + sqrt(2 + x) - sqrt(1 - 2*x)) == \ (41*x**4 + 40*x**3 + 232*x**2 - 160*x + 16, []) # orig root at 0.487 assert check(unrad(sqrt(x) + sqrt(x + 1)), (Integer(1), [])) eq = sqrt(x) + sqrt(x + 1) + sqrt(1 - sqrt(x)) assert check(unrad(eq), (16 * x**2 - 9 * x, [])) assert check(unrad(sqrt(x) + root(x + 1, 3) + 2 * sqrt(y), y), (2 * sqrt(x) * cbrt(x + 1) + x - 4 * y + (x + 1)**Rational(2, 3), [])) assert check(unrad(sqrt(x / (1 - x)) + cbrt(x + 1)), (x**5 - x**4 - x**3 + 2 * x**2 + x - 1, [])) assert check(unrad(sqrt(x / (1 - x)) + 2 * sqrt(y), y), (4 * x * y + x - 4 * y, [])) assert check(unrad(sqrt(x) * sqrt(1 - x) + 2, x), (x**2 - x + 4, [])) # issue sympy/sympy#8622 assert unrad( (root(x + 1, 5) - root(x, 3))) == (x**5 - x**3 - 3 * x**2 - 3 * x - 1, []) # issue sympy/sympy#8679 assert check(unrad(x + root(x, 3) + root(x, 3)**2 + sqrt(y), x), (s**3 + s**2 + s + sqrt(y), [s, s**3 - x])) # for coverage assert check(unrad(sqrt(x) + root(x, 3) + y), (s**3 + s**2 + y, [s, s**6 - x])) # unrad some e = root(x + 1, 3) + root(x, 3) assert unrad(e) == (2 * x + 1, []) eq = (sqrt(x) + sqrt(x + 1) + sqrt(1 - x) - 6 * sqrt(5) / 5) assert check(unrad(eq), (15625 * x**4 + 173000 * x**3 + 355600 * x**2 - 817920 * x + 331776, [])) assert check(unrad(root(x, 4) + root(x, 4)**3 - 1), (s**3 + s - 1, [s, s**4 - x])) assert check(unrad(root(x, 2) + root(x, 2)**3 - 1), (x**3 + 2 * x**2 + x - 1, [])) assert unrad(x**0.5) is None assert check(unrad(t + root(x + y, 5) + root(x + y, 5)**3), (s**3 + s + t, [s, s**5 - x - y])) assert check(unrad(x + root(x + y, 5) + root(x + y, 5)**3, y), (s**3 + s + x, [s, s**5 - x - y])) assert check(unrad(x + root(x + y, 5) + root(x + y, 5)**3, x), (s**5 + s**3 + s - y, [s, s**5 - x - y])) assert check( unrad(root(x - 1, 3) + root(x + 1, 5) + root(2, 5)), (s**5 + 5 * root(2, 5) * s**4 + s**3 + 10 * 2**Rational(2, 5) * s**3 + 10 * 2**Rational(3, 5) * s**2 + 5 * 2**Rational(4, 5) * s + 4, [s, s**3 - x + 1])) pytest.raises( NotImplementedError, lambda: unrad( (root(x, 2) + root(x, 3) + root(x, 4)).subs({x: x**5 - x + 1}))) # the simplify flag should be reset to False for unrad results; # if it's not then this next test will take a long time eq = (sqrt(x) + sqrt(x + 1) + sqrt(1 - x) - 6 * sqrt(5) / 5) assert check(unrad(eq), ((5 * x - 4) * (3125 * x**3 + 37100 * x**2 + 100800 * x - 82944), [])) # duplicate radical handling assert check(unrad(sqrt(x + root(x + 1, 3)) - root(x + 1, 3) - 2), (s**3 - s**2 - 3 * s - 5, [s, s**3 - x - 1])) # cov post-processing e = root(x**2 + 1, 3) - root(x**2 - 1, 5) - 2 assert check(unrad(e), (s**5 - 10 * s**4 + 39 * s**3 - 80 * s**2 + 80 * s - 30, [s, s**3 - x**2 - 1])) e = sqrt(x + root(x + 1, 2)) - root(x + 1, 3) - 2 assert check(unrad(e), (s**6 - 2 * s**5 - 7 * s**4 - 3 * s**3 + 26 * s**2 + 40 * s + 25, [s, s**3 - x - 1])) assert check(unrad(e, _reverse=True), (s**6 - 14 * s**5 + 73 * s**4 - 187 * s**3 + 276 * s**2 - 228 * s + 89, [s, s**2 - x - sqrt(x + 1)])) # this one needs r0, r1 reversal to work assert check(unrad(sqrt(x + sqrt(root(x, 3) - 1)) - root(x, 6) - 2), (s**12 - 2 * s**8 - 8 * s**7 - 8 * s**6 + s**4 + 8 * s**3 + 23 * s**2 + 32 * s + 17, [s, s**6 - x])) # is this needed? # assert unrad(root(cosh(x), 3)/x*root(x + 1, 5) - 1) == ( # x**15 - x**3*cosh(x)**5 - 3*x**2*cosh(x)**5 - 3*x*cosh(x)**5 - cosh(x)**5, []) pytest.raises( NotImplementedError, lambda: unrad(sqrt(cosh(x) / x) + root(x + 1, 3) * sqrt(x) - 1)) assert unrad((x + y)**(2 * y / 3) + cbrt(x + y) + 1) is None assert check(unrad((x + y)**(2 * y / 3) + cbrt(x + y) + 1, x), (s**(2 * y) + s + 1, [s, s**3 - x - y])) eq = root(x + 1, 3) - (root(x, 3) + root(x, 5)) assert check(unrad(eq), (3 * s**13 + 3 * s**11 + s**9 - 1, [s, s**15 - x])) assert check(unrad(eq - 2), (3 * s**13 + 3 * s**11 + 6 * s**10 + s**9 + 12 * s**8 + 6 * s**6 + 12 * s**5 + 12 * s**3 + 7, [s, s**15 - x])) assert check( unrad(root(x, 3) - root(x + 1, 4) / 2 + root(x + 2, 3)), (4096 * s**13 + 960 * s**12 + 48 * s**11 - s**10 - 1728 * s**4, [s, s**4 - x - 1])) # orig expr has two real roots: -1, -.389 assert check( unrad(root(x, 3) + root(x + 1, 4) - root(x + 2, 3) / 2), (343 * s**13 + 2904 * s**12 + 1344 * s**11 + 512 * s**10 - 1323 * s**9 - 3024 * s**8 - 1728 * s**7 + 1701 * s**5 + 216 * s**4 - 729 * s, [s, s**4 - x - 1])) # orig expr has one real root: -0.048 assert check( unrad(root(x, 3) / 2 - root(x + 1, 4) + root(x + 2, 3)), (729 * s**13 - 216 * s**12 + 1728 * s**11 - 512 * s**10 + 1701 * s**9 - 3024 * s**8 + 1344 * s**7 + 1323 * s**5 - 2904 * s**4 + 343 * s, [s, s**4 - x - 1])) # orig expr has 2 real roots: -0.91, -0.15 # orig expr has 1 real root: 19.53 assert check(unrad(root(x, 3) / 2 - root(x + 1, 4) + root(x + 2, 3) - 2), (729 * s**13 + 1242 * s**12 + 18496 * s**10 + 129701 * s**9 + 388602 * s**8 + 453312 * s**7 - 612864 * s**6 - 3337173 * s**5 - 6332418 * s**4 - 7134912 * s**3 - 5064768 * s**2 - 2111913 * s - 398034, [s, s**4 - x - 1])) eq = (-x + (Rational(1, 2) - sqrt(3) * I / 2) * cbrt(3 * x**3 / 2 - x * (3 * x**2 - 34) / 2 + sqrt( (-3 * x**3 + x * (3 * x**2 - 34) + 90)**2 / 4 - Rational(39304, 27)) - 45) + 34 / (3 * (Rational(1, 2) - sqrt(3) * I / 2) * cbrt(3 * x**3 / 2 - x * (3 * x**2 - 34) / 2 + sqrt( (-3 * x**3 + x * (3 * x**2 - 34) + 90)**2 / 4 - Rational(39304, 27)) - 45))) assert check(unrad(eq), (s**6 - sqrt(3) * s**6 * I + 102 * cbrt(12) * s**4 + 102 * 2**Rational(2, 3) * 3**Rational(5, 6) * s**4 * I + 1620 * s**3 - 1620 * sqrt(3) * s**3 * I - 13872 * cbrt(18) * s**2 + 471648 - 471648 * sqrt(3) * I, [ s, s**3 - 306 * x - sqrt(3) * sqrt(31212 * x**2 - 165240 * x + 61484) + 810 ]))
def test_sqrtdenest_rec(): assert sqrtdenest(sqrt(-4*sqrt(14) - 2*r6 + 4*sqrt(21) + 33)) == \ -r2 + r3 + 2*r7 assert sqrtdenest(sqrt(-28*r7 - 14*r5 + 4*sqrt(35) + 82)) == \ -7 + r5 + 2*r7 assert sqrtdenest(sqrt(6*r2/11 + 2*sqrt(22)/11 + 6*sqrt(11)/11 + 2)) == \ sqrt(11)*(r2 + 3 + sqrt(11))/11 assert sqrtdenest(sqrt(468*r3 + 3024*r2 + 2912*r6 + 19735)) == \ 9*r3 + 26 + 56*r6 z = sqrt(-490 * r3 - 98 * sqrt(115) - 98 * sqrt(345) - 2107) assert sqrtdenest(z) == sqrt(-1) * (7 * r5 + 7 * r15 + 7 * sqrt(23)) z = sqrt(-4 * sqrt(14) - 2 * r6 + 4 * sqrt(21) + 34) assert sqrtdenest(z) == z assert sqrtdenest(sqrt(-8 * r2 - 2 * r5 + 18)) == -r10 + 1 + r2 + r5 assert sqrtdenest(sqrt(8*r2 + 2*r5 - 18)) == \ sqrt(-1)*(-r10 + 1 + r2 + r5) assert sqrtdenest(sqrt(8*r2/3 + 14*r5/3 + Rational(154, 9))) == \ -r10/3 + r2 + r5 + 3 assert sqrtdenest(sqrt(sqrt(2*r6 + 5) + sqrt(2*r7 + 8))) == \ sqrt(1 + r2 + r3 + r7) assert sqrtdenest(sqrt(4 * r15 + 8 * r5 + 12 * r3 + 24)) == 1 + r3 + r5 + r15 w = 1 + r2 + r3 + r5 + r7 assert sqrtdenest(sqrt((w**2).expand())) == w z = sqrt((w**2).expand() + 1) assert sqrtdenest(z) == z z = sqrt(2 * r10 + 6 * r2 + 4 * r5 + 12 + 10 * r15 + 30 * r3) assert sqrtdenest(z) == z
def test_simple_8(): assert O(sqrt(-x)) == O(sqrt(x)) assert O(x**2 * sqrt(x)) == O(x**Rational(5, 2)) assert O(x**3 * sqrt(-(-x)**3)) == O(x**Rational(9, 2)) assert O(x**Rational(3, 2) * sqrt((-x)**3)) == O(x**3) assert O(x * (-2 * x)**(I / 2)) == O(x * (-x)**(I / 2))
def test_heurisch_special(): assert heurisch(erf(x), x) == x * erf(x) + exp(-x**2) / sqrt(pi) assert heurisch(exp(-x**2) * erf(x), x) == sqrt(pi) * erf(x)**2 / 4
def test_meijer(): pytest.raises(TypeError, lambda: meijerg(1, z)) pytest.raises(TypeError, lambda: meijerg(((1, ), (2, )), (3, ), (4, ), z)) pytest.raises(TypeError, lambda: meijerg((1, 2, 3), (4, 5), z)) assert meijerg(((1, 2), (3,)), ((4,), (5,)), z) == \ meijerg(Tuple(1, 2), Tuple(3), Tuple(4), Tuple(5), z) g = meijerg((1, 2), (3, 4, 5), (6, 7, 8, 9), (10, 11, 12, 13, 14), z) assert g.an == Tuple(1, 2) assert g.ap == Tuple(1, 2, 3, 4, 5) assert g.aother == Tuple(3, 4, 5) assert g.bm == Tuple(6, 7, 8, 9) assert g.bq == Tuple(6, 7, 8, 9, 10, 11, 12, 13, 14) assert g.bother == Tuple(10, 11, 12, 13, 14) assert g.argument == z assert g.nu == 75 assert g.delta == -1 assert g.is_commutative is True assert meijerg([1, 2], [3], [4], [5], z).delta == Rational(1, 2) # just a few checks to make sure that all arguments go where they should assert tn(meijerg(Tuple(), Tuple(), Tuple(0), Tuple(), -z), exp(z), z) assert tn( sqrt(pi) * meijerg(Tuple(), Tuple(), Tuple(0), Tuple(Rational(1, 2)), z**2 / 4), cos(z), z) assert tn(meijerg(Tuple(1, 1), Tuple(), Tuple(1), Tuple(0), z), log(1 + z), z) # test exceptions pytest.raises(ValueError, lambda: meijerg(((3, 1), (2, )), ((oo, ), (2, 0)), x)) pytest.raises(ValueError, lambda: meijerg(((3, 1), (2, )), ((1, ), (2, 0)), x)) # differentiation g = meijerg((randcplx(), ), (randcplx() + 2 * I, ), Tuple(), (randcplx(), randcplx()), z) assert td(g, z) g = meijerg(Tuple(), (randcplx(), ), Tuple(), (randcplx(), randcplx()), z) assert td(g, z) g = meijerg(Tuple(), Tuple(), Tuple(randcplx()), Tuple(randcplx(), randcplx()), z) assert td(g, z) a1, a2, b1, b2, c1, c2, d1, d2 = symbols('a1:3, b1:3, c1:3, d1:3') assert meijerg((a1, a2), (b1, b2), (c1, c2), (d1, d2), z).diff(z) == \ (meijerg((a1 - 1, a2), (b1, b2), (c1, c2), (d1, d2), z) + (a1 - 1)*meijerg((a1, a2), (b1, b2), (c1, c2), (d1, d2), z))/z assert meijerg([z, z], [], [], [], z).diff(z) == \ Derivative(meijerg([z, z], [], [], [], z), z) # meijerg is unbranched wrt parameters assert meijerg([polar_lift(a1)], [polar_lift(a2)], [polar_lift(b1)], [polar_lift(b2)], polar_lift(z)) == meijerg([a1], [a2], [b1], [b2], polar_lift(z)) # integrand assert meijerg([a], [b], [c], [d], z).integrand(s) == \ z**s*gamma(c - s)*gamma(-a + s + 1)/(gamma(b - s)*gamma(-d + s + 1)) assert meijerg([[], []], [[Rational(1, 2)], [0]], 1).is_number assert not meijerg([[], []], [[x], [0]], 1).is_number
def test_sympyissue_8545(): eq = 1 - x - abs(1 - x) ans = And(Lt(1, x), Lt(x, oo)) assert reduce_piecewise_inequality(eq, '<', x) == ans eq = 1 - x - sqrt((1 - x)**2) assert reduce_inequalities(eq < 0) == ans
def test_slow_general_univariate(): r = RootOf(x**5 - x**2 + 1, 0) assert reduce_inequalities(sqrt(x) + 1/root(x, 3) > 1) == \ Or(And(Integer(0) < x, x < r**6), And(r**6 < x, x < oo))
def test_heurisch_hacking(): assert heurisch(sqrt(1 + 7*x**2), x, hints=[]) == \ x*sqrt(1 + 7*x**2)/2 + sqrt(7)*asinh(sqrt(7)*x)/14 assert heurisch(sqrt(1 - 7*x**2), x, hints=[]) == \ x*sqrt(1 - 7*x**2)/2 + sqrt(7)*asin(sqrt(7)*x)/14 assert heurisch(1/sqrt(1 + 7*x**2), x, hints=[]) == \ sqrt(7)*asinh(sqrt(7)*x)/7 assert heurisch(1/sqrt(1 - 7*x**2), x, hints=[]) == \ sqrt(7)*asin(sqrt(7)*x)/7 assert heurisch(exp(-7*x**2), x, hints=[]) == \ sqrt(7*pi)*erf(sqrt(7)*x)/14 assert heurisch(1/sqrt(9 - 4*x**2), x, hints=[]) == \ asin(2*x/3)/2 assert heurisch(1/sqrt(9 + 4*x**2), x, hints=[]) == \ asinh(2*x/3)/2
def test_pmint_erf(): f = exp(-x**2) * erf(x) / (erf(x)**3 - erf(x)**2 - erf(x) + 1) g = sqrt(pi) * log(erf(x) - 1) / 8 - sqrt(pi) * log(erf(x) + 1) / 8 - sqrt( pi) / (4 * erf(x) - 4) assert ratsimp(heurisch(f, x)) == g
def test_reduce_inequalities_general(): assert reduce_inequalities(Ge(sqrt(2) * x, 1)) == And(sqrt(2) / 2 <= x, x < oo) assert reduce_inequalities(PurePoly(x + 1, x) > 0) == And( Integer(-1) < x, x < oo)
def test_RR(): # Make sure the algorithm does the right thing if the ring is RR. See # issue 8685. assert heurisch(sqrt(1 + 0.25*x**2), x, hints=[]) == \ 0.5*x*sqrt(0.25*x**2 + 1) + 1.0*asinh(0.5*x)
def test_heurisch_symbolic_coeffs_1130(): y = Symbol('y') assert heurisch_wrapper(1 / (x**2 + y), x) == Piecewise( (-1 / x, Eq(y, 0)), (-I * log(x - I * sqrt(y)) / (2 * sqrt(y)) + I * log(x + I * sqrt(y)) / (2 * sqrt(y)), True)) y = Symbol('y', positive=True) assert heurisch_wrapper(1 / (x**2 + y), x) in [ I / sqrt(y) * log(x + sqrt(-y)) / 2 - I / sqrt(y) * log(x - sqrt(-y)) / 2, I * log(x + I * sqrt(y)) / (2 * sqrt(y)) - I * log(x - I * sqrt(y)) / (2 * sqrt(y)) ]
def test_heurisch_symbolic_coeffs(): assert heurisch(1 / (x + y), x) == log(x + y) assert heurisch(1 / (x + sqrt(2)), x) == log(x + sqrt(2)) assert simplify(diff(heurisch(log(x + y + z), y), y)) == log(x + y + z)
def test_TR10i(): assert TR10i(cos(1)*cos(3) + sin(1)*sin(3)) == cos(2) assert TR10i(cos(1)*cos(3) - sin(1)*sin(3)) == cos(4) assert TR10i(cos(1)*sin(3) - sin(1)*cos(3)) == sin(2) assert TR10i(cos(1)*sin(3) + sin(1)*cos(3)) == sin(4) assert TR10i(cos(1)*sin(3) + sin(1)*cos(3) + 7) == sin(4) + 7 assert TR10i(cos(1)*sin(3) + sin(1)*cos(3) + cos(3)) == cos(3) + sin(4) assert TR10i(2*cos(1)*sin(3) + 2*sin(1)*cos(3) + cos(3)) == \ 2*sin(4) + cos(3) assert TR10i(cos(2)*cos(3) + sin(2)*(cos(1)*sin(2) + cos(2)*sin(1))) == \ cos(1) eq = (cos(2)*cos(3) + sin(2)*( cos(1)*sin(2) + cos(2)*sin(1)))*cos(5) + sin(1)*sin(5) assert TR10i(eq) == TR10i(eq.expand()) == cos(4) assert TR10i(sqrt(2)*cos(x)*x + sqrt(6)*sin(x)*x) == \ 2*sqrt(2)*x*sin(x + pi/6) assert TR10i(cos(x)/sqrt(6) + sin(x)/sqrt(2) + cos(x)/sqrt(6)/3 + sin(x)/sqrt(2)/3) == 4*sqrt(6)*sin(x + pi/6)/9 assert TR10i(cos(x)/sqrt(6) + sin(x)/sqrt(2) + cos(y)/sqrt(6)/3 + sin(y)/sqrt(2)/3) == \ sqrt(6)*sin(x + pi/6)/3 + sqrt(6)*sin(y + pi/6)/9 assert TR10i(cos(x) + sqrt(3)*sin(x) + 2*sqrt(3)*cos(x + pi/6)) == 4*cos(x) assert TR10i(cos(x) + sqrt(3)*sin(x) + 2*sqrt(3)*cos(x + pi/6) + 4*sin(x)) == 4*sqrt(2)*sin(x + pi/4) assert TR10i(cos(2)*sin(3) + sin(2)*cos(4)) == \ sin(2)*cos(4) + sin(3)*cos(2) A = Symbol('A', commutative=False) assert TR10i(sqrt(2)*cos(x)*A + sqrt(6)*sin(x)*A) == \ 2*sqrt(2)*sin(x + pi/6)*A c = cos(x) s = sin(x) h = sin(y) r = cos(y) for si in ((1, 1), (1, -1), (-1, 1), (-1, -1)): for a in ((c*r, s*h), (c*h, s*r)): # explicit 2-args args = zip(si, a) ex = Add(*[Mul(*ai) for ai in args]) t = TR10i(ex) assert not (ex - t.expand(trig=True) or t.is_Add) c = cos(x) s = sin(x) h = sin(pi/6) r = cos(pi/6) for si in ((1, 1), (1, -1), (-1, 1), (-1, -1)): for a in ((c*r, s*h), (c*h, s*r)): # induced args = zip(si, a) ex = Add(*[Mul(*ai) for ai in args]) t = TR10i(ex) assert not (ex - t.expand(trig=True) or t.is_Add)
def test_trig_split(): assert trig_split(cos(x), cos(y)) == (1, 1, 1, x, y, True) assert trig_split(2*cos(x), -2*cos(y)) == (2, 1, -1, x, y, True) assert trig_split(cos(x)*sin(y), cos(y)*sin(y)) == \ (sin(y), 1, 1, x, y, True) assert trig_split(cos(x), -sqrt(3)*sin(x), two=True) == \ (2, 1, -1, x, pi/6, False) assert trig_split(cos(x), sin(x), two=True) == \ (sqrt(2), 1, 1, x, pi/4, False) assert trig_split(cos(x), -sin(x), two=True) == \ (sqrt(2), 1, -1, x, pi/4, False) assert trig_split(sqrt(2)*cos(x), -sqrt(6)*sin(x), two=True) == \ (2*sqrt(2), 1, -1, x, pi/6, False) assert trig_split(-sqrt(6)*cos(x), -sqrt(2)*sin(x), two=True) == \ (-2*sqrt(2), 1, 1, x, pi/3, False) assert trig_split(cos(x)/sqrt(6), sin(x)/sqrt(2), two=True) == \ (sqrt(6)/3, 1, 1, x, pi/6, False) assert trig_split(-sqrt(6)*cos(x)*sin(y), -sqrt(2)*sin(x)*sin(y), two=True) == \ (-2*sqrt(2)*sin(y), 1, 1, x, pi/3, False) assert trig_split(cos(x), sin(x)) is None assert trig_split(cos(x), sin(z)) is None assert trig_split(2*cos(x), -sin(x)) is None assert trig_split(cos(x), -sqrt(3)*sin(x)) is None assert trig_split(cos(x)*cos(y), sin(x)*sin(z)) is None assert trig_split(cos(x)*cos(y), sin(x)*sin(y)) is None assert trig_split(-sqrt(6)*cos(x), sqrt(2)*sin(x)*sin(y), two=True) is \ None assert trig_split(sqrt(3)*sqrt(x), cos(3), two=True) is None assert trig_split(sqrt(3)*root(x, 3), sin(3)*cos(2), two=True) is None assert trig_split(cos(5)*cos(6), cos(7)*sin(5), two=True) is None
def test_RootOf___new__(): assert RootOf(x, 0) == 0 assert RootOf(x, -1) == 0 assert RootOf(x, S.Zero) == 0 assert RootOf(x - 1, 0) == 1 assert RootOf(x - 1, -1) == 1 assert RootOf(x + 1, 0) == -1 assert RootOf(x + 1, -1) == -1 assert RootOf(x**2 + 2 * x + 3, 0) == -1 - I * sqrt(2) assert RootOf(x**2 + 2 * x + 3, 1) == -1 + I * sqrt(2) assert RootOf(x**2 + 2 * x + 3, -1) == -1 + I * sqrt(2) assert RootOf(x**2 + 2 * x + 3, -2) == -1 - I * sqrt(2) r = RootOf(x**2 + 2 * x + 3, 0, radicals=False) assert isinstance(r, RootOf) is True r = RootOf(x**2 + 2 * x + 3, 1, radicals=False) assert isinstance(r, RootOf) is True r = RootOf(x**2 + 2 * x + 3, -1, radicals=False) assert isinstance(r, RootOf) is True r = RootOf(x**2 + 2 * x + 3, -2, radicals=False) assert isinstance(r, RootOf) is True assert RootOf((x - 1) * (x + 1), 0, radicals=False) == -1 assert RootOf((x - 1) * (x + 1), 1, radicals=False) == 1 assert RootOf((x - 1) * (x + 1), -1, radicals=False) == 1 assert RootOf((x - 1) * (x + 1), -2, radicals=False) == -1 assert RootOf((x - 1) * (x + 1), 0, radicals=True) == -1 assert RootOf((x - 1) * (x + 1), 1, radicals=True) == 1 assert RootOf((x - 1) * (x + 1), -1, radicals=True) == 1 assert RootOf((x - 1) * (x + 1), -2, radicals=True) == -1 assert RootOf((x - 1) * (x**3 + x + 3), 0) == RootOf(x**3 + x + 3, 0) assert RootOf((x - 1) * (x**3 + x + 3), 1) == 1 assert RootOf((x - 1) * (x**3 + x + 3), 2) == RootOf(x**3 + x + 3, 1) assert RootOf((x - 1) * (x**3 + x + 3), 3) == RootOf(x**3 + x + 3, 2) assert RootOf((x - 1) * (x**3 + x + 3), -1) == RootOf(x**3 + x + 3, 2) assert RootOf((x - 1) * (x**3 + x + 3), -2) == RootOf(x**3 + x + 3, 1) assert RootOf((x - 1) * (x**3 + x + 3), -3) == 1 assert RootOf((x - 1) * (x**3 + x + 3), -4) == RootOf(x**3 + x + 3, 0) assert RootOf(x**4 + 3 * x**3, 0) == -3 assert RootOf(x**4 + 3 * x**3, 1) == 0 assert RootOf(x**4 + 3 * x**3, 2) == 0 assert RootOf(x**4 + 3 * x**3, 3) == 0 pytest.raises(GeneratorsNeeded, lambda: RootOf(0, 0)) pytest.raises(GeneratorsNeeded, lambda: RootOf(1, 0)) pytest.raises(PolynomialError, lambda: RootOf(Poly(0, x), 0)) pytest.raises(PolynomialError, lambda: RootOf(Poly(1, x), 0)) pytest.raises(PolynomialError, lambda: RootOf(x - y, 0)) pytest.raises(NotImplementedError, lambda: RootOf(x**3 - x + sqrt(2), 0)) pytest.raises(NotImplementedError, lambda: RootOf(x**3 - x + I, 0)) pytest.raises(IndexError, lambda: RootOf(x**2 - 1, -4)) pytest.raises(IndexError, lambda: RootOf(x**2 - 1, -3)) pytest.raises(IndexError, lambda: RootOf(x**2 - 1, 2)) pytest.raises(IndexError, lambda: RootOf(x**2 - 1, 3)) pytest.raises(ValueError, lambda: RootOf(x**2 - 1, x)) assert RootOf(Poly(x - y, x), 0) == y assert RootOf(Poly(x**2 - y, x), 0) == -sqrt(y) assert RootOf(Poly(x**2 - y, x), 1) == sqrt(y) assert RootOf(Poly(x**3 - y, x), 0) == y**Rational(1, 3) assert RootOf(y * x**3 + y * x + 2 * y, x, 0) == -1 pytest.raises(NotImplementedError, lambda: RootOf(x**3 + x + 2 * y, x, 0)) assert RootOf(x**3 + x + 1, 0).is_commutative is True
def test_heurisch_radicals(): assert heurisch(1 / sqrt(x), x) == 2 * sqrt(x) assert heurisch(1 / sqrt(x)**3, x) == -2 / sqrt(x) assert heurisch(sqrt(x)**3, x) == 2 * sqrt(x)**5 / 5 assert heurisch(sin(x) * sqrt(cos(x)), x) == -2 * sqrt(cos(x))**3 / 3 y = Symbol('y') assert heurisch(sin(y*sqrt(x)), x) == 2/y**2*sin(y*sqrt(x)) - \ 2*sqrt(x)*cos(y*sqrt(x))/y assert heurisch_wrapper(sin(y * sqrt(x)), x) == Piecewise( (0, Eq(y, 0)), (-2 * sqrt(x) * cos(sqrt(x) * y) / y + 2 * sin(sqrt(x) * y) / y**2, True)) y = Symbol('y', positive=True) assert heurisch_wrapper(sin(y*sqrt(x)), x) == 2/y**2*sin(y*sqrt(x)) - \ 2*sqrt(x)*cos(y*sqrt(x))/y
def test_point3D(): p1 = Point3D(x1, x2, x3) p2 = Point3D(y1, y2, y3) p3 = Point3D(0, 0, 0) p4 = Point3D(1, 1, 1) p5 = Point3D(0, 1, 2) assert p1 in p1 assert p1 not in p2 assert p2.y == y2 assert (p3 + p4) == p4 assert (p2 - p1) == Point3D(y1 - x1, y2 - x2, y3 - x3) assert p4 * 5 == Point3D(5, 5, 5) assert -p2 == Point3D(-y1, -y2, -y3) assert Point(34.05, sqrt(3)) == Point(Rational(681, 20), sqrt(3)) assert Point3D.midpoint(p3, p4) == Point3D(half, half, half) assert Point3D.midpoint(p1, p4) == Point3D(half + half * x1, half + half * x2, half + half * x3) assert Point3D.midpoint(p2, p2) == p2 assert p2.midpoint(p2) == p2 assert Point3D.distance(p3, p4) == sqrt(3) assert Point3D.distance(p1, p1) == 0 assert Point3D.distance(p3, p2) == sqrt(p2.x**2 + p2.y**2 + p2.z**2) p1_1 = Point3D(x1, x1, x1) p1_2 = Point3D(y2, y2, y2) p1_3 = Point3D(x1 + 1, x1, x1) # according to the description in the docs, points are collinear # if they like on a single line. Thus a single point should always # be collinear assert Point3D.are_collinear(p3) assert Point3D.are_collinear(p3, p4) assert Point3D.are_collinear(p3, p4, p1_1, p1_2) assert Point3D.are_collinear(p3, p4, p1_1, p1_3) is False assert Point3D.are_collinear(p3, p3, p4, p5) is False assert p3.intersection(Point3D(0, 0, 0)) == [p3] assert p3.intersection(p4) == [] assert p4 * 5 == Point3D(5, 5, 5) assert p4 / 5 == Point3D(0.2, 0.2, 0.2) pytest.raises(ValueError, lambda: Point3D(0, 0, 0) + 10) # Point differences should be simplified assert Point3D(x*(x - 1), y, 2) - Point3D(x**2 - x, y + 1, 1) == \ Point3D(0, -1, 1) a, b = Rational(1, 2), Rational(1, 3) assert Point(a, b).evalf(2) == \ Point(a.evalf(2), b.evalf(2)) pytest.raises(ValueError, lambda: Point(1, 2) + 1) # test transformations p = Point3D(1, 1, 1) assert p.scale(2, 3) == Point3D(2, 3, 1) assert p.translate(1, 2) == Point3D(2, 3, 1) assert p.translate(1) == Point3D(2, 1, 1) assert p.translate(z=1) == Point3D(1, 1, 2) assert p.translate(*p.args) == Point3D(2, 2, 2) # Test __new__ assert Point3D(Point3D(1, 2, 3), 4, 5, evaluate=False) == Point3D(1, 2, 3) # Test length property returns correctly assert p.length == 0 assert p1_1.length == 0 assert p1_2.length == 0 # Test are_colinear type error pytest.raises(TypeError, lambda: Point3D.are_collinear(p, x)) # Test are_coplanar planar2 = Point3D(1, -1, 1) planar3 = Point3D(-1, 1, 1) assert Point3D.are_coplanar(p, planar2, planar3) is True assert Point3D.are_coplanar(p, planar2, planar3, p3) is False pytest.raises(ValueError, lambda: Point3D.are_coplanar(p, planar2)) planar2 = Point3D(1, 1, 2) planar3 = Point3D(1, 1, 3) pytest.raises(ValueError, lambda: Point3D.are_coplanar(p, planar2, planar3)) # Test Intersection assert planar2.intersection(Line3D(p, planar3)) == [Point3D(1, 1, 2)] # Test Scale assert planar2.scale(1, 1, 1) == planar2 assert planar2.scale(2, 2, 2, planar3) == Point3D(1, 1, 1) assert planar2.scale(1, 1, 1, p3) == planar2 # Test Transform identity = Matrix([[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1]]) assert p.transform(identity) == p trans = Matrix([[1, 0, 0, 1], [0, 1, 0, 1], [0, 0, 1, 1], [0, 0, 0, 1]]) assert p.transform(trans) == Point3D(2, 2, 2) pytest.raises(ValueError, lambda: p.transform(p)) pytest.raises(ValueError, lambda: p.transform(Matrix([[1, 0], [0, 1]]))) # Test Equals assert p.equals(x1) is False # Test __sub__ p_2d = Point(0, 0) pytest.raises(ValueError, lambda: (p - p_2d))
def test_lineintegral(): c = Curve([E**t + 1, E**t - 1], (t, 0, ln(2))) assert line_integrate(x + y, c, [x, y]) == 3*sqrt(2)
def test_Point2D(): p1 = Point2D(1, 5) p2 = Point2D(4, 2.5) p3 = Point2D(6.1, 3.5) assert p1.distance(p2) == sqrt(61) / 2 assert p2.distance(p3) == sqrt(541) / 10
def test_sqrtdenest2(): assert sqrtdenest(sqrt(16 - 2*r29 + 2*sqrt(55 - 10*r29))) == \ r5 + sqrt(11 - 2*r29) e = sqrt(-r5 + sqrt(-2 * r29 + 2 * sqrt(-10 * r29 + 55) + 16)) assert sqrtdenest(e) == root(-2 * r29 + 11, 4) r = sqrt(1 + r7) assert sqrtdenest(sqrt(1 + r)) == sqrt(1 + r) e = sqrt(((1 + sqrt(1 + 2 * sqrt(3 + r2 + r5)))**2).expand()) assert sqrtdenest(e) == 1 + sqrt(1 + 2 * sqrt(r2 + r5 + 3)) assert sqrtdenest(sqrt(5 * r3 + 6 * r2)) == sqrt(2) * root(3, 4) + root(27, 4) assert sqrtdenest(sqrt(((1 + r5 + sqrt(1 + r3))**2).expand())) == \ 1 + r5 + sqrt(1 + r3) assert sqrtdenest(sqrt(((1 + r5 + r7 + sqrt(1 + r3))**2).expand())) == \ 1 + sqrt(1 + r3) + r5 + r7 e = sqrt(((1 + cos(2) + cos(3) + sqrt(1 + r3))**2).expand()) assert sqrtdenest(e) == cos(3) + cos(2) + 1 + sqrt(1 + r3) e = sqrt(-2 * r10 + 2 * r2 * sqrt(-2 * r10 + 11) + 14) assert sqrtdenest(e) == sqrt(-2 * r10 - 2 * r2 + 4 * r5 + 14) # check that the result is not more complicated than the input z = sqrt(-2 * r29 + cos(2) + 2 * sqrt(-10 * r29 + 55) + 16) assert sqrtdenest(z) == z assert sqrtdenest(sqrt(r6 + sqrt(15))) == sqrt(r6 + sqrt(15)) z = sqrt(15 - 2 * sqrt(31) + 2 * sqrt(55 - 10 * r29)) assert sqrtdenest(z) == z
def test_direction_cosine(): p1 = Point3D(0, 0, 0) p2 = Point3D(1, 1, 1) assert p1.direction_cosine(Point3D(1, 0, 0)) == [1, 0, 0] assert p1.direction_cosine(Point3D(0, 1, 0)) == [0, 1, 0] assert p1.direction_cosine(Point3D(0, 0, pi)) == [0, 0, 1] assert p1.direction_cosine(Point3D(5, 0, 0)) == [1, 0, 0] assert p1.direction_cosine(Point3D(0, sqrt(3), 0)) == [0, 1, 0] assert p1.direction_cosine(Point3D(0, 0, 5)) == [0, 0, 1] assert p1.direction_cosine(Point3D(2.4, 2.4, 0)) == [sqrt(2) / 2, sqrt(2) / 2, 0] assert p1.direction_cosine(Point3D( 1, 1, 1)) == [sqrt(3) / 3, sqrt(3) / 3, sqrt(3) / 3] assert p1.direction_cosine(Point3D( -12, 0, -15)) == [-4 * sqrt(41) / 41, 0, -5 * sqrt(41) / 41] assert p2.direction_cosine(Point3D( 0, 0, 0)) == [-sqrt(3) / 3, -sqrt(3) / 3, -sqrt(3) / 3] assert p2.direction_cosine(Point3D(1, 1, 12)) == [0, 0, 1] assert p2.direction_cosine(Point3D(12, 1, 12)) == [sqrt(2) / 2, 0, sqrt(2) / 2]
def test_sympyissue_5653(): assert sqrtdenest(sqrt(2 + sqrt(2 + sqrt(2)))) == sqrt(2 + sqrt(2 + sqrt(2)))
def test_point(): p1 = Point(x1, x2) p2 = Point(y1, y2) p3 = Point(0, 0) p4 = Point(1, 1) p5 = Point(0, 1) assert p1.origin == p3 assert p1.ambient_dimension == 2 assert p1 in p1 assert p1 not in p2 assert p2.y == y2 assert (p3 + p4) == p4 assert (p2 - p1) == Point(y1 - x1, y2 - x2) assert p4 * 5 == Point(5, 5) assert -p2 == Point(-y1, -y2) pytest.raises(ValueError, lambda: Point(3, I)) pytest.raises(ValueError, lambda: Point(2 * I, I)) pytest.raises(ValueError, lambda: Point(3 + I, I)) assert Point(34.05, sqrt(3)) == Point(Rational(681, 20), sqrt(3)) assert Point.midpoint(p3, p4) == Point(half, half) assert Point.midpoint(p1, p4) == Point(half + half * x1, half + half * x2) assert Point.midpoint(p2, p2) == p2 assert p2.midpoint(p2) == p2 assert Point.distance(p3, p4) == sqrt(2) assert Point.distance(p1, p1) == 0 assert Point.distance(p3, p2) == sqrt(p2.x**2 + p2.y**2) p1_1 = Point(x1, x1) p1_2 = Point(y2, y2) p1_3 = Point(x1 + 1, x1) assert Point.is_collinear() is False assert Point.is_collinear(p3) assert Point.is_collinear(p3, p4) assert Point.is_collinear(p3, p4, p1_1, p1_2) assert Point.is_collinear(p3, p4, p1_1, p1_3) is False assert Point.is_collinear(p3, p3, p4, p5) is False line = Line(Point(1, 0), slope=1) pytest.raises(TypeError, lambda: Point.is_collinear(line)) pytest.raises(TypeError, lambda: p1_1.is_collinear(line)) assert p3.intersection(Point(0, 0)) == [p3] assert p3.intersection(p4) == [] x_pos = Symbol('x', real=True, positive=True) p2_1 = Point(x_pos, 0) p2_2 = Point(0, x_pos) p2_3 = Point(-x_pos, 0) p2_4 = Point(0, -x_pos) p2_5 = Point(x_pos, 5) assert Point.is_concyclic(p2_1) assert Point.is_concyclic(p2_1, p2_2) assert Point.is_concyclic(p2_1, p2_2, p2_3, p2_4) assert Point.is_concyclic(p2_1, p2_2, p2_3, p2_5) is False assert Point.is_concyclic(p4, p4 * 2, p4 * 3) is False pytest.raises(TypeError, lambda: Point.is_concyclic(p2_1, "123")) assert p4.scale(2, 3) == Point(2, 3) assert p3.scale(2, 3) == p3 assert p4.rotate(pi, Point(0.5, 0.5)) == p3 assert p1.__radd__(p2) == p1.midpoint(p2).scale(2, 2) assert (-p3).__rsub__(p4) == p3.midpoint(p4).scale(2, 2) assert p4 * 5 == Point(5, 5) assert p4 / 5 == Point(0.2, 0.2) pytest.raises(ValueError, lambda: Point(0, 0) + 10) # Point differences should be simplified assert Point(x * (x - 1), y) - Point(x**2 - x, y + 1) == Point(0, -1) a, b = Rational(1, 2), Rational(1, 3) assert Point(a, b).evalf(2) == \ Point(a.evalf(2), b.evalf(2)) pytest.raises(ValueError, lambda: Point(1, 2) + 1) # test transformations p = Point(1, 0) assert p.rotate(pi / 2) == Point(0, 1) assert p.rotate(pi / 2, p) == p p = Point(1, 1) assert p.scale(2, 3) == Point(2, 3) assert p.translate(1, 2) == Point(2, 3) assert p.translate(1) == Point(2, 1) assert p.translate(y=1) == Point(1, 2) assert p.translate(*p.args) == Point(2, 2) # Check invalid input for transform pytest.raises(ValueError, lambda: p3.transform(p3)) pytest.raises(ValueError, lambda: p.transform(Matrix([[1, 0], [0, 1]])))
def test_sympyissue_6343(): eq = -3 * x**2 / 2 - 45 * x / 4 + Rational(33, 2) > 0 assert reduce_inequalities(eq) == \ And(x < -Rational(15, 4) + sqrt(401)/4, -sqrt(401)/4 - Rational(15, 4) < x)
def test_powsimp(): x, y, z, n = symbols('x,y,z,n') f = Function('f') assert powsimp( 4**x * 2**(-x) * 2**(-x) ) == 1 assert powsimp( (-4)**x * (-2)**(-x) * 2**(-x) ) == 1 assert powsimp( f(4**x * 2**(-x) * 2**(-x)) ) == f(4**x * 2**(-x) * 2**(-x)) assert powsimp( f(4**x * 2**(-x) * 2**(-x)), deep=True ) == f(1) assert exp(x)*exp(y) == exp(x)*exp(y) assert powsimp(exp(x)*exp(y)) == exp(x + y) assert powsimp(exp(x)*exp(y)*2**x*2**y) == (2*E)**(x + y) assert powsimp(exp(x)*exp(y)*2**x*2**y, combine='exp') == \ exp(x + y)*2**(x + y) assert powsimp(exp(x)*exp(y)*exp(2)*sin(x) + sin(y) + 2**x*2**y) == \ exp(2 + x + y)*sin(x) + sin(y) + 2**(x + y) assert powsimp(sin(exp(x)*exp(y))) == sin(exp(x)*exp(y)) assert powsimp(sin(exp(x)*exp(y)), deep=True) == sin(exp(x + y)) assert powsimp(x**2*x**y) == x**(2 + y) # This should remain factored, because 'exp' with deep=True is supposed # to act like old automatic exponent combining. assert powsimp((1 + E*exp(E))*exp(-E), combine='exp', deep=True) == \ (1 + exp(1 + E))*exp(-E) assert powsimp((1 + E*exp(E))*exp(-E), deep=True) == \ (1 + exp(1 + E))*exp(-E) assert powsimp((1 + E*exp(E))*exp(-E)) == (1 + exp(1 + E))*exp(-E) assert powsimp((1 + E*exp(E))*exp(-E), combine='exp') == \ (1 + exp(1 + E))*exp(-E) assert powsimp((1 + E*exp(E))*exp(-E), combine='base') == \ (1 + E*exp(E))*exp(-E) x, y = symbols('x,y', nonnegative=True) n = Symbol('n', extended_real=True) assert powsimp(y**n * (y/x)**(-n)) == x**n assert powsimp(x**(x**(x*y)*y**(x*y))*y**(x**(x*y)*y**(x*y)), deep=True) \ == (x*y)**(x*y)**(x*y) assert powsimp(2**(2**(2*x)*x), deep=False) == 2**(2**(2*x)*x) assert powsimp(2**(2**(2*x)*x), deep=True) == 2**(x*4**x) assert powsimp( exp(-x + exp(-x)*exp(-x*log(x))), deep=False, combine='exp') == \ exp(-x + exp(-x)*exp(-x*log(x))) assert powsimp( exp(-x + exp(-x)*exp(-x*log(x))), deep=False, combine='exp') == \ exp(-x + exp(-x)*exp(-x*log(x))) assert powsimp((x + y)/(3*z), deep=False, combine='exp') == (x + y)/(3*z) assert powsimp((x/3 + y/3)/z, deep=True, combine='exp') == (x/3 + y/3)/z assert powsimp(exp(x)/(1 + exp(x)*exp(y)), deep=True) == \ exp(x)/(1 + exp(x + y)) assert powsimp(x*y**(z**x*z**y), deep=True) == x*y**(z**(x + y)) assert powsimp((z**x*z**y)**x, deep=True) == (z**(x + y))**x assert powsimp(x*(z**x*z**y)**x, deep=True) == x*(z**(x + y))**x p = symbols('p', positive=True) assert powsimp((1/x)**log(2)/x) == (1/x)**(1 + log(2)) assert powsimp((1/p)**log(2)/p) == p**(-1 - log(2)) # coefficient of exponent can only be simplified for positive bases assert powsimp(2**(2*x)) == 4**x assert powsimp((-1)**(2*x)) == (-1)**(2*x) i = symbols('i', integer=True) assert powsimp((-1)**(2*i)) == 1 assert powsimp((-1)**(-x)) != (-1)**x # could be 1/((-1)**x), but is not # force=True overrides assumptions assert powsimp((-1)**(2*x), force=True) == 1 # rational exponents allow combining of negative terms w, n, m = symbols('w n m', negative=True) e = i/a # not a rational exponent if `a` is unknown ex = w**e*n**e*m**e assert powsimp(ex) == m**(i/a)*n**(i/a)*w**(i/a) e = i/3 ex = w**e*n**e*m**e assert powsimp(ex) == (-1)**i*(-m*n*w)**(i/3) e = (3 + i)/i ex = w**e*n**e*m**e assert powsimp(ex) == (-1)**(3*e)*(-m*n*w)**e eq = x**(2*a/3) # eq != (x**a)**(2/3) (try x = -1 and a = 3 to see) assert powsimp(eq).exp == eq.exp == 2*a/3 # powdenest goes the other direction assert powsimp(2**(2*x)) == 4**x assert powsimp(exp(p/2)) == exp(p/2) # issue sympy/sympy#6368 eq = Mul(*[sqrt(Dummy(imaginary=True)) for i in range(3)]) assert powsimp(eq) == eq and eq.is_Mul assert all(powsimp(e) == e for e in (sqrt(x**a), sqrt(x**2))) # issue sympy/sympy#8836 assert str( powsimp(exp(I*pi/3)*root(-1, 3)) ) == '(-1)**(2/3)'
def test_Domain_preprocess(): assert Domain.preprocess(ZZ) == ZZ assert Domain.preprocess(QQ) == QQ assert Domain.preprocess(EX) == EX assert Domain.preprocess(FF(2)) == FF(2) assert Domain.preprocess(ZZ.poly_ring(x, y)) == ZZ.poly_ring(x, y) assert Domain.preprocess('Z') == ZZ assert Domain.preprocess('Q') == QQ assert Domain.preprocess('ZZ') == ZZ assert Domain.preprocess('QQ') == QQ assert Domain.preprocess('EX') == EX assert Domain.preprocess('FF(23)') == FF(23) assert Domain.preprocess('GF(23)') == GF(23) pytest.raises(OptionError, lambda: Domain.preprocess('Z[]')) assert Domain.preprocess('Z[x]') == ZZ.poly_ring(x) assert Domain.preprocess('Q[x]') == QQ.poly_ring(x) assert Domain.preprocess('ZZ[x]') == ZZ.poly_ring(x) assert Domain.preprocess('QQ[x]') == QQ.poly_ring(x) assert Domain.preprocess('Z[x,y]') == ZZ.poly_ring(x, y) assert Domain.preprocess('Q[x,y]') == QQ.poly_ring(x, y) assert Domain.preprocess('ZZ[x,y]') == ZZ.poly_ring(x, y) assert Domain.preprocess('QQ[x,y]') == QQ.poly_ring(x, y) pytest.raises(OptionError, lambda: Domain.preprocess('Z()')) assert Domain.preprocess('Z(x)') == ZZ.frac_field(x) assert Domain.preprocess('Q(x)') == QQ.frac_field(x) assert Domain.preprocess('ZZ(x)') == ZZ.frac_field(x) assert Domain.preprocess('QQ(x)') == QQ.frac_field(x) assert Domain.preprocess('Z(x,y)') == ZZ.frac_field(x, y) assert Domain.preprocess('Q(x,y)') == QQ.frac_field(x, y) assert Domain.preprocess('ZZ(x,y)') == ZZ.frac_field(x, y) assert Domain.preprocess('QQ(x,y)') == QQ.frac_field(x, y) assert Domain.preprocess('Q<I>') == QQ.algebraic_field(I) assert Domain.preprocess('QQ<I>') == QQ.algebraic_field(I) assert Domain.preprocess('Q<sqrt(2), I>') == QQ.algebraic_field(sqrt(2), I) assert Domain.preprocess('QQ<sqrt(2), I>') == QQ.algebraic_field( sqrt(2), I) pytest.raises(OptionError, lambda: Domain.preprocess('abc')) assert Domain.preprocess('RR') == RR assert Domain.preprocess('RR_5') == RealField(prec=5) assert Domain.preprocess('CC') == CC assert Domain.preprocess('CC_5') == ComplexField(prec=5) pytest.raises(OptionError, lambda: Domain.preprocess(()))
def test_reduce_poly_inequalities_real_interval(): assert reduce_rational_inequalities([[Eq(x**2, 0)]], x, relational=False) == FiniteSet(0) assert reduce_rational_inequalities([[Le(x**2, 0)]], x, relational=False) == FiniteSet(0) assert reduce_rational_inequalities([[Lt(x**2, 0)]], x, relational=False) == S.EmptySet assert reduce_rational_inequalities( [[Ge(x**2, 0)]], x, relational=False) == \ S.Reals if x.is_extended_real else Interval(-oo, oo) assert reduce_rational_inequalities( [[Gt(x**2, 0)]], x, relational=False) == \ FiniteSet(0).complement(S.Reals) assert reduce_rational_inequalities( [[Ne(x**2, 0)]], x, relational=False) == \ FiniteSet(0).complement(S.Reals) assert reduce_rational_inequalities([[Eq(x**2, 1)]], x, relational=False) == FiniteSet(-1, 1) assert reduce_rational_inequalities([[Le(x**2, 1)]], x, relational=False) == Interval(-1, 1) assert reduce_rational_inequalities([[Lt(x**2, 1)]], x, relational=False) == Interval( -1, 1, True, True) assert reduce_rational_inequalities( [[Ge(x**2, 1)]], x, relational=False) == \ Union(Interval(-oo, -1, True), Interval(1, oo, False, True)) assert reduce_rational_inequalities( [[Gt(x**2, 1)]], x, relational=False) == \ Interval(-1, 1).complement(S.Reals) assert reduce_rational_inequalities( [[Ne(x**2, 1)]], x, relational=False) == \ FiniteSet(-1, 1).complement(S.Reals) assert reduce_rational_inequalities([[Eq(x**2, 1.0)]], x, relational=False) == FiniteSet( -1.0, 1.0).evalf() assert reduce_rational_inequalities([[Le(x**2, 1.0)]], x, relational=False) == Interval( -1.0, 1.0) assert reduce_rational_inequalities([[Lt(x**2, 1.0)]], x, relational=False) == Interval( -1.0, 1.0, True, True) assert reduce_rational_inequalities( [[Ge(x**2, 1.0)]], x, relational=False) == \ Union(Interval(-inf, -1.0, True), Interval(1.0, inf, False, True)) assert reduce_rational_inequalities( [[Gt(x**2, 1.0)]], x, relational=False) == \ Union(Interval(-inf, -1.0, True, True), Interval(1.0, inf, True, True)) assert reduce_rational_inequalities([[Ne( x**2, 1.0)]], x, relational=False) == \ FiniteSet(-1.0, 1.0).complement(S.Reals) s = sqrt(2) assert reduce_rational_inequalities( [[Lt(x**2 - 1, 0), Gt(x**2 - 1, 0)]], x, relational=False) == S.EmptySet assert reduce_rational_inequalities( [[Le(x**2 - 1, 0), Ge(x**2 - 1, 0)]], x, relational=False) == FiniteSet(-1, 1) assert reduce_rational_inequalities( [[Le(x**2 - 2, 0), Ge(x**2 - 1, 0)]], x, relational=False) == Union(Interval(-s, -1, False, False), Interval(1, s, False, False)) assert reduce_rational_inequalities( [[Le(x**2 - 2, 0), Gt(x**2 - 1, 0)]], x, relational=False) == Union(Interval(-s, -1, False, True), Interval(1, s, True, False)) assert reduce_rational_inequalities( [[Lt(x**2 - 2, 0), Ge(x**2 - 1, 0)]], x, relational=False) == Union(Interval(-s, -1, True, False), Interval(1, s, False, True)) assert reduce_rational_inequalities( [[Lt(x**2 - 2, 0), Gt(x**2 - 1, 0)]], x, relational=False) == Union(Interval(-s, -1, True, True), Interval(1, s, True, True)) assert reduce_rational_inequalities( [[Lt(x**2 - 2, 0), Ne(x**2 - 1, 0)]], x, relational=False) == Union(Interval(-s, -1, True, True), Interval(-1, 1, True, True), Interval(1, s, True, True)) # issue sympy/sympy#10237 assert reduce_rational_inequalities([[x < oo, x >= 0, -oo < x]], x, relational=False) == Interval( 0, oo, False, True) assert reduce_rational_inequalities([[Eq( (x + 1) / (x**2 - 1), 0)]], x) is false