def test_derivative2(): f = Function("f") a = Wild("a", exclude=[f, x]) b = Wild("b", exclude=[f]) e = Derivative(f(x), x) assert e.match(Derivative(f(x), x)) == {} assert e.match(Derivative(f(x), x, x)) is None e = Derivative(f(x), x, x) assert e.match(Derivative(f(x), x)) is None assert e.match(Derivative(f(x), x, x)) == {} e = Derivative(f(x), x) + x**2 assert e.match(a * Derivative(f(x), x) + b) == {a: 1, b: x**2} assert e.match(a * Derivative(f(x), x, x) + b) is None e = Derivative(f(x), x, x) + x**2 assert e.match(a * Derivative(f(x), x) + b) is None assert e.match(a * Derivative(f(x), x, x) + b) == {a: 1, b: x**2}
def test_Derivative_bug1(): f = Function("f") a = Wild("a", exclude=[f(x)]) b = Wild("b", exclude=[f(x)]) eq = f(x).diff(x) assert eq.match(a * Derivative(f(x), x) + b) == {a: 1, b: 0}
def test_derivative_subs3(): x = Symbol('x') dex = Derivative(exp(x), x) assert Derivative(dex, x).subs(dex, exp(x)) == dex assert dex.subs(exp(x), dex) == Derivative(exp(x), x, x)
def test_del_operator(): pytest.raises(TypeError, lambda: Del(Integer(1))) # Tests for curl assert (delop ^ Vector.zero == (Derivative(0, C.y) - Derivative(0, C.z))*C.i + (-Derivative(0, C.x) + Derivative(0, C.z))*C.j + (Derivative(0, C.x) - Derivative(0, C.y))*C.k) assert ((delop ^ Vector.zero).doit() == Vector.zero == curl(Vector.zero, C)) assert delop.cross(Vector.zero) == delop ^ Vector.zero assert (delop ^ i).doit() == Vector.zero assert delop.cross(2*y**2*j, doit=True) == Vector.zero assert delop.cross(2*y**2*j) == delop ^ 2*y**2*j v = x*y*z * (i + j + k) assert ((delop ^ v).doit() == (-x*y + x*z)*i + (x*y - y*z)*j + (-x*z + y*z)*k == curl(v, C)) assert delop ^ v == delop.cross(v) assert (delop.cross(2*x**2*j) == (Derivative(0, C.y) - Derivative(2*C.x**2, C.z))*C.i + (-Derivative(0, C.x) + Derivative(0, C.z))*C.j + (-Derivative(0, C.y) + Derivative(2*C.x**2, C.x))*C.k) assert (delop.cross(2*x**2*j, doit=True) == 4*x*k == curl(2*x**2*j, C)) # Tests for divergence assert delop & Vector.zero == Integer(0) == divergence(Vector.zero, C) assert (delop & Vector.zero).doit() == Integer(0) assert delop.dot(Vector.zero) == delop & Vector.zero assert (delop & i).doit() == Integer(0) assert (delop & x**2*i).doit() == 2*x == divergence(x**2*i, C) assert (delop.dot(v, doit=True) == x*y + y*z + z*x == divergence(v, C)) assert delop & v == delop.dot(v) assert delop.dot(1/(x*y*z) * (i + j + k), doit=True) == \ - 1 / (x*y*z**2) - 1 / (x*y**2*z) - 1 / (x**2*y*z) v = x*i + y*j + z*k assert (delop & v == Derivative(C.x, C.x) + Derivative(C.y, C.y) + Derivative(C.z, C.z)) assert delop.dot(v, doit=True) == 3 == divergence(v, C) assert delop & v == delop.dot(v) assert simplify((delop & v).doit()) == 3 # Tests for gradient assert (delop.gradient(0, doit=True) == Vector.zero == gradient(0, C)) assert delop.gradient(0) == delop(0) assert (delop(Integer(0))).doit() == Vector.zero assert (delop(x) == (Derivative(C.x, C.x))*C.i + (Derivative(C.x, C.y))*C.j + (Derivative(C.x, C.z))*C.k) assert (delop(x)).doit() == i == gradient(x, C) assert (delop(x*y*z) == (Derivative(C.x*C.y*C.z, C.x))*C.i + (Derivative(C.x*C.y*C.z, C.y))*C.j + (Derivative(C.x*C.y*C.z, C.z))*C.k) assert (delop.gradient(x*y*z, doit=True) == y*z*i + z*x*j + x*y*k == gradient(x*y*z, C)) assert delop(x*y*z) == delop.gradient(x*y*z) assert (delop(2*x**2)).doit() == 4*x*i assert ((delop(a*sin(y) / x)).doit() == -a*sin(y)/x**2 * i + a*cos(y)/x * j) # Tests for directional derivative assert (Vector.zero & delop)(a) == Integer(0) assert ((Vector.zero & delop)(a)).doit() == Integer(0) assert ((v & delop)(Vector.zero)).doit() == Vector.zero assert ((v & delop)(Integer(0))).doit() == Integer(0) assert ((i & delop)(x)).doit() == 1 assert ((j & delop)(y)).doit() == 1 assert ((k & delop)(z)).doit() == 1 assert ((i & delop)(x*y*z)).doit() == y*z assert ((v & delop)(x)).doit() == x assert ((v & delop)(x*y*z)).doit() == 3*x*y*z assert (v & delop)(x + y + z) == C.x + C.y + C.z assert ((v & delop)(x + y + z)).doit() == x + y + z assert ((v & delop)(v)).doit() == v assert ((i & delop)(v)).doit() == i assert ((j & delop)(v)).doit() == j assert ((k & delop)(v)).doit() == k assert ((v & delop)(Vector.zero)).doit() == Vector.zero
def test_derivative_numerically(): z0 = random() + I*random() assert abs(Derivative(sin(x), x).doit_numerically(z0) - cos(z0)) < 1e-15
def test_sympyissue_11313(): # test Derivative series & as_leading_term assert Derivative(x**3 + x**4, x).as_leading_term(x).doit() == 3*x**2 s = Derivative(sin(x), x).series(x, n=3) assert s == Derivative(-x**3/6, x) + Derivative(x, x) + O(x**3) assert s.doit() == 1 - x**2/2 + O(x**3)
def test_derivative_subs3(): x = Symbol('x') dex = Derivative(exp(x), x) assert Derivative(dex, x).subs({dex: exp(x)}) == dex assert dex.subs({exp(x): dex}) == Derivative(exp(x), x, x)
def test_Derivative(): assert str(Derivative(x, y)) == 'Derivative(x, y)' assert str(Derivative(x**2, x, evaluate=False)) == 'Derivative(x**2, x)' assert str(Derivative(x**2 / y, x, y, evaluate=False)) == 'Derivative(x**2/y, x, y)'
def test_deriv_sub_bug3(): y = Symbol('y') f = Function('f') pat = Derivative(f(x), x, x) assert pat.subs({y: y**2}) == Derivative(f(x), x, x) assert pat.subs({y: y**2}) != Derivative(f(x), x)
def test_derivative_subs2(): f_func, g_func = symbols('f g', cls=Function) f, g = f_func(x, y, z), g_func(x, y, z) assert Derivative(f, x, y).subs({Derivative(f, x, y): g}) == g assert Derivative(f, y, x).subs({Derivative(f, x, y): g}) == g assert Derivative(f, x, y).subs({Derivative(f, x): g}) == Derivative(g, y) assert Derivative(f, x, y).subs({Derivative(f, y): g}) == Derivative(g, x) assert (Derivative(f, x, y, z).subs({Derivative(f, x, z): g}) == Derivative(g, y)) assert (Derivative(f, x, y, z).subs({Derivative(f, z, y): g}) == Derivative(g, x)) assert (Derivative(f, x, y, z).subs({Derivative(f, z, y, x): g}) == g) assert (Derivative(sin(x), x, 2).subs({Derivative(sin(x), f_func(x)): g_func}) == Derivative(sin(x), x, 2)) # issue sympy/sympy#9135 assert (Derivative(f, x, x, y).subs({Derivative(f, y, y): g}) == Derivative(f, x, x, y)) assert (Derivative(f, x, y, y, z).subs({Derivative(f, x, y, y, y): g}) == Derivative(f, x, y, y, z)) assert Derivative(f, x, y).subs({Derivative(f_func(x), x, y): g}) == Derivative(f, x, y)
def test_jacobi(): assert jacobi(0, a, b, x) == 1 assert jacobi(1, a, b, x) == a / 2 - b / 2 + x * (a / 2 + b / 2 + 1) assert (jacobi(2, a, b, x) == a**2 / 8 - a * b / 4 - a / 8 + b**2 / 8 - b / 8 + x**2 * (a**2 / 8 + a * b / 4 + 7 * a / 8 + b**2 / 8 + 7 * b / 8 + Rational(3, 2)) + x * (a**2 / 4 + 3 * a / 4 - b**2 / 4 - 3 * b / 4) - Rational(1, 2)) assert jacobi(n, a, a, x) == RisingFactorial(a + 1, n) * gegenbauer( n, a + Rational(1, 2), x) / RisingFactorial(2 * a + 1, n) assert jacobi(n, a, -a, x) == ((-1)**a * (-x + 1)**(-a / 2) * (x + 1)**(a / 2) * assoc_legendre(n, a, x) * factorial(-a + n) * gamma(a + n + 1) / (factorial(a + n) * gamma(n + 1))) assert jacobi(n, -b, b, x) == ((-x + 1)**(b / 2) * (x + 1)**(-b / 2) * assoc_legendre(n, b, x) * gamma(-b + n + 1) / gamma(n + 1)) assert jacobi(n, 0, 0, x) == legendre(n, x) assert jacobi(n, Rational(1, 2), Rational(1, 2), x) == RisingFactorial( Rational(3, 2), n) * chebyshevu(n, x) / factorial(n + 1) assert jacobi(n, Rational(-1, 2), Rational(-1, 2), x) == RisingFactorial( Rational(1, 2), n) * chebyshevt(n, x) / factorial(n) X = jacobi(n, a, b, x) assert isinstance(X, jacobi) assert jacobi(n, a, b, -x) == (-1)**n * jacobi(n, b, a, x) assert jacobi(n, a, b, 0) == 2**(-n) * gamma(a + n + 1) * hyper( (-b - n, -n), (a + 1, ), -1) / (factorial(n) * gamma(a + 1)) assert jacobi(n, a, b, 1) == RisingFactorial(a + 1, n) / factorial(n) m = Symbol("m", positive=True) assert jacobi(m, a, b, oo) == oo * RisingFactorial(a + b + m + 1, m) assert jacobi(n, a, b, oo) == jacobi(n, a, b, oo, evaluate=False) assert conjugate(jacobi(m, a, b, x)) == \ jacobi(m, conjugate(a), conjugate(b), conjugate(x)) assert diff(jacobi(n, a, b, x), n) == Derivative(jacobi(n, a, b, x), n) assert diff(jacobi(n, a, b, x), x) == \ (a + b + n + 1)*jacobi(n - 1, a + 1, b + 1, x)/2 # XXX see issue sympy/sympy#5539 assert str(jacobi(n, a, b, x).diff(a)) == \ ("Sum((jacobi(n, a, b, x) + (a + b + 2*_k + 1)*RisingFactorial(b + " "_k + 1, n - _k)*jacobi(_k, a, b, x)/((n - _k)*RisingFactorial(a + " "b + _k + 1, n - _k)))/(a + b + n + _k + 1), (_k, 0, n - 1))") assert str(jacobi(n, a, b, x).diff(b)) == \ ("Sum(((-1)**(n - _k)*(a + b + 2*_k + 1)*RisingFactorial(a + " "_k + 1, n - _k)*jacobi(_k, a, b, x)/((n - _k)*RisingFactorial(a + " "b + _k + 1, n - _k)) + jacobi(n, a, b, x))/(a + b + n + " "_k + 1), (_k, 0, n - 1))") assert jacobi_normalized(n, a, b, x) == \ (jacobi(n, a, b, x)/sqrt(2**(a + b + 1)*gamma(a + n + 1)*gamma(b + n + 1) / ((a + b + 2*n + 1)*factorial(n)*gamma(a + b + n + 1)))) pytest.raises(ValueError, lambda: jacobi(-2.1, a, b, x)) pytest.raises(ValueError, lambda: jacobi(Dummy(positive=True, integer=True), 1, 2, oo)) pytest.raises(ArgumentIndexError, lambda: jacobi(n, a, b, x).fdiff(5))
def test_integrate_derivatives(): assert integrate(Derivative(f(x), x), x) == f(x)
def test_integrate_functions(): # issue sympy/sympy#4111 assert integrate(f(x), x) == Integral(f(x), x) assert integrate(f(x), (x, 0, 1)) == Integral(f(x), (x, 0, 1)) assert integrate(Derivative(f(y), y), x) == x*Derivative(f(y), y)
def test_diff(): assert O(1).diff(x) == 0 assert O(1, x).diff(x) == Derivative(O(1, x), x) assert O(x**2).diff(x) == Derivative(O(x**2), x)
def test_im(): a, b = symbols('a,b', extended_real=True) r = Symbol('r', extended_real=True) i = Symbol('i', imaginary=True) assert im(nan) == nan assert im(oo * I) == oo assert im(-oo * I) == -oo assert im(0) == 0 assert im(1) == 0 assert im(-1) == 0 assert im(E * I) == E assert im(-E * I) == -E x = Symbol('x') assert im(x) == im(x) assert im(x * I) == re(x) assert im(r * I) == r assert im(r) == 0 assert im(i * I) == 0 assert im(i) == -I * i y = Symbol('x') assert im(x + y) == im(x + y) assert im(x + r) == im(x) assert im(x + r * I) == im(x) + r assert im(im(x) * I) == im(x) assert im(2 + I) == 1 assert im(x + I) == im(x) + 1 assert im(x + y * I) == im(x) + re(y) assert im(x + r * I) == im(x) + r assert im(log(2 * I)) == pi / 2 assert im((2 + I)**2).expand(complex=True) == 4 assert im(conjugate(x)) == -im(x) assert conjugate(im(x)) == im(x) assert im(x).as_real_imag() == (im(x), 0) assert im(i * r * x).diff(r) == im(i * x) assert im(i * r * x).diff(i) == -I * re(r * x) assert im(sqrt(a + b * I)) == root(a**2 + b**2, 4) * sin(arg(a + I * b) / 2) assert im(a * (2 + b * I)) == a * b assert im((1 + sqrt(a + b * I)) / 2) == root(a**2 + b**2, 4) * sin(arg(a + I * b) / 2) / 2 assert im(x).rewrite(re) == -I * (x - re(x)) # sympy/sympy#10897 assert (x + im(y)).rewrite(im, re) == x - I * (y - re(y)) a = Symbol('a', algebraic=True) t = Symbol('t', transcendental=True) assert re(a).is_algebraic assert re(x).is_algebraic is None assert re(t).is_algebraic is False assert re(zoo) == nan # issue sympy/sympy#4757 x = Symbol('x', extended_real=True) y = Symbol('y', imaginary=True) f = Function('f') assert im(f(x)).diff(x) == im(f(x).diff(x)) assert im(f(y)).diff(y) == -I * re(f(y).diff(y)) assert im(f(z)).diff(z) == Derivative(im(f(z)), z)
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_re(): a, b = symbols('a,b', extended_real=True) r = Symbol('r', extended_real=True) i = Symbol('i', imaginary=True) assert re(nan) == nan assert re(oo) == oo assert re(-oo) == -oo assert re(0) == 0 assert re(1) == 1 assert re(-1) == -1 assert re(E) == E assert re(-E) == -E x = Symbol('x') assert re(x) == re(x) assert re(x * I) == -im(x) assert re(r * I) == 0 assert re(r) == r assert re(i * I) == I * i assert re(i) == 0 y = Symbol('y') assert re(x + y) == re(x + y) assert re(x + r) == re(x) + r assert re(re(x)) == re(x) assert re(2 + I) == 2 assert re(x + I) == re(x) assert re(x + y * I) == re(x) - im(y) assert re(x + r * I) == re(x) assert re(log(2 * I)) == log(2) assert re((2 + I)**2).expand(complex=True) == 3 assert re(conjugate(x)) == re(x) assert conjugate(re(x)) == re(x) assert re(x).as_real_imag() == (re(x), 0) assert re(i * r * x).diff(r) == re(i * x) assert re(i * r * x).diff(i) == I * r * im(x) assert re(sqrt(a + b * I)) == root(a**2 + b**2, 4) * cos(arg(a + I * b) / 2) assert re(a * (2 + b * I)) == 2 * a assert re( (1 + sqrt(a + b * I)) / 2) == root(a**2 + b**2, 4) * cos(arg(a + I * b) / 2) / 2 + Rational( 1, 2) assert re(x).rewrite(im) == x - I * im(x) # issue sympy/sympy#10897 assert (x + re(y)).rewrite(re, im) == x + y - I * im(y) a = Symbol('a', algebraic=True) t = Symbol('t', transcendental=True) assert re(a).is_algebraic assert re(x).is_algebraic is None assert re(t).is_algebraic is False assert re(zoo) == nan # issue sympy/sympy#4757 x = Symbol('x', extended_real=True) y = Symbol('y', imaginary=True) f = Function('f') assert re(f(x)).diff(x) == re(f(x).diff(x)) assert re(f(y)).diff(y) == -I * im(f(y).diff(y)) assert re(f(z)).diff(z) == Derivative(re(f(z)), z)
def test_doit(): n = Symbol('n', integer=True) f = Sum(2 * n * x, (n, 1, 3)) d = Derivative(f, x) assert d.doit() == 12 assert d.doit(deep=False) == Sum(2*n, (n, 1, 3))
def test_Subs(): assert Subs(x, (x, 0)) == Subs(y, (y, 0)) assert Subs(x, (x, 0)).subs({x: 1}) == Subs(x, (x, 0)) assert Subs(y, (x, 0)).subs({y: 1}) == Subs(1, (x, 0)) assert Subs(f(x), (x, 0)).doit() == f(0) assert Subs(f(x**2), (x**2, 0)).doit() == f(0) assert Subs(f(x, y, z), (x, 0), (y, 1), (z, 1)) != \ Subs(f(x, y, z), (x, 0), (y, 0), (z, 1)) assert Subs(f(x, y), (x, 0), (y, 1), (z, 1)) == \ Subs(f(x, y), (x, 0), (y, 1), (z, 2)) assert Subs(f(x, y), (x, 0), (y, 1), (z, 1)) != \ Subs(f(x, y) + z, (x, 0), (y, 1), (z, 0)) assert Subs(f(x, y), (x, 0), (y, 1)).doit() == f(0, 1) assert Subs(Subs(f(x, y), (x, 0)), (y, 1)).doit() == f(0, 1) pytest.raises(ValueError, lambda: Subs(f(x, y), x)) pytest.raises(ValueError, lambda: Subs(f(x, y), (x, 0), (x, 0), (y, 1))) assert len(Subs(f(x, y), (x, 0), (y, 1)).variables) == 2 assert Subs(f(x, y), (x, 0), (y, 1)).point == Tuple(0, 1) assert Subs(f(x), (x, 0)) == Subs(f(y), (y, 0)) assert Subs(f(x, y), (x, 0), (y, 1)) == Subs(f(x, y), (y, 1), (x, 0)) assert Subs(f(x) * y, (x, 0), (y, 1)) == Subs(f(y) * x, (y, 0), (x, 1)) assert Subs(f(x) * y, (x, 1), (y, 1)) == Subs(f(y) * x, (x, 1), (y, 1)) assert Subs(f(x), (x, 0)).subs({x: 1}).doit() == f(0) assert Subs(f(x), (x, y)).subs({y: 0}) == Subs(f(x), (x, 0)) assert Subs(y * f(x), (x, y)).subs({y: 2}) == Subs(2 * f(x), (x, 2)) assert (2 * Subs(f(x), (x, 0))).subs({Subs(f(x), (x, 0)): y}) == 2 * y assert Subs(f(x), (x, 0)).free_symbols == set() assert Subs(f(x, y), (x, z)).free_symbols == {y, z} assert Subs(f(x).diff(x), (x, 0)).doit(), Subs(f(x).diff(x), (x, 0)) assert Subs(1 + f(x).diff(x), (x, 0)).doit(), 1 + Subs(f(x).diff(x), (x, 0)) assert Subs(y*f(x, y).diff(x), (x, 0), (y, 2)).doit() == \ 2*Subs(Derivative(f(x, 2), x), (x, 0)) assert Subs(y**2 * f(x), (x, 0)).diff(y) == 2 * y * f(0) e = Subs(y**2 * f(x), (x, y)) assert e.diff(y) == e.doit().diff( y) == y**2 * Derivative(f(y), y) + 2 * y * f(y) assert Subs(f(x), (x, 0)) + Subs(f(x), (x, 0)) == 2 * Subs(f(x), (x, 0)) e1 = Subs(z * f(x), (x, 1)) e2 = Subs(z * f(y), (y, 1)) assert e1 + e2 == 2 * e1 assert e1.__hash__() == e2.__hash__() assert Subs(z * f(x + 1), (x, 1)) not in (e1, e2) assert Derivative(f(x), x).subs({x: g(x)}) == Derivative(f(g(x)), g(x)) assert Derivative(f(x), x).subs({x: x + y}) == Subs(Derivative(f(x), x), (x, x + y)) assert Subs(f(x)*cos(y) + z, (x, 0), (y, pi/3)).evalf(2, strict=False) == \ Subs(f(x)*cos(y) + z, (x, 0), (y, pi/3)).evalf(2, strict=False) == \ z + Rational('1/2').evalf(2)*f(0) assert f(x).diff(x).subs({x: 0}).subs({x: y}) == f(x).diff(x).subs({x: 0}) assert (x * f(x).diff(x).subs({x: 0})).subs( {x: y}) == y * f(x).diff(x).subs({x: 0})
def test_diff_wrt_value(): assert Expr()._diff_wrt is False assert x._diff_wrt is True assert f(x)._diff_wrt is True assert Derivative(f(x), x)._diff_wrt is True assert Derivative(x**2, x)._diff_wrt is False
def test_requires_partial(): x, y, z, t, nu = symbols('x y z t nu') n = symbols('n', integer=True) f = x * y assert requires_partial(Derivative(f, x)) is True assert requires_partial(Derivative(f, y)) is True # integrating out one of the variables assert requires_partial( Derivative(Integral(exp(-x * y), (x, 0, oo)), y, evaluate=False)) is False # bessel function with smooth parameter f = besselj(nu, x) assert requires_partial(Derivative(f, x)) is True assert requires_partial(Derivative(f, nu)) is True # bessel function with integer parameter f = besselj(n, x) assert requires_partial(Derivative(f, x)) is False # this is not really valid (differentiating with respect to an integer) # but there's no reason to use the partial derivative symbol there. make # sure we don't throw an exception here, though assert requires_partial(Derivative(f, n)) is False # bell polynomial f = bell(n, x) assert requires_partial(Derivative(f, x)) is False # again, invalid assert requires_partial(Derivative(f, n)) is False # legendre polynomial f = legendre(0, x) assert requires_partial(Derivative(f, x)) is False f = legendre(n, x) assert requires_partial(Derivative(f, x)) is False # again, invalid assert requires_partial(Derivative(f, n)) is False f = x**n assert requires_partial(Derivative(f, x)) is False assert requires_partial( Derivative( Integral((x * y)**n * exp(-x * y), (x, 0, oo)), y, evaluate=False)) is False # parametric equation f = (exp(t), cos(t)) g = sum(f) assert requires_partial(Derivative(g, t)) is False # function of unspecified variables f = symbols('f', cls=Function) assert requires_partial(Derivative(f, x)) is False assert requires_partial(Derivative(f, x, y)) is True
def test_derivative_evaluate(): assert Derivative(sin(x), x) != diff(sin(x), x) assert Derivative(sin(x), x).doit() == diff(sin(x), x) assert Derivative(Derivative(f(x), x), x) == diff(f(x), x, x) assert Derivative(sin(x), x, 0) == sin(x)
def test_count_ops_visual(): ADD, MUL, POW, SIN, COS, EXP, AND, D, G = symbols( 'Add Mul Pow sin cos exp And Derivative Integral'.upper()) DIV, SUB, NEG = symbols('DIV SUB NEG') NOT, OR, AND, XOR, IMPLIES, EQUIVALENT, _ITE, BASIC, TUPLE = symbols( 'Not Or And Xor Implies Equivalent ITE Basic Tuple'.upper()) def count(val): return count_ops(val, visual=True) assert count(7) is S.Zero assert count(Integer(7)) is S.Zero assert count(-1) == NEG assert count(-2) == NEG assert count(Rational(2, 3)) == DIV assert count(pi / 3) == DIV assert count(-pi / 3) == DIV + NEG assert count(I - 1) == SUB assert count(1 - I) == SUB assert count(1 - 2 * I) == SUB + MUL assert count(x) is S.Zero assert count(-x) == NEG assert count(-2 * x / 3) == NEG + DIV + MUL assert count(1 / x) == DIV assert count(1 / (x * y)) == DIV + MUL assert count(-1 / x) == NEG + DIV assert count(-2 / x) == NEG + DIV assert count(x / y) == DIV assert count(-x / y) == NEG + DIV assert count(x**2) == POW assert count(-x**2) == POW + NEG assert count(-2 * x**2) == POW + MUL + NEG assert count(x + pi / 3) == ADD + DIV assert count(x + Rational(1, 3)) == ADD + DIV assert count(x + y) == ADD assert count(x - y) == SUB assert count(y - x) == SUB assert count(-1 / (x - y)) == DIV + NEG + SUB assert count(-1 / (y - x)) == DIV + NEG + SUB assert count(1 + x**y) == ADD + POW assert count(1 + x + y) == 2 * ADD assert count(1 + x + y + z) == 3 * ADD assert count(1 + x**y + 2 * x * y + y**2) == 3 * ADD + 2 * POW + 2 * MUL assert count(2 * z + y + x + 1) == 3 * ADD + MUL assert count(2 * z + y**17 + x + 1) == 3 * ADD + MUL + POW assert count(2 * z + y**17 + x + sin(x)) == 3 * ADD + POW + MUL + SIN assert count(2 * z + y**17 + x + sin(x**2)) == 3 * ADD + MUL + 2 * POW + SIN assert count(2 * z + y**17 + x + sin(x**2) + exp(cos(x))) == 4 * ADD + MUL + 3 * POW + COS + SIN assert count(Derivative(x, x)) == D assert count(Integral(x, x) + 2 * x / (1 + x)) == G + DIV + MUL + 2 * ADD assert count(Basic()) is S.Zero assert count({x + 1: sin(x)}) == ADD + SIN assert count([x + 1, sin(x) + y, None]) == ADD + SIN + ADD assert count({x + 1: sin(x), y: cos(x) + 1}) == SIN + COS + 2 * ADD assert count({}) is S.Zero assert count([x + 1, sin(x) * y, None]) == SIN + ADD + MUL assert count([]) is S.Zero assert count(Basic()) == 0 assert count(Basic(Basic(), Basic(x, x + y))) == ADD + 2 * BASIC assert count(Basic(x, x + y)) == ADD + BASIC assert count(Or(x, y)) == OR assert count(And(x, y)) == AND assert count(And(x**y, z)) == AND + POW assert count(Or(x, Or(y, And(z, a)))) == AND + OR assert count(Nor(x, y)) == NOT + OR assert count(Nand(x, y)) == NOT + AND assert count(Xor(x, y)) == XOR assert count(Implies(x, y)) == IMPLIES assert count(Equivalent(x, y)) == EQUIVALENT assert count(ITE(x, y, z)) == _ITE assert count([Or(x, y), And(x, y), Basic(x + y)]) == ADD + AND + BASIC + OR assert count(Basic(Tuple(x))) == BASIC + TUPLE # It checks that TUPLE is counted as an operation. assert count(Eq(x + y, Integer(2))) == ADD