def test_Matrix_array(): class matarray: def __array__(self): from numpy import array return array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) matarr = matarray() assert Matrix(matarr) == Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
def test_Matrix_sum(): M = Matrix([[1, 2, 3], [x, y, x], [2 * y, -50, z * x]]) m = numpy.array([[2, 3, 4], [x, 5, 6], [x, y, z**2]]) assert M + m == Matrix([[3, 5, 7], [2 * x, y + 5, x + 6], [2 * y + x, y - 50, z * x + z**2]]) assert m + M == Matrix([[3, 5, 7], [2 * x, y + 5, x + 6], [2 * y + x, y - 50, z * x + z**2]]) assert M + m == M.add(m)
def test_funcmatrix(): X = FunctionMatrix(3, 3, Lambda((i, j), i - j)) assert X[1, 1] == 0 assert X[1, 2] == -1 assert X.shape == (3, 3) assert X.rows == X.cols == 3 assert Matrix(X) == Matrix(3, 3, lambda i, j: i - j) assert isinstance(X * X + X, MatrixExpr)
def test_matrix_to_vector(): m = Matrix([[1], [2], [3]]) assert matrix_to_vector(m, C) == C.i + 2 * C.j + 3 * C.k m = Matrix([[0], [0], [0]]) assert matrix_to_vector(m, N) == matrix_to_vector(m, C) == \ Vector.zero m = Matrix([[q1], [q2], [q3]]) assert matrix_to_vector(m, N) == q1 * N.i + q2 * N.j + q3 * N.k
def test_sympyissue_11678(): p = Matrix([[1./2, 1./4, 1./4], [1./2, 0, 1./2], [1./4, 0, 3./4]]) e = (p**x).applyfunc(lambda i: limit(i, x, oo)) assert e == Matrix([[Float('0.36363636363636359', prec=15), Float('0.090909090909090898', prec=15), Float('0.54545454545454541', prec=15)]]*3)
def test_orienters(): A = CoordSysCartesian('A') axis_orienter = AxisOrienter(a, A.k) B = body_orienter = BodyOrienter(a, b, c, '123') assert (B.angle1, B.angle2, B.angle3) == (a, b, c) assert B.rot_order == '123' B = BodyOrienter(a, b, c, Symbol('123')) assert B.rot_order == '123' space_orienter = SpaceOrienter(a, b, c, '123') Q = q_orienter = QuaternionOrienter(q1, q2, q3, q4) assert (Q.q0, Q.q1, Q.q2, Q.q3) == (q1, q2, q3, q4) assert axis_orienter.rotation_matrix(A) == Matrix([[+cos(a), sin(a), 0], [-sin(a), cos(a), 0], [0, 0, 1]]) assert body_orienter.rotation_matrix() == Matrix( [[ cos(b) * cos(c), sin(a) * sin(b) * cos(c) + sin(c) * cos(a), sin(a) * sin(c) - sin(b) * cos(a) * cos(c) ], [ -sin(c) * cos(b), -sin(a) * sin(b) * sin(c) + cos(a) * cos(c), sin(a) * cos(c) + sin(b) * sin(c) * cos(a) ], [sin(b), -sin(a) * cos(b), cos(a) * cos(b)]]) assert space_orienter.rotation_matrix() == Matrix( [[cos(b) * cos(c), sin(c) * cos(b), -sin(b)], [ sin(a) * sin(b) * cos(c) - sin(c) * cos(a), sin(a) * sin(b) * sin(c) + cos(a) * cos(c), sin(a) * cos(b) ], [ sin(a) * sin(c) + sin(b) * cos(a) * cos(c), -sin(a) * cos(c) + sin(b) * sin(c) * cos(a), cos(a) * cos(b) ]]) assert q_orienter.rotation_matrix() == Matrix( [[ q1**2 + q2**2 - q3**2 - q4**2, 2 * q1 * q4 + 2 * q2 * q3, -2 * q1 * q3 + 2 * q2 * q4 ], [ -2 * q1 * q4 + 2 * q2 * q3, q1**2 - q2**2 + q3**2 - q4**2, 2 * q1 * q2 + 2 * q3 * q4 ], [ 2 * q1 * q3 + 2 * q2 * q4, -2 * q1 * q2 + 2 * q3 * q4, q1**2 - q2**2 - q3**2 + q4**2 ]]) B = CoordSysCartesian('T') pytest.raises(ValueError, lambda: A.orient_new_axis('A', a, B.i)) pytest.raises(TypeError, lambda: BodyOrienter(a, b, c, '12')) pytest.raises(TypeError, lambda: BodyOrienter(a, b, c, '111'))
def test_matrix(): A = Matrix([[x, y], [y * x, z**2]]) assert lambdarepr(A) == "MutableDenseMatrix([[x, y], [x*y, z**2]])" # Test printing a Matrix that has an element that is printed differently # with the LambdaPrinter than in the StrPrinter. p = Piecewise((x, True), evaluate=False) A = Matrix([p]) assert lambdarepr(A) == "MutableDenseMatrix([[((x) if (True) else None)]])"
def test_necklaces(): def count(n, k, f): return len(list(necklaces(n, k, f))) m = [] for i in range(1, 8): m.append((i, count(i, 2, 0), count(i, 2, 1), count(i, 3, 1))) assert Matrix(m) == Matrix([[1, 2, 2, 3], [2, 3, 3, 6], [3, 4, 4, 10], [4, 6, 6, 21], [5, 8, 8, 39], [6, 14, 13, 92], [7, 20, 18, 198]])
def test_numpy_matmul(): xmat = Matrix([[x, y], [z, 1+z]]) ymat = Matrix([[x**2], [Abs(x)]]) mat_func = lambdify((x, y, z), xmat*ymat, modules="numpy") numpy.testing.assert_array_equal(mat_func(0.5, 3, 4), numpy.array([[1.625], [3.5]])) numpy.testing.assert_array_equal(mat_func(-0.5, 3, 4), numpy.array([[1.375], [3.5]])) # Multiple matrices chained together in multiplication f = lambdify((x, y, z), xmat*xmat*xmat, modules="numpy") numpy.testing.assert_array_equal(f(0.5, 3, 4), numpy.array([[72.125, 119.25], [159, 251]]))
def test_constant_system(): A = Matrix([[-(x + 3) / (x - 1), (x + 1) / (x - 1), 1], [-x - 3, x + 1, x - 1], [2 * (x + 3) / (x - 1), 0, 0]]) u = Matrix([(x + 1) / (x - 1), x + 1, 0]) DE = DifferentialExtension(extension={'D': [Poly(1, x)]}) assert constant_system(A, u, DE) == \ (Matrix([[1, 0, 0], [0, 1, 0], [0, 0, 0], [0, 0, 1]]), Matrix([0, 1, 0, 0]))
def test_transpose(): assert transpose(A * B) == Transpose(B) * Transpose(A) assert transpose(2 * A * B) == 2 * Transpose(B) * Transpose(A) assert transpose(2 * I * C) == 2 * I * Transpose(C) M = Matrix(2, 2, [1, 2 + I, 3, 4]).as_immutable() MT = Matrix(2, 2, [1, 3, 2 + I, 4]) assert transpose(M) == MT assert transpose(2 * M) == 2 * MT assert transpose(MatMul(2, M)) == MatMul(2, MT).doit()
def test_adjoint(): assert adjoint(A * B) == Adjoint(B) * Adjoint(A) assert adjoint(2 * A * B) == 2 * Adjoint(B) * Adjoint(A) assert adjoint(2 * I * C) == -2 * I * Adjoint(C) M = Matrix(2, 2, [1, 2 + I, 3, 4]).as_immutable() MA = Matrix(2, 2, [1, 3, 2 - I, 4]) assert adjoint(M) == MA assert adjoint(2 * M) == 2 * MA assert adjoint(MatMul(2, M)) == MatMul(2, MA).doit()
def test_matrix2numpy_conversion(): a = Matrix([[1, 2, sin(x)], [x**2, x, Rational(1, 2)]]) b = numpy.array([[1, 2, sin(x)], [x**2, x, Rational(1, 2)]]) assert (matrix2numpy(a) == b).all() assert matrix2numpy(a).dtype == numpy.dtype('object') c = matrix2numpy(Matrix([[1, 2], [10, 20]]), dtype='int8') d = matrix2numpy(Matrix([[1, 2], [10, 20]]), dtype='float64') assert c.dtype == numpy.dtype('int8') assert d.dtype == numpy.dtype('float64')
def test_atan2_expansion(): assert cancel(atan2(x**2, x + 1).diff(x) - atan(x**2/(x + 1)).diff(x)) == 0 assert cancel(atan(y/x).series(y, 0, 5) - atan2(y, x).series(y, 0, 5) + atan2(0, x) - atan(0)) == O(y**5) assert cancel(atan(y/x).series(x, 1, 4) - atan2(y, x).series(x, 1, 4) + atan2(y, 1) - atan(y)) == O((x - 1)**4, (x, 1)) assert cancel(atan((y + x)/x).series(x, 1, 3) - atan2(y + x, x).series(x, 1, 3) + atan2(1 + y, 1) - atan(1 + y)) == O((x - 1)**3, (x, 1)) assert Matrix([atan2(y, x)]).jacobian([y, x]) == \ Matrix([[x/(y**2 + x**2), -y/(y**2 + x**2)]])
def _get_valued_base_test_variables(): minkowski = Matrix(( (1, 0, 0, 0), (0, -1, 0, 0), (0, 0, -1, 0), (0, 0, 0, -1), )) Lorentz = TensorIndexType('Lorentz', dim=4) Lorentz.data = minkowski i0, i1, i2, i3, i4 = tensor_indices('i0:5', Lorentz) E, px, py, pz = symbols('E px py pz') A = tensorhead('A', [Lorentz], [[1]]) A.data = [E, px, py, pz] B = tensorhead('B', [Lorentz], [[1]], 'Gcomm') B.data = range(4) AB = tensorhead('AB', [Lorentz] * 2, [[1]]*2) AB.data = minkowski ba_matrix = Matrix(( (1, 2, 3, 4), (5, 6, 7, 8), (9, 0, -1, -2), (-3, -4, -5, -6), )) BA = tensorhead('BA', [Lorentz] * 2, [[1]]*2) BA.data = ba_matrix # Let's test the diagonal metric, with inverted Minkowski metric: LorentzD = TensorIndexType('LorentzD') LorentzD.data = [-1, 1, 1, 1] mu0, mu1, mu2 = tensor_indices('mu0:3', LorentzD) C = tensorhead('C', [LorentzD], [[1]]) C.data = [E, px, py, pz] # ### non-diagonal metric ### ndm_matrix = ( (1, 1, 0,), (1, 0, 1), (0, 1, 0,), ) ndm = TensorIndexType('ndm') ndm.data = ndm_matrix n0, n1, n2 = tensor_indices('n0:3', ndm) NA = tensorhead('NA', [ndm], [[1]]) NA.data = range(10, 13) NB = tensorhead('NB', [ndm]*2, [[1]]*2) NB.data = [[i+j for j in range(10, 13)] for i in range(10, 13)] NC = tensorhead('NC', [ndm]*3, [[1]]*3) NC.data = [[[i+j+k for k in range(4, 7)] for j in range(1, 4)] for i in range(2, 5)] return (A, B, AB, BA, C, Lorentz, E, px, py, pz, LorentzD, mu0, mu1, mu2, ndm, n0, n1, n2, NA, NB, NC, minkowski, ba_matrix, ndm_matrix, i0, i1, i2, i3, i4)
def test_simplify_expr(): A = Symbol('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)) 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) 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 # (x + y)*A/(x*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_solve_linear_system(): assert solve_linear_system(Matrix([[0, 0]]), x) == {} M = Matrix([[0, 0, n * (n + 1), (n + 1)**2, 0], [n + 1, n + 1, -2 * n - 1, -(n + 1), 0], [-1, 0, 1, 0, 0]]) assert solve_linear_system(M, x, y, z, t) == { x: -t - t / n, z: -t - t / n, y: 0 }
def test_matrix(): A = Matrix([[x, x*y], [sin(z) + 4, x**z]]) sol = Matrix([[1, 2], [sin(3) + 4, 1]]) f = lambdify((x, y, z), A, modules="diofant") assert f(1, 2, 3) == sol f = lambdify((x, y, z), (A, [A]), modules="diofant") assert f(1, 2, 3) == (sol, [sol]) J = Matrix((x, x + y)).jacobian((x, y)) v = Matrix((x, y)) sol = Matrix([[1, 0], [1, 1]]) assert lambdify(v, J, modules='diofant')(1, 2) == sol assert lambdify(v.T, J, modules='diofant')(1, 2) == sol
def test_Matrix_str(): M = Matrix([[x**+1, 1], [y, x + y]]) assert str(M) == "Matrix([\n[x, 1],\n[y, x + y]])" assert sstr(M) == "Matrix([\n[x, 1],\n[y, x + y]])" M = Matrix([[1]]) assert str(M) == sstr(M) == "Matrix([[1]])" M = Matrix([[1, 2]]) assert str(M) == sstr(M) == "Matrix([[1, 2]])" M = Matrix() assert str(M) == sstr(M) == "Matrix(0, 0, [])" M = Matrix(0, 1, lambda i, j: 0) assert str(M) == sstr(M) == "Matrix(0, 1, [])"
def test_from_ndarray(): # See sympy/sympy#7465 assert Matrix(numpy.array([1, 2, 3])) == Matrix([1, 2, 3]) assert Matrix(numpy.array([[1, 2, 3]])) == Matrix([[1, 2, 3]]) assert Matrix(numpy.array([[1, 2, 3], [4, 5, 6]])) == \ Matrix([[1, 2, 3], [4, 5, 6]]) assert Matrix(numpy.array([x, y, z])) == Matrix([x, y, z]) pytest.raises(NotImplementedError, lambda: Matrix(numpy.array([[ [1, 2], [3, 4]], [[5, 6], [7, 8]]])))
def test_Matrix2(): a = numpy.array([[2, 4], [5, 1]]) assert Matrix(a) == Matrix([[2, 4], [5, 1]]) assert Matrix(a) != Matrix([[2, 4], [5, 2]]) a = numpy.array([[sin(2), 4], [5, 1]]) assert Matrix(a) == Matrix([[sin(2), 4], [5, 1]]) assert Matrix(a) != Matrix([[sin(0), 4], [5, 1]])
def test_diff_integrate(): M = Matrix([x, 1]).as_immutable() assert M.integrate(x) == Matrix([x**2 / 2, x]) assert M.diff(x) == Matrix([1, 0]) assert M.limit(x, 1) == Matrix([1, 1]) assert zeros(2).as_immutable().integrate(x) == zeros(2)
def test_Matrix4(): a = matrix([[2, 4], [5, 1]]) assert Matrix(a) == Matrix([[2, 4], [5, 1]]) assert Matrix(a) != Matrix([[2, 4], [5, 2]]) a = matrix([[sin(2), 4], [5, 1]]) assert Matrix(a) == Matrix([[sin(2), 4], [5, 1]]) assert Matrix(a) != Matrix([[sin(0), 4], [5, 1]])
def test_rotation_matrix(): N = CoordSysCartesian('N') A = N.orient_new_axis('A', q1, N.k) B = A.orient_new_axis('B', q2, A.i) C = B.orient_new_axis('C', q3, B.j) D = N.orient_new_axis('D', q4, N.j) E = N.orient_new_space('E', q1, q2, q3, '123') F = N.orient_new_quaternion('F', q1, q2, q3, q4) G = N.orient_new_body('G', q1, q2, q3, '123') assert N.rotation_matrix(C) == Matrix([ [- sin(q1) * sin(q2) * sin(q3) + cos(q1) * cos(q3), - sin(q1) * cos(q2), sin(q1) * sin(q2) * cos(q3) + sin(q3) * cos(q1)], [sin(q1) * cos(q3) + sin(q2) * sin(q3) * cos(q1), cos(q1) * cos(q2), sin(q1) * sin(q3) - sin(q2) * cos(q1) * cos(q3)], [- sin(q3) * cos(q2), sin(q2), cos(q2) * cos(q3)]]) test_mat = D.rotation_matrix(C) - Matrix( [[cos(q1) * cos(q3) * cos(q4) - sin(q3) * (- sin(q4) * cos(q2) + sin(q1) * sin(q2) * cos(q4)), - sin(q2) * sin(q4) - sin(q1) * cos(q2) * cos(q4), sin(q3) * cos(q1) * cos(q4) + cos(q3) * (- sin(q4) * cos(q2) + sin(q1) * sin(q2) * cos(q4))], [sin(q1) * cos(q3) + sin(q2) * sin(q3) * cos(q1), cos(q1) * cos(q2), sin(q1) * sin(q3) - sin(q2) * cos(q1) * cos(q3)], [sin(q4) * cos(q1) * cos(q3) - sin(q3) * (cos(q2) * cos(q4) + sin(q1) * sin(q2) * sin(q4)), sin(q2) * cos(q4) - sin(q1) * sin(q4) * cos(q2), sin(q3) * sin(q4) * cos(q1) + cos(q3) * (cos(q2) * cos(q4) + sin(q1) * sin(q2) * sin(q4))]]) assert test_mat.expand() == zeros(3, 3) assert E.rotation_matrix(N) == Matrix( [[cos(q2)*cos(q3), sin(q3)*cos(q2), -sin(q2)], [sin(q1)*sin(q2)*cos(q3) - sin(q3)*cos(q1), sin(q1)*sin(q2)*sin(q3) + cos(q1)*cos(q3), sin(q1)*cos(q2)], [sin(q1)*sin(q3) + sin(q2)*cos(q1)*cos(q3), - sin(q1)*cos(q3) + sin(q2)*sin(q3)*cos(q1), cos(q1)*cos(q2)]]) assert F.rotation_matrix(N) == Matrix([[ q1**2 + q2**2 - q3**2 - q4**2, 2*q1*q4 + 2*q2*q3, -2*q1*q3 + 2*q2*q4], [ -2*q1*q4 + 2*q2*q3, q1**2 - q2**2 + q3**2 - q4**2, 2*q1*q2 + 2*q3*q4], [2*q1*q3 + 2*q2*q4, -2*q1*q2 + 2*q3*q4, q1**2 - q2**2 - q3**2 + q4**2]]) assert G.rotation_matrix(N) == Matrix([[ cos(q2)*cos(q3), sin(q1)*sin(q2)*cos(q3) + sin(q3)*cos(q1), sin(q1)*sin(q3) - sin(q2)*cos(q1)*cos(q3)], [ -sin(q3)*cos(q2), -sin(q1)*sin(q2)*sin(q3) + cos(q1)*cos(q3), sin(q1)*cos(q3) + sin(q2)*sin(q3)*cos(q1)], [ sin(q2), -sin(q1)*cos(q2), cos(q1)*cos(q2)]]) pytest.raises(TypeError, lambda: G.rotation_matrix(a))
def test_prde_linear_constraints(): DE = DifferentialExtension(extension={'D': [Poly(1, x)]}) G = [(Poly(2*x**3 + 3*x + 1, x), Poly(x**2 - 1, x)), (Poly(1, x), Poly(x - 1, x)), (Poly(1, x), Poly(x + 1, x))] assert prde_linear_constraints(Poly(1, x), Poly(0, x), G, DE) == \ ((Poly(2*x, x), Poly(0, x), Poly(0, x)), Matrix([[1, 1, -1], [5, 1, 1]])) G = [(Poly(t, t), Poly(1, t)), (Poly(t**2, t), Poly(1, t)), (Poly(t**3, t), Poly(1, t))] DE = DifferentialExtension(extension={'D': [Poly(1, x), Poly(t, t)]}) assert prde_linear_constraints(Poly(t + 1, t), Poly(t**2, t), G, DE) == \ ((Poly(t, t), Poly(t**2, t), Poly(t**3, t)), Matrix()) G = [(Poly(2*x, t), Poly(t, t)), (Poly(-x, t), Poly(t, t))] DE = DifferentialExtension(extension={'D': [Poly(1, x), Poly(1/x, t)]}) prde_linear_constraints(Poly(1, t), Poly(0, t), G, DE) == \ ((Poly(0, t), Poly(0, t)), Matrix([[2*x, -x]]))
def test_converting_functions(): arr_list = [1, 2, 3, 4] arr_matrix = Matrix(((1, 2), (3, 4))) # list arr_ndim_array = MutableDenseNDimArray(arr_list, (2, 2)) assert isinstance(arr_ndim_array, MutableDenseNDimArray) assert arr_matrix.tolist() == arr_ndim_array.tolist() # Matrix arr_ndim_array = MutableDenseNDimArray(arr_matrix) assert isinstance(arr_ndim_array, MutableDenseNDimArray) assert arr_matrix.tolist() == arr_ndim_array.tolist() assert arr_matrix.shape == arr_ndim_array.shape
def test_Matrices(): assert octave_code(Matrix(1, 1, [10])) == '10' A = Matrix([[1, sin(x / 2), abs(x)], [0, 1, pi], [0, exp(1), ceiling(x)]]) expected = ('[1 sin(x/2) abs(x);\n' '0 1 pi;\n' '0 exp(1) ceil(x)]') assert octave_code(A) == expected # row and columns assert octave_code(A[:, 0]) == '[1; 0; 0]' assert octave_code(A[0, :]) == '[1 sin(x/2) abs(x)]' # empty matrices assert octave_code(Matrix(0, 0, [])) == '[]' assert octave_code(Matrix(0, 3, [])) == 'zeros(0, 3)' # annoying to read but correct assert octave_code(Matrix([[x, x - y, -y]])) == '[x x - y -y]'
def test_BlockMatrix(): A = MatrixSymbol('A', n, m) B = MatrixSymbol('B', n, k) C = MatrixSymbol('C', l, m) D = MatrixSymbol('D', l, k) M = MatrixSymbol('M', m + k, p) N = MatrixSymbol('N', l + n, k + m) X = BlockMatrix(Matrix([[A, B], [C, D]])) assert X.__class__(*X.args) == X # block_collapse does nothing on normal inputs E = MatrixSymbol('E', n, m) assert block_collapse(A + 2 * E) == A + 2 * E F = MatrixSymbol('F', m, m) assert block_collapse(E.T * A * F) == E.T * A * F assert X.shape == (l + n, k + m) assert X.blockshape == (2, 2) assert transpose(X) == BlockMatrix(Matrix([[A.T, C.T], [B.T, D.T]])) assert transpose(X).shape == X.shape[::-1] # Test that BlockMatrices and MatrixSymbols can still mix assert (X * M).is_MatMul assert X._blockmul(M).is_MatMul assert (X * M).shape == (n + l, p) assert (X + N).is_MatAdd assert X._blockadd(N).is_MatAdd assert (X + N).shape == X.shape E = MatrixSymbol('E', m, 1) F = MatrixSymbol('F', k, 1) Y = BlockMatrix(Matrix([[E], [F]])) assert (X * Y).shape == (l + n, 1) assert block_collapse(X * Y).blocks[0, 0] == A * E + B * F assert block_collapse(X * Y).blocks[1, 0] == C * E + D * F # block_collapse passes down into container objects, transposes, and inverse assert block_collapse(transpose(X * Y)) == transpose(block_collapse(X * Y)) assert block_collapse(Tuple(X * Y, 2 * X)) == (block_collapse(X * Y), block_collapse(2 * X)) # Make sure that MatrixSymbols will enter 1x1 BlockMatrix if it simplifies Ab = BlockMatrix([[A]]) Z = MatrixSymbol('Z', *A.shape) assert block_collapse(Ab + Z) == A + Z
def test_Matrix_mul(): M = Matrix([[1, 2, 3], [x, y, x]]) m = numpy.array([[2, 4], [x, 6], [x, z**2]]) assert M * m == Matrix([ [2 + 5 * x, 16 + 3 * z**2], [2 * x + x * y + x**2, 4 * x + 6 * y + x * z**2], ]) assert m * M == Matrix([ [2 + 4 * x, 4 + 4 * y, 6 + 4 * x], [7 * x, 2 * x + 6 * y, 9 * x], [x + x * z**2, 2 * x + y * z**2, 3 * x + x * z**2], ]) a = numpy.array([2]) assert a[0] * M == 2 * M assert M * a[0] == 2 * M
def test_m_matrix_output_autoname_2(): e1 = (x + y) e2 = Matrix([[2 * x, 2 * y, 2 * z]]) e3 = Matrix([[x], [y], [z]]) e4 = Matrix([[x, y], [z, 16]]) name_expr = ('test', (e1, e2, e3, e4)) result, = codegen(name_expr, 'Octave', header=False, empty=False) source = result[1] expected = ('function [out1, out2, out3, out4] = test(x, y, z)\n' ' out1 = x + y;\n' ' out2 = [2*x 2*y 2*z];\n' ' out3 = [x; y; z];\n' ' out4 = [x y;\n' ' z 16];\n' 'end\n') assert source == expected
def test_sympyissue_2827_trigsimp_methods(): def measure1(expr): return len(str(expr)) def measure2(expr): return -count_ops(expr) # Return the most complicated result expr = (x + 1)/(x + sin(x)**2 + cos(x)**2) ans = Matrix([1]) M = Matrix([expr]) assert trigsimp(M, method='fu', measure=measure1) == ans assert trigsimp(M, method='fu', measure=measure2) != ans # all methods should work with Basic expressions even if they # aren't Expr M = Matrix.eye(1) assert all(trigsimp(M, method=m) == M for m in 'fu matching groebner old'.split()) # watch for E in exptrigsimp, not only exp() eq = 1/sqrt(E) + E assert exptrigsimp(eq) == eq
def test_as_immutable(): X = Matrix([[1, 2], [3, 4]]) assert sympify(X) == X.as_immutable() == ImmutableMatrix([[1, 2], [3, 4]]) X = SparseMatrix(5, 5, {}) assert sympify(X) == X.as_immutable() == ImmutableSparseMatrix( [[0 for i in range(5)] for i in range(5)])
def test_sympyissue_11413(): V = Matrix([[x], [y], [z]]) U = V.normalized() r = sqrt(Abs(x)**2 + Abs(y)**2 + Abs(z)**2) assert U == Matrix([[x/r], [y/r], [z/r]]) assert U.norm().simplify() == 1