def test_octave_not_supported(): assert mcode(S.ComplexInfinity) == ( "% Not supported in Octave:\n" "% ComplexInfinity\n" "zoo" ) f = Function('f') assert mcode(f(x).diff(x)) == ( "% Not supported in Octave:\n" "% Derivative\n" "Derivative(f(x), x)" )
def test_m_not_supported(): f = Function('f') name_expr = ("test", [f(x).diff(x), S.ComplexInfinity]) result, = codegen(name_expr, "Octave", header=False, empty=False) source = result[1] expected = ("function [out1, out2] = test(x)\n" " % unsupported: Derivative(f(x), x)\n" " % unsupported: zoo\n" " out1 = Derivative(f(x), x);\n" " out2 = zoo;\n" "end\n") assert source == expected
def test_functional_diffgeom_ch4(): x0, y0, theta0 = symbols('x0, y0, theta0', extended_real=True) x, y, r, theta = symbols('x, y, r, theta', extended_real=True) r0 = symbols('r0', positive=True) f = Function('f') b1 = Function('b1') b2 = Function('b2') p_r = R2_r.point([x0, y0]) p_p = R2_p.point([r0, theta0]) f_field = b1(R2.x, R2.y) * R2.dx + b2(R2.x, R2.y) * R2.dy assert f_field.rcall(R2.e_x).rcall(p_r) == b1(x0, y0) assert f_field.rcall(R2.e_y).rcall(p_r) == b2(x0, y0) s_field_r = f(R2.x, R2.y) df = Differential(s_field_r) assert df(R2.e_x).rcall(p_r).doit() == Derivative(f(x0, y0), x0) assert df(R2.e_y).rcall(p_r).doit() == Derivative(f(x0, y0), y0) s_field_p = f(R2.r, R2.theta) df = Differential(s_field_p) assert trigsimp(df(R2.e_x).rcall(p_p).doit()) == ( cos(theta0) * Derivative(f(r0, theta0), r0) - sin(theta0) * Derivative(f(r0, theta0), theta0) / r0) assert trigsimp(df(R2.e_y).rcall(p_p).doit()) == ( sin(theta0) * Derivative(f(r0, theta0), r0) + cos(theta0) * Derivative(f(r0, theta0), theta0) / r0) assert R2.dx(R2.e_x).rcall(p_r) == 1 assert R2.dx(R2.e_x) == 1 assert R2.dx(R2.e_y).rcall(p_r) == 0 assert R2.dx(R2.e_y) == 0 circ = -R2.y * R2.e_x + R2.x * R2.e_y assert R2.dx(circ).rcall(p_r).doit() == -y0 assert R2.dy(circ).rcall(p_r) == x0 assert R2.dr(circ).rcall(p_r) == 0 assert simplify(R2.dtheta(circ).rcall(p_r)) == 1 assert (circ - R2.e_theta).rcall(s_field_r).rcall(p_r) == 0
def test_split_symbols_function(): transformations = standard_transformations + \ (split_symbols, implicit_multiplication) x = Symbol('x') y = Symbol('y') a = Symbol('a') f = Function('f') assert parse_expr('ay(x+1)', transformations=transformations) == a * y * (x + 1) assert parse_expr('af(x+1)', transformations=transformations, local_dict={'f': f}) == a * f(x + 1)
def test_ufunc_support(): f = Function('f') g = Function('g') x = IndexedBase('x') y = IndexedBase('y') i, j = Idx('i'), Idx('j') assert get_indices(f(x[i])) == ({i}, {}) assert get_indices(f(x[i], y[j])) == ({i, j}, {}) assert get_indices(f(y[i]) * g(x[i])) == (set(), {}) assert get_indices(f(a, x[i])) == ({i}, {}) assert get_indices(f(a, y[i], x[j]) * g(x[i])) == ({j}, {}) assert get_indices(g(f(x[i]))) == ({i}, {}) assert get_contraction_structure(f(x[i])) == {None: {f(x[i])}} assert get_contraction_structure(f(y[i]) * g(x[i])) == { (i, ): {f(y[i]) * g(x[i])} } assert get_contraction_structure(f(y[i]) * g(f(x[i]))) == { (i, ): {f(y[i]) * g(f(x[i]))} } assert get_contraction_structure(f(x[j], y[i]) * g(x[i])) == { (i, ): {f(x[j], y[i]) * g(x[i])} }
def test_get_contraction_structure_basic(): x = IndexedBase('x') y = IndexedBase('y') i, j = Idx('i'), Idx('j') f = Function('f') assert get_contraction_structure(x[i] * y[j]) == {None: {x[i] * y[j]}} assert get_contraction_structure(x[i] + y[j]) == {None: {x[i], y[j]}} assert get_contraction_structure(x[i] * y[i]) == {(i, ): {x[i] * y[i]}} assert get_contraction_structure(1 + x[i] * y[i]) == { None: {1}, (i, ): {x[i] * y[i]} } assert get_contraction_structure(x[i]**y[i]) == {None: {x[i]**y[i]}} assert (get_contraction_structure(f(x[i, i])) == { None: {f(x[i, i])}, f(x[i, i]): [{ (i, ): {x[i, i]} }] })
def test_sympyissue_11799(): n = 2 M = Manifold('M', n) P = Patch('P', M) coord = CoordSystem('coord', P, ['x%s' % i for i in range(n)]) x = coord.coord_functions() dx = coord.base_oneforms() f = Function('f') g = [[f(x[0], x[1])**2, 0], [0, f(x[0], x[1])**2]] metric = sum(g[i][j]*TP(dx[i], dx[j]) for i in range(n) for j in range(n)) R = metric_to_Riemann_components(metric) d = Symbol('d') assert (R[0, 1, 0, 1] == -Subs(Derivative(f(d, x[1]), d, d), (d, x[0]))/f(x[0], x[1]) - Subs(Derivative(f(x[0], d), d, d), (d, x[1]))/f(x[0], x[1]) + Subs(Derivative(f(d, x[1]), d), (d, x[0]))**2/f(x[0], x[1])**2 + Subs(Derivative(f(x[0], d), d), (d, x[1]))**2/f(x[0], x[1])**2)
from diofant.functions import (Heaviside, Max, Min, Piecewise, acos, acosh, acot, acoth, asin, asinh, atan, atanh, binomial, conjugate, cos, cosh, cot, coth, csch, erfc, exp, factorial, factorial2, fibonacci, gamma, hyper, im, log, meijerg, polygamma, polylog, re, rf, sech, sign, sin, sinh, tan, tanh, zeta) from diofant.integrals import Integral from diofant.logic import Or, false, true from diofant.matrices import Matrix, SparseMatrix from diofant.polys import Poly, RootOf, RootSum from diofant.series import Limit __all__ = () f = Function('f') def test_Integer(): assert mcode(Integer(67)) == "67" assert mcode(Integer(-1)) == "-1" def test_Rational(): assert mcode(Rational(3, 7)) == "3/7" assert mcode(Rational(18, 9)) == "2" assert mcode(Rational(3, -7)) == "-3/7" assert mcode(Rational(-3, -7)) == "3/7" assert mcode(x + Rational(3, 7)) == "x + 3/7" assert mcode(Rational(3, 7)*x) == "(3/7)*x"
def test_Min(): n = Symbol('n', negative=True) n_ = Symbol('n_', negative=True) nn = Symbol('nn', nonnegative=True) nn_ = Symbol('nn_', nonnegative=True) p = Symbol('p', positive=True) p_ = Symbol('p_', positive=True) np = Symbol('np', nonpositive=True) np_ = Symbol('np_', nonpositive=True) assert Min(5, 4) == 4 assert Min(-oo, -oo) == -oo assert Min(-oo, n) == -oo assert Min(n, -oo) == -oo assert Min(-oo, np) == -oo assert Min(np, -oo) == -oo assert Min(-oo, 0) == -oo assert Min(0, -oo) == -oo assert Min(-oo, nn) == -oo assert Min(nn, -oo) == -oo assert Min(-oo, p) == -oo assert Min(p, -oo) == -oo assert Min(-oo, oo) == -oo assert Min(oo, -oo) == -oo assert Min(n, n) == n assert Min(n, np) == Min(n, np) assert Min(np, n) == Min(np, n) assert Min(n, 0) == n assert Min(0, n) == n assert Min(n, nn) == n assert Min(nn, n) == n assert Min(n, p) == n assert Min(p, n) == n assert Min(n, oo) == n assert Min(oo, n) == n assert Min(np, np) == np assert Min(np, 0) == np assert Min(0, np) == np assert Min(np, nn) == np assert Min(nn, np) == np assert Min(np, p) == np assert Min(p, np) == np assert Min(np, oo) == np assert Min(oo, np) == np assert Min(0, 0) == 0 assert Min(0, nn) == 0 assert Min(nn, 0) == 0 assert Min(0, p) == 0 assert Min(p, 0) == 0 assert Min(0, oo) == 0 assert Min(oo, 0) == 0 assert Min(nn, nn) == nn assert Min(nn, p) == Min(nn, p) assert Min(p, nn) == Min(p, nn) assert Min(nn, oo) == nn assert Min(oo, nn) == nn assert Min(p, p) == p assert Min(p, oo) == p assert Min(oo, p) == p assert Min(oo, oo) == oo assert isinstance(Min(n, n_), Min) assert isinstance(Min(nn, nn_), Min) assert isinstance(Min(np, np_), Min) assert isinstance(Min(p, p_), Min) # lists pytest.raises(ValueError, lambda: Min()) assert Min(x, y) == Min(y, x) assert Min(x, y, z) == Min(z, y, x) assert Min(x, Min(y, z)) == Min(z, y, x) assert Min(x, Max(y, -oo)) == Min(x, y) assert Min(p, oo, n, p, p, p_) == n assert Min(p_, n_, p) == n_ assert Min(n, oo, -7, p, p, 2) == Min(n, -7) assert Min(2, x, p, n, oo, n_, p, 2, -2, -2) == Min(-2, x, n, n_) assert Min(0, x, 1, y) == Min(0, x, y) assert Min(1000, 100, -100, x, p, n) == Min(n, x, -100) assert Min(cos(x), sin(x)) == Min(cos(x), sin(x)) assert Min(cos(x), sin(x)).subs({x: 1}) == cos(1) assert Min(cos(x), sin(x)).subs({x: Rational(1, 2)}) == sin(Rational(1, 2)) pytest.raises(ValueError, lambda: Min(cos(x), sin(x)).subs({x: I})) pytest.raises(ValueError, lambda: Min(I)) pytest.raises(ValueError, lambda: Min(I, x)) pytest.raises(ValueError, lambda: Min(zoo, x)) assert Min(1, x).diff(x) == Heaviside(1 - x) assert Min(x, 1).diff(x) == Heaviside(1 - x) assert Min(0, -x, 1 - 2*x).diff(x) == -Heaviside(x + Min(0, -2*x + 1)) \ - 2*Heaviside(2*x + Min(0, -x) - 1) pytest.raises(ArgumentIndexError, lambda: Min(1, x).fdiff(3)) a, b = Symbol('a', extended_real=True), Symbol('b', extended_real=True) # a and b are both real, Min(a, b) should be real assert Min(a, b).is_extended_real # issue sympy/sympy#7619 f = Function('f') assert Min(1, 2 * Min(f(1), 2)) # doesn't fail # issue sympy/sympy#7233 e = Min(0, x) assert e.evalf == e.n assert e.evalf(strict=False).args == (0, x)
def test_get_indices_Idx(): f = Function('f') i, j = Idx('i'), Idx('j') assert get_indices(f(i) * j) == ({i, j}, {}) assert get_indices(f(j, i)) == ({j, i}, {}) assert get_indices(f(i) * i) == (set(), {})
def apart_list_full_decomposition(P, Q, dummygen): """ Bronstein's full partial fraction decomposition algorithm. Given a univariate rational function ``f``, performing only GCD operations over the algebraic closure of the initial ground domain of definition, compute full partial fraction decomposition with fractions having linear denominators. Note that no factorization of the initial denominator of ``f`` is performed. The final decomposition is formed in terms of a sum of :class:`RootSum` instances. References ========== .. [1] [Bronstein93]_ """ f, x, U = P / Q, P.gen, [] u = Function('u')(x) a = Dummy('a') partial = [] for d, n in Q.sqf_list_include(all=True): b = d.as_expr() U += [u.diff(x, n - 1)] h = cancel(f * b**n) / u**n H, subs = [h], [] for j in range(1, n): H += [H[-1].diff(x) / j] for j in range(1, n + 1): subs += [(U[j - 1], b.diff(x, j) / j)] for j in range(0, n): P, Q = cancel(H[j]).as_numer_denom() for i in range(0, j + 1): P = P.subs(*subs[j - i]) Q = Q.subs(*subs[0]) P = Poly(P, x) Q = Poly(Q, x) G = P.gcd(d) D = d.quo(G) B, g = Q.half_gcdex(D) b = (P * B.quo(g)).rem(D) Dw = D.subs(x, next(dummygen)) numer = Lambda(a, b.as_expr().subs(x, a)) denom = Lambda(a, (x - a)) exponent = n - j partial.append((Dw, numer, denom, exponent)) return partial