|
|
from sympy.concrete.summations import Sum |
|
|
from sympy.core.add import Add |
|
|
from sympy.core.basic import Basic |
|
|
from sympy.core.expr import unchanged |
|
|
from sympy.core.function import (count_ops, diff, expand, expand_multinomial, Function, Derivative) |
|
|
from sympy.core.mul import Mul, _keep_coeff |
|
|
from sympy.core import GoldenRatio |
|
|
from sympy.core.numbers import (E, Float, I, oo, pi, Rational, zoo) |
|
|
from sympy.core.relational import (Eq, Lt, Gt, Ge, Le) |
|
|
from sympy.core.singleton import S |
|
|
from sympy.core.symbol import (Symbol, symbols) |
|
|
from sympy.core.sympify import sympify |
|
|
from sympy.functions.combinatorial.factorials import (binomial, factorial) |
|
|
from sympy.functions.elementary.complexes import (Abs, sign) |
|
|
from sympy.functions.elementary.exponential import (exp, exp_polar, log) |
|
|
from sympy.functions.elementary.hyperbolic import (cosh, csch, sinh) |
|
|
from sympy.functions.elementary.miscellaneous import sqrt |
|
|
from sympy.functions.elementary.piecewise import Piecewise |
|
|
from sympy.functions.elementary.trigonometric import (acos, asin, atan, cos, sin, sinc, tan) |
|
|
from sympy.functions.special.error_functions import erf |
|
|
from sympy.functions.special.gamma_functions import gamma |
|
|
from sympy.functions.special.hyper import hyper |
|
|
from sympy.functions.special.tensor_functions import KroneckerDelta |
|
|
from sympy.geometry.polygon import rad |
|
|
from sympy.integrals.integrals import (Integral, integrate) |
|
|
from sympy.logic.boolalg import (And, Or) |
|
|
from sympy.matrices.dense import (Matrix, eye) |
|
|
from sympy.matrices.expressions.matexpr import MatrixSymbol |
|
|
from sympy.polys.polytools import (factor, Poly) |
|
|
from sympy.simplify.simplify import (besselsimp, hypersimp, inversecombine, logcombine, nsimplify, nthroot, posify, separatevars, signsimp, simplify) |
|
|
from sympy.solvers.solvers import solve |
|
|
|
|
|
from sympy.testing.pytest import XFAIL, slow, _both_exp_pow |
|
|
from sympy.abc import x, y, z, t, a, b, c, d, e, f, g, h, i, n |
|
|
|
|
|
|
|
|
def test_issue_7263(): |
|
|
assert abs((simplify(30.8**2 - 82.5**2 * sin(rad(11.6))**2)).evalf() - \ |
|
|
673.447451402970) < 1e-12 |
|
|
|
|
|
|
|
|
def test_factorial_simplify(): |
|
|
|
|
|
x = Symbol('x') |
|
|
assert simplify(factorial(x)/x) == gamma(x) |
|
|
assert simplify(factorial(factorial(x))) == factorial(factorial(x)) |
|
|
|
|
|
|
|
|
def test_simplify_expr(): |
|
|
x, y, z, k, n, m, w, s, A = symbols('x,y,z,k,n,m,w,s,A') |
|
|
f = Function('f') |
|
|
|
|
|
assert all(simplify(tmp) == tmp for tmp in [I, E, oo, x, -x, -oo, -E, -I]) |
|
|
|
|
|
e = 1/x + 1/y |
|
|
assert e != (x + y)/(x*y) |
|
|
assert simplify(e) == (x + y)/(x*y) |
|
|
|
|
|
e = A**2*s**4/(4*pi*k*m**3) |
|
|
assert simplify(e) == e |
|
|
|
|
|
e = (4 + 4*x - 2*(2 + 2*x))/(2 + 2*x) |
|
|
assert simplify(e) == 0 |
|
|
|
|
|
e = (-4*x*y**2 - 2*y**3 - 2*x**2*y)/(x + y)**2 |
|
|
assert simplify(e) == -2*y |
|
|
|
|
|
e = -x - y - (x + y)**(-1)*y**2 + (x + y)**(-1)*x**2 |
|
|
assert simplify(e) == -2*y |
|
|
|
|
|
e = (x + x*y)/x |
|
|
assert simplify(e) == 1 + y |
|
|
|
|
|
e = (f(x) + y*f(x))/f(x) |
|
|
assert simplify(e) == 1 + y |
|
|
|
|
|
e = (2 * (1/n - cos(n * pi)/n))/pi |
|
|
assert simplify(e) == (-cos(pi*n) + 1)/(pi*n)*2 |
|
|
|
|
|
e = integrate(1/(x**3 + 1), x).diff(x) |
|
|
assert simplify(e) == 1/(x**3 + 1) |
|
|
|
|
|
e = integrate(x/(x**2 + 3*x + 1), x).diff(x) |
|
|
assert simplify(e) == x/(x**2 + 3*x + 1) |
|
|
|
|
|
f = Symbol('f') |
|
|
A = Matrix([[2*k - m*w**2, -k], [-k, k - m*w**2]]).inv() |
|
|
assert simplify((A*Matrix([0, f]))[1] - |
|
|
(-f*(2*k - m*w**2)/(k**2 - (k - m*w**2)*(2*k - m*w**2)))) == 0 |
|
|
|
|
|
f = -x + y/(z + t) + z*x/(z + t) + z*a/(z + t) + t*x/(z + t) |
|
|
assert simplify(f) == (y + a*z)/(z + t) |
|
|
|
|
|
|
|
|
expr = -x*(y**2 - 1)*(2*y**2*(x**2 - 1)/(a*(x**2 - y**2)**2) + (x**2 - 1) |
|
|
/(a*(x**2 - y**2)))/(a*(x**2 - y**2)) + x*(-2*x**2*sqrt(-x**2*y**2 + x**2 |
|
|
+ y**2 - 1)*sin(z)/(a*(x**2 - y**2)**2) - x**2*sqrt(-x**2*y**2 + x**2 + |
|
|
y**2 - 1)*sin(z)/(a*(x**2 - 1)*(x**2 - y**2)) + (x**2*sqrt((-x**2 + 1)* |
|
|
(y**2 - 1))*sqrt(-x**2*y**2 + x**2 + y**2 - 1)*sin(z)/(x**2 - 1) + sqrt( |
|
|
(-x**2 + 1)*(y**2 - 1))*(x*(-x*y**2 + x)/sqrt(-x**2*y**2 + x**2 + y**2 - |
|
|
1) + sqrt(-x**2*y**2 + x**2 + y**2 - 1))*sin(z))/(a*sqrt((-x**2 + 1)*( |
|
|
y**2 - 1))*(x**2 - y**2)))*sqrt(-x**2*y**2 + x**2 + y**2 - 1)*sin(z)/(a* |
|
|
(x**2 - y**2)) + x*(-2*x**2*sqrt(-x**2*y**2 + x**2 + y**2 - 1)*cos(z)/(a* |
|
|
(x**2 - y**2)**2) - x**2*sqrt(-x**2*y**2 + x**2 + y**2 - 1)*cos(z)/(a* |
|
|
(x**2 - 1)*(x**2 - y**2)) + (x**2*sqrt((-x**2 + 1)*(y**2 - 1))*sqrt(-x**2 |
|
|
*y**2 + x**2 + y**2 - 1)*cos(z)/(x**2 - 1) + x*sqrt((-x**2 + 1)*(y**2 - |
|
|
1))*(-x*y**2 + x)*cos(z)/sqrt(-x**2*y**2 + x**2 + y**2 - 1) + sqrt((-x**2 |
|
|
+ 1)*(y**2 - 1))*sqrt(-x**2*y**2 + x**2 + y**2 - 1)*cos(z))/(a*sqrt((-x**2 |
|
|
+ 1)*(y**2 - 1))*(x**2 - y**2)))*sqrt(-x**2*y**2 + x**2 + y**2 - 1)*cos( |
|
|
z)/(a*(x**2 - y**2)) - y*sqrt((-x**2 + 1)*(y**2 - 1))*(-x*y*sqrt(-x**2* |
|
|
y**2 + x**2 + y**2 - 1)*sin(z)/(a*(x**2 - y**2)*(y**2 - 1)) + 2*x*y*sqrt( |
|
|
-x**2*y**2 + x**2 + y**2 - 1)*sin(z)/(a*(x**2 - y**2)**2) + (x*y*sqrt(( |
|
|
-x**2 + 1)*(y**2 - 1))*sqrt(-x**2*y**2 + x**2 + y**2 - 1)*sin(z)/(y**2 - |
|
|
1) + x*sqrt((-x**2 + 1)*(y**2 - 1))*(-x**2*y + y)*sin(z)/sqrt(-x**2*y**2 |
|
|
+ x**2 + y**2 - 1))/(a*sqrt((-x**2 + 1)*(y**2 - 1))*(x**2 - y**2)))*sin( |
|
|
z)/(a*(x**2 - y**2)) + y*(x**2 - 1)*(-2*x*y*(x**2 - 1)/(a*(x**2 - y**2) |
|
|
**2) + 2*x*y/(a*(x**2 - y**2)))/(a*(x**2 - y**2)) + y*(x**2 - 1)*(y**2 - |
|
|
1)*(-x*y*sqrt(-x**2*y**2 + x**2 + y**2 - 1)*cos(z)/(a*(x**2 - y**2)*(y**2 |
|
|
- 1)) + 2*x*y*sqrt(-x**2*y**2 + x**2 + y**2 - 1)*cos(z)/(a*(x**2 - y**2) |
|
|
**2) + (x*y*sqrt((-x**2 + 1)*(y**2 - 1))*sqrt(-x**2*y**2 + x**2 + y**2 - |
|
|
1)*cos(z)/(y**2 - 1) + x*sqrt((-x**2 + 1)*(y**2 - 1))*(-x**2*y + y)*cos( |
|
|
z)/sqrt(-x**2*y**2 + x**2 + y**2 - 1))/(a*sqrt((-x**2 + 1)*(y**2 - 1) |
|
|
)*(x**2 - y**2)))*cos(z)/(a*sqrt((-x**2 + 1)*(y**2 - 1))*(x**2 - y**2) |
|
|
) - x*sqrt((-x**2 + 1)*(y**2 - 1))*sqrt(-x**2*y**2 + x**2 + y**2 - 1)*sin( |
|
|
z)**2/(a**2*(x**2 - 1)*(x**2 - y**2)*(y**2 - 1)) - x*sqrt((-x**2 + 1)*( |
|
|
y**2 - 1))*sqrt(-x**2*y**2 + x**2 + y**2 - 1)*cos(z)**2/(a**2*(x**2 - 1)*( |
|
|
x**2 - y**2)*(y**2 - 1)) |
|
|
assert simplify(expr) == 2*x/(a**2*(x**2 - y**2)) |
|
|
|
|
|
|
|
|
assert simplify('((-1/2)*Boole(True)*Boole(False)-1)*Boole(True)') == \ |
|
|
Mul(sympify('(2 + Boole(True)*Boole(False))'), sympify('-Boole(True)/2')) |
|
|
|
|
|
A, B = symbols('A,B', commutative=False) |
|
|
|
|
|
assert simplify(A*B - B*A) == A*B - B*A |
|
|
assert simplify(A/(1 + y/x)) == x*A/(x + y) |
|
|
assert simplify(A*(1/x + 1/y)) == A/x + A/y |
|
|
|
|
|
assert simplify(log(2) + log(3)) == log(6) |
|
|
assert simplify(log(2*x) - log(2)) == log(x) |
|
|
|
|
|
assert simplify(hyper([], [], x)) == exp(x) |
|
|
|
|
|
|
|
|
def test_issue_3557(): |
|
|
f_1 = x*a + y*b + z*c - 1 |
|
|
f_2 = x*d + y*e + z*f - 1 |
|
|
f_3 = x*g + y*h + z*i - 1 |
|
|
|
|
|
solutions = solve([f_1, f_2, f_3], x, y, z, simplify=False) |
|
|
|
|
|
assert simplify(solutions[y]) == \ |
|
|
(a*i + c*d + f*g - a*f - c*g - d*i)/ \ |
|
|
(a*e*i + b*f*g + c*d*h - a*f*h - b*d*i - c*e*g) |
|
|
|
|
|
|
|
|
def test_simplify_other(): |
|
|
assert simplify(sin(x)**2 + cos(x)**2) == 1 |
|
|
assert simplify(gamma(x + 1)/gamma(x)) == x |
|
|
assert simplify(sin(x)**2 + cos(x)**2 + factorial(x)/gamma(x)) == 1 + x |
|
|
assert simplify( |
|
|
Eq(sin(x)**2 + cos(x)**2, factorial(x)/gamma(x))) == Eq(x, 1) |
|
|
nc = symbols('nc', commutative=False) |
|
|
assert simplify(x + x*nc) == x*(1 + nc) |
|
|
|
|
|
|
|
|
|
|
|
ans = I*(-pi*x*exp(I*pi*Rational(-3, 4) + I*x**2/(4*t))*erf(x*exp(I*pi*Rational(-3, 4))/ |
|
|
(2*sqrt(t)))/(2*sqrt(t)) + pi*x*exp(I*pi*Rational(-3, 4) + I*x**2/(4*t))/ |
|
|
(2*sqrt(t)))*exp(-I*x**2/(4*t))/(sqrt(pi)*x) - I*sqrt(pi) * \ |
|
|
(-erf(x*exp(I*pi/4)/(2*sqrt(t))) + 1)*exp(I*pi/4)/(2*sqrt(t)) |
|
|
assert simplify(ans) == -(-1)**Rational(3, 4)*sqrt(pi)/sqrt(t) |
|
|
|
|
|
assert simplify(2**(2 + x)/4) == 2**x |
|
|
|
|
|
|
|
|
@_both_exp_pow |
|
|
def test_simplify_complex(): |
|
|
cosAsExp = cos(x)._eval_rewrite_as_exp(x) |
|
|
tanAsExp = tan(x)._eval_rewrite_as_exp(x) |
|
|
assert simplify(cosAsExp*tanAsExp) == sin(x) |
|
|
|
|
|
|
|
|
assert simplify(exp(Matrix([[0, -1], [1, 0]]))) == Matrix([[cos(1), |
|
|
-sin(1)], [sin(1), cos(1)]]) |
|
|
|
|
|
|
|
|
def test_simplify_ratio(): |
|
|
|
|
|
roots = ['(1/2 - sqrt(3)*I/2)*(sqrt(21)/2 + 5/2)**(1/3) + 1/((1/2 - ' |
|
|
'sqrt(3)*I/2)*(sqrt(21)/2 + 5/2)**(1/3))', |
|
|
'1/((1/2 + sqrt(3)*I/2)*(sqrt(21)/2 + 5/2)**(1/3)) + ' |
|
|
'(1/2 + sqrt(3)*I/2)*(sqrt(21)/2 + 5/2)**(1/3)', |
|
|
'-(sqrt(21)/2 + 5/2)**(1/3) - 1/(sqrt(21)/2 + 5/2)**(1/3)'] |
|
|
|
|
|
for r in roots: |
|
|
r = S(r) |
|
|
assert count_ops(simplify(r, ratio=1)) <= count_ops(r) |
|
|
|
|
|
assert simplify(r, ratio=oo) is not r |
|
|
|
|
|
|
|
|
def test_simplify_measure(): |
|
|
measure1 = lambda expr: len(str(expr)) |
|
|
measure2 = lambda expr: -count_ops(expr) |
|
|
|
|
|
expr = (x + 1)/(x + sin(x)**2 + cos(x)**2) |
|
|
assert measure1(simplify(expr, measure=measure1)) <= measure1(expr) |
|
|
assert measure2(simplify(expr, measure=measure2)) <= measure2(expr) |
|
|
|
|
|
expr2 = Eq(sin(x)**2 + cos(x)**2, 1) |
|
|
assert measure1(simplify(expr2, measure=measure1)) <= measure1(expr2) |
|
|
assert measure2(simplify(expr2, measure=measure2)) <= measure2(expr2) |
|
|
|
|
|
|
|
|
def test_simplify_rational(): |
|
|
expr = 2**x*2.**y |
|
|
assert simplify(expr, rational = True) == 2**(x+y) |
|
|
assert simplify(expr, rational = None) == 2.0**(x+y) |
|
|
assert simplify(expr, rational = False) == expr |
|
|
assert simplify('0.9 - 0.8 - 0.1', rational = True) == 0 |
|
|
|
|
|
|
|
|
def test_simplify_issue_1308(): |
|
|
assert simplify(exp(Rational(-1, 2)) + exp(Rational(-3, 2))) == \ |
|
|
(1 + E)*exp(Rational(-3, 2)) |
|
|
|
|
|
|
|
|
def test_issue_5652(): |
|
|
assert simplify(E + exp(-E)) == exp(-E) + E |
|
|
n = symbols('n', commutative=False) |
|
|
assert simplify(n + n**(-n)) == n + n**(-n) |
|
|
|
|
|
def test_issue_27380(): |
|
|
assert simplify(1.0**(x+1)/1.0**x) == 1.0 |
|
|
|
|
|
def test_simplify_fail1(): |
|
|
x = Symbol('x') |
|
|
y = Symbol('y') |
|
|
e = (x + y)**2/(-4*x*y**2 - 2*y**3 - 2*x**2*y) |
|
|
assert simplify(e) == 1 / (-2*y) |
|
|
|
|
|
|
|
|
def test_nthroot(): |
|
|
assert nthroot(90 + 34*sqrt(7), 3) == sqrt(7) + 3 |
|
|
q = 1 + sqrt(2) - 2*sqrt(3) + sqrt(6) + sqrt(7) |
|
|
assert nthroot(expand_multinomial(q**3), 3) == q |
|
|
assert nthroot(41 + 29*sqrt(2), 5) == 1 + sqrt(2) |
|
|
assert nthroot(-41 - 29*sqrt(2), 5) == -1 - sqrt(2) |
|
|
expr = 1320*sqrt(10) + 4216 + 2576*sqrt(6) + 1640*sqrt(15) |
|
|
assert nthroot(expr, 5) == 1 + sqrt(6) + sqrt(15) |
|
|
q = 1 + sqrt(2) + sqrt(3) + sqrt(5) |
|
|
assert expand_multinomial(nthroot(expand_multinomial(q**5), 5)) == q |
|
|
q = 1 + sqrt(2) + 7*sqrt(6) + 2*sqrt(10) |
|
|
assert nthroot(expand_multinomial(q**5), 5, 8) == q |
|
|
q = 1 + sqrt(2) - 2*sqrt(3) + 1171*sqrt(6) |
|
|
assert nthroot(expand_multinomial(q**3), 3) == q |
|
|
assert nthroot(expand_multinomial(q**6), 6) == q |
|
|
|
|
|
|
|
|
def test_nthroot1(): |
|
|
q = 1 + sqrt(2) + sqrt(3) + S.One/10**20 |
|
|
p = expand_multinomial(q**5) |
|
|
assert nthroot(p, 5) == q |
|
|
q = 1 + sqrt(2) + sqrt(3) + S.One/10**30 |
|
|
p = expand_multinomial(q**5) |
|
|
assert nthroot(p, 5) == q |
|
|
|
|
|
|
|
|
@_both_exp_pow |
|
|
def test_separatevars(): |
|
|
x, y, z, n = symbols('x,y,z,n') |
|
|
assert separatevars(2*n*x*z + 2*x*y*z) == 2*x*z*(n + y) |
|
|
assert separatevars(x*z + x*y*z) == x*z*(1 + y) |
|
|
assert separatevars(pi*x*z + pi*x*y*z) == pi*x*z*(1 + y) |
|
|
assert separatevars(x*y**2*sin(x) + x*sin(x)*sin(y)) == \ |
|
|
x*(sin(y) + y**2)*sin(x) |
|
|
assert separatevars(x*exp(x + y) + x*exp(x)) == x*(1 + exp(y))*exp(x) |
|
|
assert separatevars((x*(y + 1))**z).is_Pow |
|
|
assert separatevars(1 + x + y + x*y) == (x + 1)*(y + 1) |
|
|
assert separatevars(y/pi*exp(-(z - x)/cos(n))) == \ |
|
|
y*exp(x/cos(n))*exp(-z/cos(n))/pi |
|
|
assert separatevars((x + y)*(x - y) + y**2 + 2*x + 1) == (x + 1)**2 |
|
|
|
|
|
p = Symbol('p', positive=True) |
|
|
assert separatevars(sqrt(p**2 + x*p**2)) == p*sqrt(1 + x) |
|
|
assert separatevars(sqrt(y*(p**2 + x*p**2))) == p*sqrt(y*(1 + x)) |
|
|
assert separatevars(sqrt(y*(p**2 + x*p**2)), force=True) == \ |
|
|
p*sqrt(y)*sqrt(1 + x) |
|
|
|
|
|
assert separatevars(sqrt(x*y)).is_Pow |
|
|
assert separatevars(sqrt(x*y), force=True) == sqrt(x)*sqrt(y) |
|
|
|
|
|
|
|
|
assert separatevars(((2*x + 2)*y), dict=True, symbols=()) == \ |
|
|
{'coeff': 1, x: 2*x + 2, y: y} |
|
|
|
|
|
assert separatevars(((2*x + 2)*y), dict=True, symbols=[x]) == \ |
|
|
{'coeff': y, x: 2*x + 2} |
|
|
assert separatevars(((2*x + 2)*y), dict=True, symbols=[]) == \ |
|
|
{'coeff': 1, x: 2*x + 2, y: y} |
|
|
assert separatevars(((2*x + 2)*y), dict=True) == \ |
|
|
{'coeff': 1, x: 2*x + 2, y: y} |
|
|
assert separatevars(((2*x + 2)*y), dict=True, symbols=None) == \ |
|
|
{'coeff': y*(2*x + 2)} |
|
|
|
|
|
assert separatevars(3, dict=True) is None |
|
|
assert separatevars(2*x + y, dict=True, symbols=()) is None |
|
|
assert separatevars(2*x + y, dict=True) is None |
|
|
assert separatevars(2*x + y, dict=True, symbols=None) == {'coeff': 2*x + y} |
|
|
|
|
|
n, m = symbols('n,m', commutative=False) |
|
|
assert separatevars(m + n*m) == (1 + n)*m |
|
|
assert separatevars(x + x*n) == x*(1 + n) |
|
|
|
|
|
f = Function('f') |
|
|
assert separatevars(f(x) + x*f(x)) == f(x) + x*f(x) |
|
|
|
|
|
eq = x*(1 + hyper((), (), y*z)) |
|
|
assert separatevars(eq) == eq |
|
|
|
|
|
s = separatevars(abs(x*y)) |
|
|
assert s == abs(x)*abs(y) and s.is_Mul |
|
|
z = cos(1)**2 + sin(1)**2 - 1 |
|
|
a = abs(x*z) |
|
|
s = separatevars(a) |
|
|
assert not a.is_Mul and s.is_Mul and s == abs(x)*abs(z) |
|
|
s = separatevars(abs(x*y*z)) |
|
|
assert s == abs(x)*abs(y)*abs(z) |
|
|
|
|
|
|
|
|
|
|
|
assert separatevars(abs((x+y)/z)) == abs((x+y)/z) |
|
|
|
|
|
|
|
|
def test_separatevars_advanced_factor(): |
|
|
x, y, z = symbols('x,y,z') |
|
|
assert separatevars(1 + log(x)*log(y) + log(x) + log(y)) == \ |
|
|
(log(x) + 1)*(log(y) + 1) |
|
|
assert separatevars(1 + x - log(z) - x*log(z) - exp(y)*log(z) - |
|
|
x*exp(y)*log(z) + x*exp(y) + exp(y)) == \ |
|
|
-((x + 1)*(log(z) - 1)*(exp(y) + 1)) |
|
|
x, y = symbols('x,y', positive=True) |
|
|
assert separatevars(1 + log(x**log(y)) + log(x*y)) == \ |
|
|
(log(x) + 1)*(log(y) + 1) |
|
|
|
|
|
|
|
|
def test_hypersimp(): |
|
|
n, k = symbols('n,k', integer=True) |
|
|
|
|
|
assert hypersimp(factorial(k), k) == k + 1 |
|
|
assert hypersimp(factorial(k**2), k) is None |
|
|
|
|
|
assert hypersimp(1/factorial(k), k) == 1/(k + 1) |
|
|
|
|
|
assert hypersimp(2**k/factorial(k)**2, k) == 2/(k + 1)**2 |
|
|
|
|
|
assert hypersimp(binomial(n, k), k) == (n - k)/(k + 1) |
|
|
assert hypersimp(binomial(n + 1, k), k) == (n - k + 1)/(k + 1) |
|
|
|
|
|
term = (4*k + 1)*factorial(k)/factorial(2*k + 1) |
|
|
assert hypersimp(term, k) == S.Half*((4*k + 5)/(3 + 14*k + 8*k**2)) |
|
|
|
|
|
term = 1/((2*k - 1)*factorial(2*k + 1)) |
|
|
assert hypersimp(term, k) == (k - S.Half)/((k + 1)*(2*k + 1)*(2*k + 3)) |
|
|
|
|
|
term = binomial(n, k)*(-1)**k/factorial(k) |
|
|
assert hypersimp(term, k) == (k - n)/(k + 1)**2 |
|
|
|
|
|
|
|
|
def test_nsimplify(): |
|
|
x = Symbol("x") |
|
|
assert nsimplify(0) == 0 |
|
|
assert nsimplify(-1) == -1 |
|
|
assert nsimplify(1) == 1 |
|
|
assert nsimplify(1 + x) == 1 + x |
|
|
assert nsimplify(2.7) == Rational(27, 10) |
|
|
assert nsimplify(1 - GoldenRatio) == (1 - sqrt(5))/2 |
|
|
assert nsimplify((1 + sqrt(5))/4, [GoldenRatio]) == GoldenRatio/2 |
|
|
assert nsimplify(2/GoldenRatio, [GoldenRatio]) == 2*GoldenRatio - 2 |
|
|
assert nsimplify(exp(pi*I*Rational(5, 3), evaluate=False)) == \ |
|
|
sympify('1/2 - sqrt(3)*I/2') |
|
|
assert nsimplify(sin(pi*Rational(3, 5), evaluate=False)) == \ |
|
|
sympify('sqrt(sqrt(5)/8 + 5/8)') |
|
|
assert nsimplify(sqrt(atan('1', evaluate=False))*(2 + I), [pi]) == \ |
|
|
sqrt(pi) + sqrt(pi)/2*I |
|
|
assert nsimplify(2 + exp(2*atan('1/4')*I)) == sympify('49/17 + 8*I/17') |
|
|
assert nsimplify(pi, tolerance=0.01) == Rational(22, 7) |
|
|
assert nsimplify(pi, tolerance=0.001) == Rational(355, 113) |
|
|
assert nsimplify(0.33333, tolerance=1e-4) == Rational(1, 3) |
|
|
assert nsimplify(2.0**(1/3.), tolerance=0.001) == Rational(635, 504) |
|
|
assert nsimplify(2.0**(1/3.), tolerance=0.001, full=True) == \ |
|
|
2**Rational(1, 3) |
|
|
assert nsimplify(x + .5, rational=True) == S.Half + x |
|
|
assert nsimplify(1/.3 + x, rational=True) == Rational(10, 3) + x |
|
|
assert nsimplify(log(3).n(), rational=True) == \ |
|
|
sympify('109861228866811/100000000000000') |
|
|
assert nsimplify(Float(0.272198261287950), [pi, log(2)]) == pi*log(2)/8 |
|
|
assert nsimplify(Float(0.272198261287950).n(3), [pi, log(2)]) == \ |
|
|
-pi/4 - log(2) + Rational(7, 4) |
|
|
assert nsimplify(x/7.0) == x/7 |
|
|
assert nsimplify(pi/1e2) == pi/100 |
|
|
assert nsimplify(pi/1e2, rational=False) == pi/100.0 |
|
|
assert nsimplify(pi/1e-7) == 10000000*pi |
|
|
assert not nsimplify( |
|
|
factor(-3.0*z**2*(z**2)**(-2.5) + 3*(z**2)**(-1.5))).atoms(Float) |
|
|
e = x**0.0 |
|
|
assert e.is_Pow and nsimplify(x**0.0) == 1 |
|
|
assert nsimplify(3.333333, tolerance=0.1, rational=True) == Rational(10, 3) |
|
|
assert nsimplify(3.333333, tolerance=0.01, rational=True) == Rational(10, 3) |
|
|
assert nsimplify(3.666666, tolerance=0.1, rational=True) == Rational(11, 3) |
|
|
assert nsimplify(3.666666, tolerance=0.01, rational=True) == Rational(11, 3) |
|
|
assert nsimplify(33, tolerance=10, rational=True) == Rational(33) |
|
|
assert nsimplify(33.33, tolerance=10, rational=True) == Rational(30) |
|
|
assert nsimplify(37.76, tolerance=10, rational=True) == Rational(40) |
|
|
assert nsimplify(-203.1) == Rational(-2031, 10) |
|
|
assert nsimplify(.2, tolerance=0) == Rational(1, 5) |
|
|
assert nsimplify(-.2, tolerance=0) == Rational(-1, 5) |
|
|
assert nsimplify(.2222, tolerance=0) == Rational(1111, 5000) |
|
|
assert nsimplify(-.2222, tolerance=0) == Rational(-1111, 5000) |
|
|
|
|
|
assert nsimplify(S(2e-8)) == Rational(1, 50000000) |
|
|
|
|
|
assert nsimplify(1e-42, rational=True) != 0 |
|
|
|
|
|
inf = Float('inf') |
|
|
infs = (-oo, oo, inf, -inf) |
|
|
for zi in infs: |
|
|
ans = sign(zi)*oo |
|
|
assert nsimplify(zi) == ans |
|
|
assert nsimplify(zi + x) == x + ans |
|
|
|
|
|
assert nsimplify(0.33333333, rational=True, rational_conversion='exact') == Rational(0.33333333) |
|
|
|
|
|
|
|
|
assert nsimplify(pi.evalf(100)*x, rational_conversion='exact').evalf(100) == pi.evalf(100)*x |
|
|
|
|
|
|
|
|
def test_issue_9448(): |
|
|
tmp = sympify("1/(1 - (-1)**(2/3) - (-1)**(1/3)) + 1/(1 + (-1)**(2/3) + (-1)**(1/3))") |
|
|
assert nsimplify(tmp) == S.Half |
|
|
|
|
|
|
|
|
def test_extract_minus_sign(): |
|
|
x = Symbol("x") |
|
|
y = Symbol("y") |
|
|
a = Symbol("a") |
|
|
b = Symbol("b") |
|
|
assert simplify(-x/-y) == x/y |
|
|
assert simplify(-x/y) == -x/y |
|
|
assert simplify(x/y) == x/y |
|
|
assert simplify(x/-y) == -x/y |
|
|
assert simplify(-x/0) == zoo*x |
|
|
assert simplify(Rational(-5, 0)) is zoo |
|
|
assert simplify(-a*x/(-y - b)) == a*x/(b + y) |
|
|
|
|
|
|
|
|
def test_diff(): |
|
|
x = Symbol("x") |
|
|
y = Symbol("y") |
|
|
f = Function("f") |
|
|
g = Function("g") |
|
|
assert simplify(g(x).diff(x)*f(x).diff(x) - f(x).diff(x)*g(x).diff(x)) == 0 |
|
|
assert simplify(2*f(x)*f(x).diff(x) - diff(f(x)**2, x)) == 0 |
|
|
assert simplify(diff(1/f(x), x) + f(x).diff(x)/f(x)**2) == 0 |
|
|
assert simplify(f(x).diff(x, y) - f(x).diff(y, x)) == 0 |
|
|
|
|
|
|
|
|
def test_logcombine_1(): |
|
|
x, y = symbols("x,y") |
|
|
a = Symbol("a") |
|
|
z, w = symbols("z,w", positive=True) |
|
|
b = Symbol("b", real=True) |
|
|
assert logcombine(log(x) + 2*log(y)) == log(x) + 2*log(y) |
|
|
assert logcombine(log(x) + 2*log(y), force=True) == log(x*y**2) |
|
|
assert logcombine(a*log(w) + log(z)) == a*log(w) + log(z) |
|
|
assert logcombine(b*log(z) + b*log(x)) == log(z**b) + b*log(x) |
|
|
assert logcombine(b*log(z) - log(w)) == log(z**b/w) |
|
|
assert logcombine(log(x)*log(z)) == log(x)*log(z) |
|
|
assert logcombine(log(w)*log(x)) == log(w)*log(x) |
|
|
assert logcombine(cos(-2*log(z) + b*log(w))) in [cos(log(w**b/z**2)), |
|
|
cos(log(z**2/w**b))] |
|
|
assert logcombine(log(log(x) - log(y)) - log(z), force=True) == \ |
|
|
log(log(x/y)/z) |
|
|
assert logcombine((2 + I)*log(x), force=True) == (2 + I)*log(x) |
|
|
assert logcombine((x**2 + log(x) - log(y))/(x*y), force=True) == \ |
|
|
(x**2 + log(x/y))/(x*y) |
|
|
|
|
|
|
|
|
assert logcombine(log(x)*2*log(y) + log(z), force=True) == \ |
|
|
log(z*y**log(x**2)) |
|
|
assert logcombine((x*y + sqrt(x**4 + y**4) + log(x) - log(y))/(pi*x**Rational(2, 3)* |
|
|
sqrt(y)**3), force=True) == ( |
|
|
x*y + sqrt(x**4 + y**4) + log(x/y))/(pi*x**Rational(2, 3)*y**Rational(3, 2)) |
|
|
assert logcombine(gamma(-log(x/y))*acos(-log(x/y)), force=True) == \ |
|
|
acos(-log(x/y))*gamma(-log(x/y)) |
|
|
|
|
|
assert logcombine(2*log(z)*log(w)*log(x) + log(z) + log(w)) == \ |
|
|
log(z**log(w**2))*log(x) + log(w*z) |
|
|
assert logcombine(3*log(w) + 3*log(z)) == log(w**3*z**3) |
|
|
assert logcombine(x*(y + 1) + log(2) + log(3)) == x*(y + 1) + log(6) |
|
|
assert logcombine((x + y)*log(w) + (-x - y)*log(3)) == (x + y)*log(w/3) |
|
|
|
|
|
assert logcombine(log(x) + log(2)) == log(2*x) |
|
|
eq = log(abs(x)) + log(abs(y)) |
|
|
assert logcombine(eq) == eq |
|
|
reps = {x: 0, y: 0} |
|
|
assert log(abs(x)*abs(y)).subs(reps) != eq.subs(reps) |
|
|
|
|
|
|
|
|
def test_logcombine_complex_coeff(): |
|
|
i = Integral((sin(x**2) + cos(x**3))/x, x) |
|
|
assert logcombine(i, force=True) == i |
|
|
assert logcombine(i + 2*log(x), force=True) == \ |
|
|
i + log(x**2) |
|
|
|
|
|
|
|
|
def test_issue_5950(): |
|
|
x, y = symbols("x,y", positive=True) |
|
|
assert logcombine(log(3) - log(2)) == log(Rational(3,2), evaluate=False) |
|
|
assert logcombine(log(x) - log(y)) == log(x/y) |
|
|
assert logcombine(log(Rational(3,2), evaluate=False) - log(2)) == \ |
|
|
log(Rational(3,4), evaluate=False) |
|
|
|
|
|
|
|
|
def test_posify(): |
|
|
x = symbols('x') |
|
|
|
|
|
assert str(posify( |
|
|
x + |
|
|
Symbol('p', positive=True) + |
|
|
Symbol('n', negative=True))) == '(_x + n + p, {_x: x})' |
|
|
|
|
|
eq, rep = posify(1/x) |
|
|
assert log(eq).expand().subs(rep) == -log(x) |
|
|
assert str(posify([x, 1 + x])) == '([_x, _x + 1], {_x: x})' |
|
|
|
|
|
p = symbols('p', positive=True) |
|
|
n = symbols('n', negative=True) |
|
|
orig = [x, n, p] |
|
|
modified, reps = posify(orig) |
|
|
assert str(modified) == '[_x, n, p]' |
|
|
assert [w.subs(reps) for w in modified] == orig |
|
|
|
|
|
assert str(Integral(posify(1/x + y)[0], (y, 1, 3)).expand()) == \ |
|
|
'Integral(1/_x, (y, 1, 3)) + Integral(_y, (y, 1, 3))' |
|
|
assert str(Sum(posify(1/x**n)[0], (n,1,3)).expand()) == \ |
|
|
'Sum(_x**(-n), (n, 1, 3))' |
|
|
|
|
|
A = Matrix([[1, 2, 3], [4, 5, 6 * Abs(x)]]) |
|
|
Ap, rep = posify(A) |
|
|
assert Ap == A.subs(*reversed(rep.popitem())) |
|
|
|
|
|
|
|
|
k = Symbol('k', finite=True) |
|
|
eq, rep = posify(k) |
|
|
assert eq.assumptions0 == {'positive': True, 'zero': False, 'imaginary': False, |
|
|
'nonpositive': False, 'commutative': True, 'hermitian': True, 'real': True, 'nonzero': True, |
|
|
'nonnegative': True, 'negative': False, 'complex': True, 'finite': True, |
|
|
'infinite': False, 'extended_real':True, 'extended_negative': False, |
|
|
'extended_nonnegative': True, 'extended_nonpositive': False, |
|
|
'extended_nonzero': True, 'extended_positive': True} |
|
|
|
|
|
|
|
|
def test_issue_4194(): |
|
|
|
|
|
f = Function('f') |
|
|
assert simplify((4*x + 6*f(y))/(2*x + 3*f(y))) == 2 |
|
|
|
|
|
|
|
|
@XFAIL |
|
|
def test_simplify_float_vs_integer(): |
|
|
|
|
|
|
|
|
assert simplify(x**2.0 - x**2) == 0 |
|
|
assert simplify(x**2 - x**2.0) == 0 |
|
|
|
|
|
|
|
|
def test_as_content_primitive(): |
|
|
assert (x/2 + y).as_content_primitive() == (S.Half, x + 2*y) |
|
|
assert (x/2 + y).as_content_primitive(clear=False) == (S.One, x/2 + y) |
|
|
assert (y*(x/2 + y)).as_content_primitive() == (S.Half, y*(x + 2*y)) |
|
|
assert (y*(x/2 + y)).as_content_primitive(clear=False) == (S.One, y*(x/2 + y)) |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
assert (x*(2 + 2*x)*(3*x + 3)**2).as_content_primitive() == \ |
|
|
(18, x*(x + 1)**3) |
|
|
assert (2 + 2*x + 2*y*(3 + 3*y)).as_content_primitive() == \ |
|
|
(2, x + 3*y*(y + 1) + 1) |
|
|
assert ((2 + 6*x)**2).as_content_primitive() == \ |
|
|
(4, (3*x + 1)**2) |
|
|
assert ((2 + 6*x)**(2*y)).as_content_primitive() == \ |
|
|
(1, (_keep_coeff(S(2), (3*x + 1)))**(2*y)) |
|
|
assert (5 + 10*x + 2*y*(3 + 3*y)).as_content_primitive() == \ |
|
|
(1, 10*x + 6*y*(y + 1) + 5) |
|
|
assert (5*(x*(1 + y)) + 2*x*(3 + 3*y)).as_content_primitive() == \ |
|
|
(11, x*(y + 1)) |
|
|
assert ((5*(x*(1 + y)) + 2*x*(3 + 3*y))**2).as_content_primitive() == \ |
|
|
(121, x**2*(y + 1)**2) |
|
|
assert (y**2).as_content_primitive() == \ |
|
|
(1, y**2) |
|
|
assert (S.Infinity).as_content_primitive() == (1, oo) |
|
|
eq = x**(2 + y) |
|
|
assert (eq).as_content_primitive() == (1, eq) |
|
|
assert (S.Half**(2 + x)).as_content_primitive() == (Rational(1, 4), 2**-x) |
|
|
assert (Rational(-1, 2)**(2 + x)).as_content_primitive() == \ |
|
|
(Rational(1, 4), (Rational(-1, 2))**x) |
|
|
assert (Rational(-1, 2)**(2 + x)).as_content_primitive() == \ |
|
|
(Rational(1, 4), Rational(-1, 2)**x) |
|
|
assert (4**((1 + y)/2)).as_content_primitive() == (2, 4**(y/2)) |
|
|
assert (3**((1 + y)/2)).as_content_primitive() == \ |
|
|
(1, 3**(Mul(S.Half, 1 + y, evaluate=False))) |
|
|
assert (5**Rational(3, 4)).as_content_primitive() == (1, 5**Rational(3, 4)) |
|
|
assert (5**Rational(7, 4)).as_content_primitive() == (5, 5**Rational(3, 4)) |
|
|
assert Add(z*Rational(5, 7), 0.5*x, y*Rational(3, 2), evaluate=False).as_content_primitive() == \ |
|
|
(Rational(1, 14), 7.0*x + 21*y + 10*z) |
|
|
assert (2**Rational(3, 4) + 2**Rational(1, 4)*sqrt(3)).as_content_primitive(radical=True) == \ |
|
|
(1, 2**Rational(1, 4)*(sqrt(2) + sqrt(3))) |
|
|
|
|
|
|
|
|
def test_signsimp(): |
|
|
e = x*(-x + 1) + x*(x - 1) |
|
|
assert signsimp(Eq(e, 0)) is S.true |
|
|
assert Abs(x - 1) == Abs(1 - x) |
|
|
assert signsimp(y - x) == y - x |
|
|
assert signsimp(y - x, evaluate=False) == Mul(-1, x - y, evaluate=False) |
|
|
|
|
|
|
|
|
def test_besselsimp(): |
|
|
from sympy.functions.special.bessel import (besseli, besselj, bessely) |
|
|
from sympy.integrals.transforms import cosine_transform |
|
|
assert besselsimp(exp(-I*pi*y/2)*besseli(y, z*exp_polar(I*pi/2))) == \ |
|
|
besselj(y, z) |
|
|
assert besselsimp(exp(-I*pi*a/2)*besseli(a, 2*sqrt(x)*exp_polar(I*pi/2))) == \ |
|
|
besselj(a, 2*sqrt(x)) |
|
|
assert besselsimp(sqrt(2)*sqrt(pi)*x**Rational(1, 4)*exp(I*pi/4)*exp(-I*pi*a/2) * |
|
|
besseli(Rational(-1, 2), sqrt(x)*exp_polar(I*pi/2)) * |
|
|
besseli(a, sqrt(x)*exp_polar(I*pi/2))/2) == \ |
|
|
besselj(a, sqrt(x)) * cos(sqrt(x)) |
|
|
assert besselsimp(besseli(Rational(-1, 2), z)) == \ |
|
|
sqrt(2)*cosh(z)/(sqrt(pi)*sqrt(z)) |
|
|
assert besselsimp(besseli(a, z*exp_polar(-I*pi/2))) == \ |
|
|
exp(-I*pi*a/2)*besselj(a, z) |
|
|
assert cosine_transform(1/t*sin(a/t), t, y) == \ |
|
|
sqrt(2)*sqrt(pi)*besselj(0, 2*sqrt(a)*sqrt(y))/2 |
|
|
|
|
|
assert besselsimp(x**2*(a*(-2*besselj(5*I, x) + besselj(-2 + 5*I, x) + |
|
|
besselj(2 + 5*I, x)) + b*(-2*bessely(5*I, x) + bessely(-2 + 5*I, x) + |
|
|
bessely(2 + 5*I, x)))/4 + x*(a*(besselj(-1 + 5*I, x)/2 - besselj(1 + 5*I, x)/2) |
|
|
+ b*(bessely(-1 + 5*I, x)/2 - bessely(1 + 5*I, x)/2)) + (x**2 + 25)*(a*besselj(5*I, x) |
|
|
+ b*bessely(5*I, x))) == 0 |
|
|
|
|
|
assert besselsimp(81*x**2*(a*(besselj(Rational(-5, 3), 9*x) - 2*besselj(Rational(1, 3), 9*x) + besselj(Rational(7, 3), 9*x)) |
|
|
+ b*(bessely(Rational(-5, 3), 9*x) - 2*bessely(Rational(1, 3), 9*x) + bessely(Rational(7, 3), 9*x)))/4 + x*(a*(9*besselj(Rational(-2, 3), 9*x)/2 |
|
|
- 9*besselj(Rational(4, 3), 9*x)/2) + b*(9*bessely(Rational(-2, 3), 9*x)/2 - 9*bessely(Rational(4, 3), 9*x)/2)) + |
|
|
(81*x**2 - Rational(1, 9))*(a*besselj(Rational(1, 3), 9*x) + b*bessely(Rational(1, 3), 9*x))) == 0 |
|
|
|
|
|
assert besselsimp(besselj(a-1,x) + besselj(a+1, x) - 2*a*besselj(a, x)/x) == 0 |
|
|
|
|
|
assert besselsimp(besselj(a-1,x) + besselj(a+1, x) + besselj(a, x)) == (2*a + x)*besselj(a, x)/x |
|
|
|
|
|
assert besselsimp(x**2* besselj(a,x) + x**3*besselj(a+1, x) + besselj(a+2, x)) == \ |
|
|
2*a*x*besselj(a + 1, x) + x**3*besselj(a + 1, x) - x**2*besselj(a + 2, x) + 2*x*besselj(a + 1, x) + besselj(a + 2, x) |
|
|
|
|
|
def test_Piecewise(): |
|
|
e1 = x*(x + y) - y*(x + y) |
|
|
e2 = sin(x)**2 + cos(x)**2 |
|
|
e3 = expand((x + y)*y/x) |
|
|
s1 = simplify(e1) |
|
|
s2 = simplify(e2) |
|
|
s3 = simplify(e3) |
|
|
assert simplify(Piecewise((e1, x < e2), (e3, True))) == \ |
|
|
Piecewise((s1, x < s2), (s3, True)) |
|
|
|
|
|
|
|
|
def test_polymorphism(): |
|
|
class A(Basic): |
|
|
def _eval_simplify(x, **kwargs): |
|
|
return S.One |
|
|
|
|
|
a = A(S(5), S(2)) |
|
|
assert simplify(a) == 1 |
|
|
|
|
|
|
|
|
def test_issue_from_PR1599(): |
|
|
n1, n2, n3, n4 = symbols('n1 n2 n3 n4', negative=True) |
|
|
assert simplify(I*sqrt(n1)) == -sqrt(-n1) |
|
|
|
|
|
|
|
|
def test_issue_6811(): |
|
|
eq = (x + 2*y)*(2*x + 2) |
|
|
assert simplify(eq) == (x + 1)*(x + 2*y)*2 |
|
|
|
|
|
assert simplify(eq.expand()) == \ |
|
|
2*x**2 + 4*x*y + 2*x + 4*y |
|
|
|
|
|
|
|
|
def test_issue_6920(): |
|
|
e = [cos(x) + I*sin(x), cos(x) - I*sin(x), |
|
|
cosh(x) - sinh(x), cosh(x) + sinh(x)] |
|
|
ok = [exp(I*x), exp(-I*x), exp(-x), exp(x)] |
|
|
|
|
|
f = Function('f') |
|
|
assert [simplify(f(ei)).args[0] for ei in e] == ok |
|
|
|
|
|
|
|
|
def test_issue_7001(): |
|
|
from sympy.abc import r, R |
|
|
assert simplify(-(r*Piecewise((pi*Rational(4, 3), r <= R), |
|
|
(-8*pi*R**3/(3*r**3), True)) + 2*Piecewise((pi*r*Rational(4, 3), r <= R), |
|
|
(4*pi*R**3/(3*r**2), True)))/(4*pi*r)) == \ |
|
|
Piecewise((-1, r <= R), (0, True)) |
|
|
|
|
|
|
|
|
def test_inequality_no_auto_simplify(): |
|
|
|
|
|
lhs = cos(x)**2 + sin(x)**2 |
|
|
rhs = 2 |
|
|
e = Lt(lhs, rhs, evaluate=False) |
|
|
assert e is not S.true |
|
|
assert simplify(e) |
|
|
|
|
|
|
|
|
def test_issue_9398(): |
|
|
from sympy.core.numbers import Number |
|
|
from sympy.polys.polytools import cancel |
|
|
assert cancel(1e-14) != 0 |
|
|
assert cancel(1e-14*I) != 0 |
|
|
|
|
|
assert simplify(1e-14) != 0 |
|
|
assert simplify(1e-14*I) != 0 |
|
|
|
|
|
assert (I*Number(1.)*Number(10)**Number(-14)).simplify() != 0 |
|
|
|
|
|
assert cancel(1e-20) != 0 |
|
|
assert cancel(1e-20*I) != 0 |
|
|
|
|
|
assert simplify(1e-20) != 0 |
|
|
assert simplify(1e-20*I) != 0 |
|
|
|
|
|
assert cancel(1e-100) != 0 |
|
|
assert cancel(1e-100*I) != 0 |
|
|
|
|
|
assert simplify(1e-100) != 0 |
|
|
assert simplify(1e-100*I) != 0 |
|
|
|
|
|
f = Float("1e-1000") |
|
|
assert cancel(f) != 0 |
|
|
assert cancel(f*I) != 0 |
|
|
|
|
|
assert simplify(f) != 0 |
|
|
assert simplify(f*I) != 0 |
|
|
|
|
|
|
|
|
def test_issue_9324_simplify(): |
|
|
M = MatrixSymbol('M', 10, 10) |
|
|
e = M[0, 0] + M[5, 4] + 1304 |
|
|
assert simplify(e) == e |
|
|
|
|
|
|
|
|
def test_issue_9817_simplify(): |
|
|
|
|
|
|
|
|
|
|
|
from sympy.matrices.expressions import Identity, trace |
|
|
v = MatrixSymbol('v', 3, 1) |
|
|
A = MatrixSymbol('A', 3, 3) |
|
|
x = Matrix([i + 1 for i in range(3)]) |
|
|
X = Identity(3) |
|
|
quadratic = v.T * A * v |
|
|
assert simplify((trace(quadratic.as_explicit())).xreplace({v:x, A:X})) == 14 |
|
|
|
|
|
|
|
|
def test_issue_13474(): |
|
|
x = Symbol('x') |
|
|
assert simplify(x + csch(sinc(1))) == x + csch(sinc(1)) |
|
|
|
|
|
|
|
|
@_both_exp_pow |
|
|
def test_simplify_function_inverse(): |
|
|
|
|
|
|
|
|
|
|
|
x, y = symbols('x, y') |
|
|
g = Function('g') |
|
|
|
|
|
class f(Function): |
|
|
def inverse(self, argindex=1): |
|
|
return g |
|
|
|
|
|
assert simplify(f(g(x))) == f(g(x)) |
|
|
assert inversecombine(f(g(x))) == x |
|
|
assert simplify(f(g(x)), inverse=True) == x |
|
|
assert simplify(f(g(sin(x)**2 + cos(x)**2)), inverse=True) == 1 |
|
|
assert simplify(f(g(x, y)), inverse=True) == f(g(x, y)) |
|
|
assert unchanged(asin, sin(x)) |
|
|
assert simplify(asin(sin(x))) == asin(sin(x)) |
|
|
assert simplify(2*asin(sin(3*x)), inverse=True) == 6*x |
|
|
assert simplify(log(exp(x))) == log(exp(x)) |
|
|
assert simplify(log(exp(x)), inverse=True) == x |
|
|
assert simplify(exp(log(x)), inverse=True) == x |
|
|
assert simplify(log(exp(x), 2), inverse=True) == x/log(2) |
|
|
assert simplify(log(exp(x), 2, evaluate=False), inverse=True) == x/log(2) |
|
|
|
|
|
|
|
|
def test_clear_coefficients(): |
|
|
from sympy.simplify.simplify import clear_coefficients |
|
|
assert clear_coefficients(4*y*(6*x + 3)) == (y*(2*x + 1), 0) |
|
|
assert clear_coefficients(4*y*(6*x + 3) - 2) == (y*(2*x + 1), Rational(1, 6)) |
|
|
assert clear_coefficients(4*y*(6*x + 3) - 2, x) == (y*(2*x + 1), x/12 + Rational(1, 6)) |
|
|
assert clear_coefficients(sqrt(2) - 2) == (sqrt(2), 2) |
|
|
assert clear_coefficients(4*sqrt(2) - 2) == (sqrt(2), S.Half) |
|
|
assert clear_coefficients(S(3), x) == (0, x - 3) |
|
|
assert clear_coefficients(S.Infinity, x) == (S.Infinity, x) |
|
|
assert clear_coefficients(-S.Pi, x) == (S.Pi, -x) |
|
|
assert clear_coefficients(2 - S.Pi/3, x) == (pi, -3*x + 6) |
|
|
|
|
|
def test_nc_simplify(): |
|
|
from sympy.simplify.simplify import nc_simplify |
|
|
from sympy.matrices.expressions import MatPow, Identity |
|
|
from sympy.core import Pow |
|
|
from functools import reduce |
|
|
|
|
|
a, b, c, d = symbols('a b c d', commutative = False) |
|
|
x = Symbol('x') |
|
|
A = MatrixSymbol("A", x, x) |
|
|
B = MatrixSymbol("B", x, x) |
|
|
C = MatrixSymbol("C", x, x) |
|
|
D = MatrixSymbol("D", x, x) |
|
|
subst = {a: A, b: B, c: C, d:D} |
|
|
funcs = {Add: lambda x,y: x+y, Mul: lambda x,y: x*y } |
|
|
|
|
|
def _to_matrix(expr): |
|
|
if expr in subst: |
|
|
return subst[expr] |
|
|
if isinstance(expr, Pow): |
|
|
return MatPow(_to_matrix(expr.args[0]), expr.args[1]) |
|
|
elif isinstance(expr, (Add, Mul)): |
|
|
return reduce(funcs[expr.func],[_to_matrix(a) for a in expr.args]) |
|
|
else: |
|
|
return expr*Identity(x) |
|
|
|
|
|
def _check(expr, simplified, deep=True, matrix=True): |
|
|
assert nc_simplify(expr, deep=deep) == simplified |
|
|
assert expand(expr) == expand(simplified) |
|
|
if matrix: |
|
|
m_simp = _to_matrix(simplified).doit(inv_expand=False) |
|
|
assert nc_simplify(_to_matrix(expr), deep=deep) == m_simp |
|
|
|
|
|
_check(a*b*a*b*a*b*c*(a*b)**3*c, ((a*b)**3*c)**2) |
|
|
_check(a*b*(a*b)**-2*a*b, 1) |
|
|
_check(a**2*b*a*b*a*b*(a*b)**-1, a*(a*b)**2, matrix=False) |
|
|
_check(b*a*b**2*a*b**2*a*b**2, b*(a*b**2)**3) |
|
|
_check(a*b*a**2*b*a**2*b*a**3, (a*b*a)**3*a**2) |
|
|
_check(a**2*b*a**4*b*a**4*b*a**2, (a**2*b*a**2)**3) |
|
|
_check(a**3*b*a**4*b*a**4*b*a, a**3*(b*a**4)**3*a**-3) |
|
|
_check(a*b*a*b + a*b*c*x*a*b*c, (a*b)**2 + x*(a*b*c)**2) |
|
|
_check(a*b*a*b*c*a*b*a*b*c, ((a*b)**2*c)**2) |
|
|
_check(b**-1*a**-1*(a*b)**2, a*b) |
|
|
_check(a**-1*b*c**-1, (c*b**-1*a)**-1) |
|
|
expr = a**3*b*a**4*b*a**4*b*a**2*b*a**2*(b*a**2)**2*b*a**2*b*a**2 |
|
|
for _ in range(10): |
|
|
expr *= a*b |
|
|
_check(expr, a**3*(b*a**4)**2*(b*a**2)**6*(a*b)**10) |
|
|
_check((a*b*a*b)**2, (a*b*a*b)**2, deep=False) |
|
|
_check(a*b*(c*d)**2, a*b*(c*d)**2) |
|
|
expr = b**-1*(a**-1*b**-1 - a**-1*c*b**-1)**-1*a**-1 |
|
|
assert nc_simplify(expr) == (1-c)**-1 |
|
|
|
|
|
assert nc_simplify(2*x**2) == 2*x**2 |
|
|
|
|
|
def test_issue_15965(): |
|
|
A = Sum(z*x**y, (x, 1, a)) |
|
|
anew = z*Sum(x**y, (x, 1, a)) |
|
|
B = Integral(x*y, x) |
|
|
bdo = x**2*y/2 |
|
|
assert simplify(A + B) == anew + bdo |
|
|
assert simplify(A) == anew |
|
|
assert simplify(B) == bdo |
|
|
assert simplify(B, doit=False) == y*Integral(x, x) |
|
|
|
|
|
|
|
|
def test_issue_17137(): |
|
|
assert simplify(cos(x)**I) == cos(x)**I |
|
|
assert simplify(cos(x)**(2 + 3*I)) == cos(x)**(2 + 3*I) |
|
|
|
|
|
|
|
|
def test_issue_21869(): |
|
|
x = Symbol('x', real=True) |
|
|
y = Symbol('y', real=True) |
|
|
expr = And(Eq(x**2, 4), Le(x, y)) |
|
|
assert expr.simplify() == expr |
|
|
|
|
|
expr = And(Eq(x**2, 4), Eq(x, 2)) |
|
|
assert expr.simplify() == Eq(x, 2) |
|
|
|
|
|
expr = And(Eq(x**3, x**2), Eq(x, 1)) |
|
|
assert expr.simplify() == Eq(x, 1) |
|
|
|
|
|
expr = And(Eq(sin(x), x**2), Eq(x, 0)) |
|
|
assert expr.simplify() == Eq(x, 0) |
|
|
|
|
|
expr = And(Eq(x**3, x**2), Eq(x, 2)) |
|
|
assert expr.simplify() == S.false |
|
|
|
|
|
expr = And(Eq(y, x**2), Eq(x, 1)) |
|
|
assert expr.simplify() == And(Eq(y,1), Eq(x, 1)) |
|
|
|
|
|
expr = And(Eq(y**2, 1), Eq(y, x**2), Eq(x, 1)) |
|
|
assert expr.simplify() == And(Eq(y,1), Eq(x, 1)) |
|
|
|
|
|
expr = And(Eq(y**2, 4), Eq(y, 2*x**2), Eq(x, 1)) |
|
|
assert expr.simplify() == And(Eq(y,2), Eq(x, 1)) |
|
|
|
|
|
expr = And(Eq(y**2, 4), Eq(y, x**2), Eq(x, 1)) |
|
|
assert expr.simplify() == S.false |
|
|
|
|
|
|
|
|
def test_issue_7971_21740(): |
|
|
z = Integral(x, (x, 1, 1)) |
|
|
assert z != 0 |
|
|
assert simplify(z) is S.Zero |
|
|
assert simplify(S.Zero) is S.Zero |
|
|
z = simplify(Float(0)) |
|
|
assert z is not S.Zero and z == 0.0 |
|
|
|
|
|
|
|
|
@slow |
|
|
def test_issue_17141_slow(): |
|
|
|
|
|
assert simplify((2**acos(I+1)**2).rewrite('log')) == 2**((pi + 2*I*log(-1 + |
|
|
sqrt(1 - 2*I) + I))**2/4) |
|
|
|
|
|
|
|
|
def test_issue_17141(): |
|
|
|
|
|
assert simplify(x**(1 / acos(I))) == x**(2/(pi - 2*I*log(1 + sqrt(2)))) |
|
|
assert simplify(acos(-I)**2*acos(I)**2) == \ |
|
|
log(1 + sqrt(2))**4 + pi**2*log(1 + sqrt(2))**2/2 + pi**4/16 |
|
|
assert simplify(2**acos(I)**2) == 2**((pi - 2*I*log(1 + sqrt(2)))**2/4) |
|
|
p = 2**acos(I+1)**2 |
|
|
assert simplify(p) == p |
|
|
|
|
|
|
|
|
def test_simplify_kroneckerdelta(): |
|
|
i, j = symbols("i j") |
|
|
K = KroneckerDelta |
|
|
|
|
|
assert simplify(K(i, j)) == K(i, j) |
|
|
assert simplify(K(0, j)) == K(0, j) |
|
|
assert simplify(K(i, 0)) == K(i, 0) |
|
|
|
|
|
assert simplify(K(0, j).rewrite(Piecewise) * K(1, j)) == 0 |
|
|
assert simplify(K(1, i) + Piecewise((1, Eq(j, 2)), (0, True))) == K(1, i) + K(2, j) |
|
|
|
|
|
|
|
|
assert simplify(K(0, j) * K(1, j)) == 0 |
|
|
|
|
|
n = Symbol('n', integer=True) |
|
|
assert simplify(K(0, n) * K(1, n)) == 0 |
|
|
|
|
|
M = Matrix(4, 4, lambda i, j: K(j - i, n) if i <= j else 0) |
|
|
assert simplify(M**2) == Matrix([[K(0, n), 0, K(1, n), 0], |
|
|
[0, K(0, n), 0, K(1, n)], |
|
|
[0, 0, K(0, n), 0], |
|
|
[0, 0, 0, K(0, n)]]) |
|
|
assert simplify(eye(1) * KroneckerDelta(0, n) * |
|
|
KroneckerDelta(1, n)) == Matrix([[0]]) |
|
|
|
|
|
assert simplify(S.Infinity * KroneckerDelta(0, n) * |
|
|
KroneckerDelta(1, n)) is S.NaN |
|
|
|
|
|
|
|
|
def test_issue_17292(): |
|
|
assert simplify(abs(x)/abs(x**2)) == 1/abs(x) |
|
|
|
|
|
assert simplify(5*abs((x**2 - 1)/(x - 1))) == 5*Abs(x + 1) |
|
|
|
|
|
|
|
|
def test_issue_19822(): |
|
|
expr = And(Gt(n-2, 1), Gt(n, 1)) |
|
|
assert simplify(expr) == Gt(n, 3) |
|
|
|
|
|
|
|
|
def test_issue_18645(): |
|
|
expr = And(Ge(x, 3), Le(x, 3)) |
|
|
assert simplify(expr) == Eq(x, 3) |
|
|
expr = And(Eq(x, 3), Le(x, 3)) |
|
|
assert simplify(expr) == Eq(x, 3) |
|
|
|
|
|
|
|
|
@XFAIL |
|
|
def test_issue_18642(): |
|
|
i = Symbol("i", integer=True) |
|
|
n = Symbol("n", integer=True) |
|
|
expr = And(Eq(i, 2 * n), Le(i, 2*n -1)) |
|
|
assert simplify(expr) == S.false |
|
|
|
|
|
|
|
|
@XFAIL |
|
|
def test_issue_18389(): |
|
|
n = Symbol("n", integer=True) |
|
|
expr = Eq(n, 0) | (n >= 1) |
|
|
assert simplify(expr) == Ge(n, 0) |
|
|
|
|
|
|
|
|
def test_issue_8373(): |
|
|
x = Symbol('x', real=True) |
|
|
assert simplify(Or(x < 1, x >= 1)) == S.true |
|
|
|
|
|
|
|
|
def test_issue_7950(): |
|
|
expr = And(Eq(x, 1), Eq(x, 2)) |
|
|
assert simplify(expr) == S.false |
|
|
|
|
|
|
|
|
def test_issue_22020(): |
|
|
expr = I*pi/2 -oo |
|
|
assert simplify(expr) == expr |
|
|
|
|
|
|
|
|
|
|
|
def test_issue_19484(): |
|
|
assert simplify(sign(x) * Abs(x)) == x |
|
|
|
|
|
e = x + sign(x + x**3) |
|
|
assert simplify(Abs(x + x**3)*e) == x**3 + x*Abs(x**3 + x) + x |
|
|
|
|
|
e = x**2 + sign(x**3 + 1) |
|
|
assert simplify(Abs(x**3 + 1) * e) == x**3 + x**2*Abs(x**3 + 1) + 1 |
|
|
|
|
|
f = Function('f') |
|
|
e = x + sign(x + f(x)**3) |
|
|
assert simplify(Abs(x + f(x)**3) * e) == x*Abs(x + f(x)**3) + x + f(x)**3 |
|
|
|
|
|
|
|
|
def test_issue_23543(): |
|
|
|
|
|
x, y, z = symbols("x y z", commutative=False) |
|
|
assert (x*(y + z/2)).simplify() == x*(2*y + z)/2 |
|
|
|
|
|
|
|
|
def test_issue_11004(): |
|
|
|
|
|
def f(n): |
|
|
return sqrt(2*pi*n) * (n/E)**n |
|
|
|
|
|
def m(n, k): |
|
|
return f(n) / (f(n/k)**k) |
|
|
|
|
|
def p(n,k): |
|
|
return m(n, k) / (k**n) |
|
|
|
|
|
N, k = symbols('N k') |
|
|
half = Float('0.5', 4) |
|
|
z = log(p(n, k) / p(n, k + 1)).expand(force=True) |
|
|
r = simplify(z.subs(n, N).n(4)) |
|
|
assert r == ( |
|
|
half*k*log(k) |
|
|
- half*k*log(k + 1) |
|
|
+ half*log(N) |
|
|
- half*log(k + 1) |
|
|
+ Float(0.9189224, 4) |
|
|
) |
|
|
|
|
|
|
|
|
def test_issue_19161(): |
|
|
polynomial = Poly('x**2').simplify() |
|
|
assert (polynomial-x**2).simplify() == 0 |
|
|
|
|
|
|
|
|
def test_issue_22210(): |
|
|
d = Symbol('d', integer=True) |
|
|
expr = 2*Derivative(sin(x), (x, d)) |
|
|
assert expr.simplify() == expr |
|
|
|
|
|
|
|
|
def test_reduce_inverses_nc_pow(): |
|
|
x, y = symbols("x y", commutative=True) |
|
|
Z = symbols("Z", commutative=False) |
|
|
assert simplify(2**Z * y**Z) == 2**Z * y**Z |
|
|
assert simplify(x**Z * y**Z) == x**Z * y**Z |
|
|
x, y = symbols("x y", positive=True) |
|
|
assert expand((x*y)**Z) == x**Z * y**Z |
|
|
assert simplify(x**Z * y**Z) == expand((x*y)**Z) |
|
|
|
|
|
def test_nc_recursion_coeff(): |
|
|
X = symbols("X", commutative = False) |
|
|
assert (2 * cos(pi/3) * X).simplify() == X |
|
|
assert (2.0 * cos(pi/3) * X).simplify() == X |
|
|
|
