123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384 |
- from sympy.core import (S, pi, oo, symbols, Function, Rational, Integer,
- Tuple, Symbol, Eq, Ne, Le, Lt, Gt, Ge)
- from sympy.core import EulerGamma, GoldenRatio, Catalan, Lambda, Mul, Pow
- from sympy.functions import Piecewise, sqrt, ceiling, exp, sin, cos, sinc, lucas
- from sympy.testing.pytest import raises
- from sympy.utilities.lambdify import implemented_function
- from sympy.matrices import (eye, Matrix, MatrixSymbol, Identity,
- HadamardProduct, SparseMatrix)
- from sympy.functions.special.bessel import besseli
- from sympy.printing.maple import maple_code
- x, y, z = symbols('x,y,z')
- def test_Integer():
- assert maple_code(Integer(67)) == "67"
- assert maple_code(Integer(-1)) == "-1"
- def test_Rational():
- assert maple_code(Rational(3, 7)) == "3/7"
- assert maple_code(Rational(18, 9)) == "2"
- assert maple_code(Rational(3, -7)) == "-3/7"
- assert maple_code(Rational(-3, -7)) == "3/7"
- assert maple_code(x + Rational(3, 7)) == "x + 3/7"
- assert maple_code(Rational(3, 7) * x) == '(3/7)*x'
- def test_Relational():
- assert maple_code(Eq(x, y)) == "x = y"
- assert maple_code(Ne(x, y)) == "x <> y"
- assert maple_code(Le(x, y)) == "x <= y"
- assert maple_code(Lt(x, y)) == "x < y"
- assert maple_code(Gt(x, y)) == "x > y"
- assert maple_code(Ge(x, y)) == "x >= y"
- def test_Function():
- assert maple_code(sin(x) ** cos(x)) == "sin(x)^cos(x)"
- assert maple_code(abs(x)) == "abs(x)"
- assert maple_code(ceiling(x)) == "ceil(x)"
- def test_Pow():
- assert maple_code(x ** 3) == "x^3"
- assert maple_code(x ** (y ** 3)) == "x^(y^3)"
- assert maple_code((x ** 3) ** y) == "(x^3)^y"
- assert maple_code(x ** Rational(2, 3)) == 'x^(2/3)'
- g = implemented_function('g', Lambda(x, 2 * x))
- assert maple_code(1 / (g(x) * 3.5) ** (x - y ** x) / (x ** 2 + y)) == \
- "(3.5*2*x)^(-x + y^x)/(x^2 + y)"
- # For issue 14160
- assert maple_code(Mul(-2, x, Pow(Mul(y, y, evaluate=False), -1, evaluate=False),
- evaluate=False)) == '-2*x/(y*y)'
- def test_basic_ops():
- assert maple_code(x * y) == "x*y"
- assert maple_code(x + y) == "x + y"
- assert maple_code(x - y) == "x - y"
- assert maple_code(-x) == "-x"
- def test_1_over_x_and_sqrt():
- # 1.0 and 0.5 would do something different in regular StrPrinter,
- # but these are exact in IEEE floating point so no different here.
- assert maple_code(1 / x) == '1/x'
- assert maple_code(x ** -1) == maple_code(x ** -1.0) == '1/x'
- assert maple_code(1 / sqrt(x)) == '1/sqrt(x)'
- assert maple_code(x ** -S.Half) == maple_code(x ** -0.5) == '1/sqrt(x)'
- assert maple_code(sqrt(x)) == 'sqrt(x)'
- assert maple_code(x ** S.Half) == maple_code(x ** 0.5) == 'sqrt(x)'
- assert maple_code(1 / pi) == '1/Pi'
- assert maple_code(pi ** -1) == maple_code(pi ** -1.0) == '1/Pi'
- assert maple_code(pi ** -0.5) == '1/sqrt(Pi)'
- def test_mix_number_mult_symbols():
- assert maple_code(3 * x) == "3*x"
- assert maple_code(pi * x) == "Pi*x"
- assert maple_code(3 / x) == "3/x"
- assert maple_code(pi / x) == "Pi/x"
- assert maple_code(x / 3) == '(1/3)*x'
- assert maple_code(x / pi) == "x/Pi"
- assert maple_code(x * y) == "x*y"
- assert maple_code(3 * x * y) == "3*x*y"
- assert maple_code(3 * pi * x * y) == "3*Pi*x*y"
- assert maple_code(x / y) == "x/y"
- assert maple_code(3 * x / y) == "3*x/y"
- assert maple_code(x * y / z) == "x*y/z"
- assert maple_code(x / y * z) == "x*z/y"
- assert maple_code(1 / x / y) == "1/(x*y)"
- assert maple_code(2 * pi * x / y / z) == "2*Pi*x/(y*z)"
- assert maple_code(3 * pi / x) == "3*Pi/x"
- assert maple_code(S(3) / 5) == "3/5"
- assert maple_code(S(3) / 5 * x) == '(3/5)*x'
- assert maple_code(x / y / z) == "x/(y*z)"
- assert maple_code((x + y) / z) == "(x + y)/z"
- assert maple_code((x + y) / (z + x)) == "(x + y)/(x + z)"
- assert maple_code((x + y) / EulerGamma) == '(x + y)/gamma'
- assert maple_code(x / 3 / pi) == '(1/3)*x/Pi'
- assert maple_code(S(3) / 5 * x * y / pi) == '(3/5)*x*y/Pi'
- def test_mix_number_pow_symbols():
- assert maple_code(pi ** 3) == 'Pi^3'
- assert maple_code(x ** 2) == 'x^2'
- assert maple_code(x ** (pi ** 3)) == 'x^(Pi^3)'
- assert maple_code(x ** y) == 'x^y'
- assert maple_code(x ** (y ** z)) == 'x^(y^z)'
- assert maple_code((x ** y) ** z) == '(x^y)^z'
- def test_imag():
- I = S('I')
- assert maple_code(I) == "I"
- assert maple_code(5 * I) == "5*I"
- assert maple_code((S(3) / 2) * I) == "(3/2)*I"
- assert maple_code(3 + 4 * I) == "3 + 4*I"
- def test_constants():
- assert maple_code(pi) == "Pi"
- assert maple_code(oo) == "infinity"
- assert maple_code(-oo) == "-infinity"
- assert maple_code(S.NegativeInfinity) == "-infinity"
- assert maple_code(S.NaN) == "undefined"
- assert maple_code(S.Exp1) == "exp(1)"
- assert maple_code(exp(1)) == "exp(1)"
- def test_constants_other():
- assert maple_code(2 * GoldenRatio) == '2*(1/2 + (1/2)*sqrt(5))'
- assert maple_code(2 * Catalan) == '2*Catalan'
- assert maple_code(2 * EulerGamma) == "2*gamma"
- def test_boolean():
- assert maple_code(x & y) == "x && y"
- assert maple_code(x | y) == "x || y"
- assert maple_code(~x) == "!x"
- assert maple_code(x & y & z) == "x && y && z"
- assert maple_code(x | y | z) == "x || y || z"
- assert maple_code((x & y) | z) == "z || x && y"
- assert maple_code((x | y) & z) == "z && (x || y)"
- def test_Matrices():
- assert maple_code(Matrix(1, 1, [10])) == \
- 'Matrix([[10]], storage = rectangular)'
- A = Matrix([[1, sin(x / 2), abs(x)],
- [0, 1, pi],
- [0, exp(1), ceiling(x)]])
- expected = \
- 'Matrix(' \
- '[[1, sin((1/2)*x), abs(x)],' \
- ' [0, 1, Pi],' \
- ' [0, exp(1), ceil(x)]], ' \
- 'storage = rectangular)'
- assert maple_code(A) == expected
- # row and columns
- assert maple_code(A[:, 0]) == \
- 'Matrix([[1], [0], [0]], storage = rectangular)'
- assert maple_code(A[0, :]) == \
- 'Matrix([[1, sin((1/2)*x), abs(x)]], storage = rectangular)'
- assert maple_code(Matrix([[x, x - y, -y]])) == \
- 'Matrix([[x, x - y, -y]], storage = rectangular)'
- # empty matrices
- assert maple_code(Matrix(0, 0, [])) == \
- 'Matrix([], storage = rectangular)'
- assert maple_code(Matrix(0, 3, [])) == \
- 'Matrix([], storage = rectangular)'
- def test_SparseMatrices():
- assert maple_code(SparseMatrix(Identity(2))) == 'Matrix([[1, 0], [0, 1]], storage = sparse)'
- def test_vector_entries_hadamard():
- # For a row or column, user might to use the other dimension
- A = Matrix([[1, sin(2 / x), 3 * pi / x / 5]])
- assert maple_code(A) == \
- 'Matrix([[1, sin(2/x), (3/5)*Pi/x]], storage = rectangular)'
- assert maple_code(A.T) == \
- 'Matrix([[1], [sin(2/x)], [(3/5)*Pi/x]], storage = rectangular)'
- def test_Matrices_entries_not_hadamard():
- A = Matrix([[1, sin(2 / x), 3 * pi / x / 5], [1, 2, x * y]])
- expected = \
- 'Matrix([[1, sin(2/x), (3/5)*Pi/x], [1, 2, x*y]], ' \
- 'storage = rectangular)'
- assert maple_code(A) == expected
- def test_MatrixSymbol():
- n = Symbol('n', integer=True)
- A = MatrixSymbol('A', n, n)
- B = MatrixSymbol('B', n, n)
- assert maple_code(A * B) == "A.B"
- assert maple_code(B * A) == "B.A"
- assert maple_code(2 * A * B) == "2*A.B"
- assert maple_code(B * 2 * A) == "2*B.A"
- assert maple_code(
- A * (B + 3 * Identity(n))) == "A.(3*Matrix(n, shape = identity) + B)"
- assert maple_code(A ** (x ** 2)) == "MatrixPower(A, x^2)"
- assert maple_code(A ** 3) == "MatrixPower(A, 3)"
- assert maple_code(A ** (S.Half)) == "MatrixPower(A, 1/2)"
- def test_special_matrices():
- assert maple_code(6 * Identity(3)) == "6*Matrix([[1, 0, 0], [0, 1, 0], [0, 0, 1]], storage = sparse)"
- assert maple_code(Identity(x)) == 'Matrix(x, shape = identity)'
- def test_containers():
- assert maple_code([1, 2, 3, [4, 5, [6, 7]], 8, [9, 10], 11]) == \
- "[1, 2, 3, [4, 5, [6, 7]], 8, [9, 10], 11]"
- assert maple_code((1, 2, (3, 4))) == "[1, 2, [3, 4]]"
- assert maple_code([1]) == "[1]"
- assert maple_code((1,)) == "[1]"
- assert maple_code(Tuple(*[1, 2, 3])) == "[1, 2, 3]"
- assert maple_code((1, x * y, (3, x ** 2))) == "[1, x*y, [3, x^2]]"
- # scalar, matrix, empty matrix and empty list
- assert maple_code((1, eye(3), Matrix(0, 0, []), [])) == \
- "[1, Matrix([[1, 0, 0], [0, 1, 0], [0, 0, 1]], storage = rectangular), Matrix([], storage = rectangular), []]"
- def test_maple_noninline():
- source = maple_code((x + y)/Catalan, assign_to='me', inline=False)
- expected = "me := (x + y)/Catalan"
- assert source == expected
- def test_maple_matrix_assign_to():
- A = Matrix([[1, 2, 3]])
- assert maple_code(A, assign_to='a') == "a := Matrix([[1, 2, 3]], storage = rectangular)"
- A = Matrix([[1, 2], [3, 4]])
- assert maple_code(A, assign_to='A') == "A := Matrix([[1, 2], [3, 4]], storage = rectangular)"
- def test_maple_matrix_assign_to_more():
- # assigning to Symbol or MatrixSymbol requires lhs/rhs match
- A = Matrix([[1, 2, 3]])
- B = MatrixSymbol('B', 1, 3)
- C = MatrixSymbol('C', 2, 3)
- assert maple_code(A, assign_to=B) == "B := Matrix([[1, 2, 3]], storage = rectangular)"
- raises(ValueError, lambda: maple_code(A, assign_to=x))
- raises(ValueError, lambda: maple_code(A, assign_to=C))
- def test_maple_matrix_1x1():
- A = Matrix([[3]])
- assert maple_code(A, assign_to='B') == "B := Matrix([[3]], storage = rectangular)"
- def test_maple_matrix_elements():
- A = Matrix([[x, 2, x * y]])
- assert maple_code(A[0, 0] ** 2 + A[0, 1] + A[0, 2]) == "x^2 + x*y + 2"
- AA = MatrixSymbol('AA', 1, 3)
- assert maple_code(AA) == "AA"
- assert maple_code(AA[0, 0] ** 2 + sin(AA[0, 1]) + AA[0, 2]) == \
- "sin(AA[1, 2]) + AA[1, 1]^2 + AA[1, 3]"
- assert maple_code(sum(AA)) == "AA[1, 1] + AA[1, 2] + AA[1, 3]"
- def test_maple_boolean():
- assert maple_code(True) == "true"
- assert maple_code(S.true) == "true"
- assert maple_code(False) == "false"
- assert maple_code(S.false) == "false"
- def test_sparse():
- M = SparseMatrix(5, 6, {})
- M[2, 2] = 10
- M[1, 2] = 20
- M[1, 3] = 22
- M[0, 3] = 30
- M[3, 0] = x * y
- assert maple_code(M) == \
- 'Matrix([[0, 0, 0, 30, 0, 0],' \
- ' [0, 0, 20, 22, 0, 0],' \
- ' [0, 0, 10, 0, 0, 0],' \
- ' [x*y, 0, 0, 0, 0, 0],' \
- ' [0, 0, 0, 0, 0, 0]], ' \
- 'storage = sparse)'
- # Not an important point.
- def test_maple_not_supported():
- assert maple_code(S.ComplexInfinity) == (
- "# Not supported in maple:\n"
- "# ComplexInfinity\n"
- "zoo"
- ) # PROBLEM
- def test_MatrixElement_printing():
- # test cases for issue #11821
- A = MatrixSymbol("A", 1, 3)
- B = MatrixSymbol("B", 1, 3)
- assert (maple_code(A[0, 0]) == "A[1, 1]")
- assert (maple_code(3 * A[0, 0]) == "3*A[1, 1]")
- F = A-B
- assert (maple_code(F[0,0]) == "A[1, 1] - B[1, 1]")
- def test_hadamard():
- A = MatrixSymbol('A', 3, 3)
- B = MatrixSymbol('B', 3, 3)
- v = MatrixSymbol('v', 3, 1)
- h = MatrixSymbol('h', 1, 3)
- C = HadamardProduct(A, B)
- assert maple_code(C) == "A*B"
- assert maple_code(C * v) == "(A*B).v"
- # HadamardProduct is higher than dot product.
- assert maple_code(h * C * v) == "h.(A*B).v"
- assert maple_code(C * A) == "(A*B).A"
- # mixing Hadamard and scalar strange b/c we vectorize scalars
- assert maple_code(C * x * y) == "x*y*(A*B)"
- def test_maple_piecewise():
- expr = Piecewise((x, x < 1), (x ** 2, True))
- assert maple_code(expr) == "piecewise(x < 1, x, x^2)"
- assert maple_code(expr, assign_to="r") == (
- "r := piecewise(x < 1, x, x^2)")
- expr = Piecewise((x ** 2, x < 1), (x ** 3, x < 2), (x ** 4, x < 3), (x ** 5, True))
- expected = "piecewise(x < 1, x^2, x < 2, x^3, x < 3, x^4, x^5)"
- assert maple_code(expr) == expected
- assert maple_code(expr, assign_to="r") == "r := " + expected
- # Check that Piecewise without a True (default) condition error
- expr = Piecewise((x, x < 1), (x ** 2, x > 1), (sin(x), x > 0))
- raises(ValueError, lambda: maple_code(expr))
- def test_maple_piecewise_times_const():
- pw = Piecewise((x, x < 1), (x ** 2, True))
- assert maple_code(2 * pw) == "2*piecewise(x < 1, x, x^2)"
- assert maple_code(pw / x) == "piecewise(x < 1, x, x^2)/x"
- assert maple_code(pw / (x * y)) == "piecewise(x < 1, x, x^2)/(x*y)"
- assert maple_code(pw / 3) == "(1/3)*piecewise(x < 1, x, x^2)"
- def test_maple_derivatives():
- f = Function('f')
- assert maple_code(f(x).diff(x)) == 'diff(f(x), x)'
- assert maple_code(f(x).diff(x, 2)) == 'diff(f(x), x$2)'
- def test_automatic_rewrites():
- assert maple_code(lucas(x)) == '2^(-x)*((1 - sqrt(5))^x + (1 + sqrt(5))^x)'
- assert maple_code(sinc(x)) == 'piecewise(x <> 0, sin(x)/x, 1)'
- def test_specfun():
- assert maple_code('asin(x)') == 'arcsin(x)'
- assert maple_code(besseli(x, y)) == 'BesselI(x, y)'
|