def test_squareBlockMatrix(): n, m, l, k = symbols('n m l k', integer=True) A = MatrixSymbol('A', n, n) B = MatrixSymbol('B', n, m) C = MatrixSymbol('C', m, n) D = MatrixSymbol('D', m, m) X = BlockMatrix([[A, B], [C, D]]) Y = BlockMatrix([[A]]) assert X.is_square assert block_collapse(X + Identity(m + n)) == BlockMatrix( [[A + Identity(n), B], [C, D + Identity(m)]]) Q = X + Identity(m + n) assert block_collapse(Inverse(Q)) == Inverse(block_collapse(Q)) assert (X + MatrixSymbol('Q', n + m, n + m)).is_Add assert (X * MatrixSymbol('Q', n + m, n + m)).is_Mul assert Y.I.blocks[0, 0] == A.I assert Inverse(X, expand=True) == BlockMatrix([[ (-B * D.I * C + A).I, -A.I * B * (D + -C * A.I * B).I ], [-(D - C * A.I * B).I * C * A.I, (D - C * A.I * B).I]]) assert Inverse(X, expand=False).is_Inverse assert X.inverse().is_Inverse assert not X.is_Identity Z = BlockMatrix([[Identity(n), B], [C, D]]) assert not Z.is_Identity
def test_inverse(): n, m, l = symbols('n m l', integer=True) A = MatrixSymbol('A', n, m) B = MatrixSymbol('B', m, l) C = MatrixSymbol('C', n, n) D = MatrixSymbol('D', n, n) E = MatrixSymbol('E', m, n) raises(ShapeError, lambda: Inverse(A)) assert Inverse(Inverse(C)) == C assert Inverse(C) * C == Identity(C.rows) assert Inverse(eye(3)) == eye(3) assert Inverse(S(3)) == S(1) / 3 assert Inverse(Identity(n)) == Identity(n) # Simplifies Muls if possible (i.e. submatrices are square) assert Inverse(C * D) == D.I * C.I # But still works when not possible assert Inverse(A * E).is_Inverse # We play nice with traditional explicit matrices assert Inverse(Matrix([[1, 2], [3, 4]])) == Matrix([[1, 2], [3, 4]]).inv()
def test_combine_powers(): assert combine_powers(MatMul(D, Inverse(D), D, evaluate=False)) == \ MatMul(Identity(n), D, evaluate=False) assert combine_powers(MatMul(B.T, Inverse(E*A), E, A, B, evaluate=False)) == \ MatMul(B.T, Identity(m), B, evaluate=False) assert combine_powers(MatMul(A, E, Inverse(A*E), D, evaluate=False)) == \ MatMul(Identity(n), D, evaluate=False)
def pdf(self, x): M , U , V = self.location_matrix, self.scale_matrix_1, self.scale_matrix_2 n, p = M.shape if isinstance(x, list): x = ImmutableMatrix(x) if not isinstance(x, (MatrixBase, MatrixSymbol)): raise ValueError("%s should be an isinstance of Matrix " "or MatrixSymbol" % str(x)) term1 = Inverse(V)*Transpose(x - M)*Inverse(U)*(x - M) num = exp(-Trace(term1)/S(2)) den = (2*pi)**(S(n*p)/2) * Determinant(U)**S(p)/2 * Determinant(V)**S(n)/2 return num/den
def pdf(self, x): from sympy import eye if isinstance(x, list): x = ImmutableMatrix(x) if not isinstance(x, (MatrixBase, MatrixSymbol)): raise ValueError("%s should be an isinstance of Matrix " "or MatrixSymbol" % str(x)) nu, M, Omega, Sigma = self.nu, self.location_matrix, self.scale_matrix_1, self.scale_matrix_2 n, p = M.shape K = multigamma((nu + n + p - 1)/2, p) * Determinant(Omega)**(-n/2) * Determinant(Sigma)**(-p/2) \ / ((pi)**(n*p/2) * multigamma((nu + p - 1)/2, p)) return K * (Determinant(eye(n) + Inverse(Sigma)*(x - M)*Inverse(Omega)*Transpose(x - M))) \ **(-(nu + n + p -1)/2)
def test_MatPow(): n = Symbol('n', integer=True) A = MatrixSymbol('A', n, n) assert Inverse(A).is_Pow assert (A * A).is_Pow assert (A * A).exp == 2 assert (A * A).base == A assert (A**n).exp == n assert A**0 == Identity(n) assert A**1 == A assert A**-1 == Inverse(A) raises(ShapeError, "MatrixSymbol('B', 3,2)**2")
def test_Adjoint(): from sympy.matrices import MatrixSymbol, Adjoint, Inverse, Transpose X = MatrixSymbol('X', 2, 2) Y = MatrixSymbol('Y', 2, 2) assert latex(Adjoint(X)) == r'X^\dag' assert latex(Adjoint(X + Y)) == r'\left(X + Y\right)^\dag' assert latex(Adjoint(X) + Adjoint(Y)) == r'X^\dag + Y^\dag' assert latex(Adjoint(X * Y)) == r'\left(X Y\right)^\dag' assert latex(Adjoint(Y) * Adjoint(X)) == r'Y^\dag X^\dag' assert latex(Adjoint(X**2)) == r'\left(X^{2}\right)^\dag' assert latex(Adjoint(X)**2) == r'\left(X^\dag\right)^{2}' assert latex(Adjoint(Inverse(X))) == r'\left(X^{-1}\right)^\dag' assert latex(Inverse(Adjoint(X))) == r'\left(X^\dag\right)^{-1}' assert latex(Adjoint(Transpose(X))) == r'\left(X^T\right)^\dag' assert latex(Transpose(Adjoint(X))) == r'\left(X^\dag\right)^T'
def test_invariants(): A = MatrixSymbol('A', n, m) B = MatrixSymbol('B', m, l) X = MatrixSymbol('X', n, n) objs = [Identity(n), ZeroMatrix(m, n), A, MatMul(A, B), MatAdd(A, A), Transpose(A), Adjoint(A), Inverse(X), MatPow(X, 2), MatPow(X, -1), MatPow(X, 0)] for obj in objs: assert obj == obj.__class__(*obj.args)
def test_inverse(): raises(ShapeError, lambda: Inverse(A)) assert Inverse(Inverse(C)) == C assert Inverse(C) * C == Identity(C.rows) assert Inverse(eye(3)) == eye(3) assert Inverse(S(3)) == S(1) / 3 assert Inverse(Identity(n)) == Identity(n) # Simplifies Muls if possible (i.e. submatrices are square) assert Inverse(C * D) == D.I * C.I # But still works when not possible assert Inverse(A * E).is_Inverse # We play nice with traditional explicit matrices assert Inverse(Matrix([[1, 2], [3, 4]])) == Matrix([[1, 2], [3, 4]]).inv()
def test_Identity(): A = MatrixSymbol('A', n, m) In = Identity(n) Im = Identity(m) assert A * Im == A assert In * A == A assert Transpose(In) == In assert Inverse(In) == In assert In.conjugate() == In
def test_Identity(): n, m = symbols('n m', integer=True) A = MatrixSymbol('A', n, m) In = Identity(n) Im = Identity(m) assert A * Im == A assert In * A == A assert Transpose(In) == In assert Inverse(In) == In
def pdf(self, x): n, scale_matrix = self.n, self.scale_matrix p = scale_matrix.shape[0] if isinstance(x, list): x = ImmutableMatrix(x) if not isinstance(x, (MatrixBase, MatrixSymbol)): raise ValueError("%s should be an isinstance of Matrix " "or MatrixSymbol" % str(x)) sigma_inv_x = - Inverse(scale_matrix)*x / S(2) term1 = exp(Trace(sigma_inv_x))/((2**(p*n/S(2))) * multigamma(n/S(2), p)) term2 = (Determinant(scale_matrix))**(-n/S(2)) term3 = (Determinant(x))**(S(n - p - 1)/2) return term1 * term2 * term3
def pdf(self, x): alpha , beta , scale_matrix = self.alpha, self.beta, self.scale_matrix p = scale_matrix.shape[0] if isinstance(x, list): x = ImmutableMatrix(x) if not isinstance(x, (MatrixBase, MatrixSymbol)): raise ValueError("%s should be an isinstance of Matrix " "or MatrixSymbol" % str(x)) sigma_inv_x = - Inverse(scale_matrix)*x / beta term1 = exp(Trace(sigma_inv_x))/((beta**(p*alpha)) * multigamma(alpha, p)) term2 = (Determinant(scale_matrix))**(-alpha) term3 = (Determinant(x))**(alpha - S(p + 1)/2) return term1 * term2 * term3
def test_MatPow(): A = MatrixSymbol('A', n, n) AA = MatPow(A, 2) assert AA.exp == 2 assert AA.base == A assert (A**n).exp == n assert A**0 == Identity(n) assert A**1 == A assert A**2 == AA assert A**-1 == Inverse(A) assert A**S.Half == sqrt(A) raises(ShapeError, lambda: MatrixSymbol('B', 3, 2)**2)
def test_MatPow(): A = MatrixSymbol('A', n, n) AA = MatPow(A, 2) assert AA.exp == 2 assert AA.base == A assert (A**n).exp == n assert A**0 == Identity(n) assert A**1 == A assert A**2 == AA assert A**-1 == Inverse(A) assert (A**-1)**-1 == A assert (A**2)**3 == A**6 assert A**S.Half == sqrt(A) assert A**Rational(1, 3) == cbrt(A) raises(NonSquareMatrixError, lambda: MatrixSymbol('B', 3, 2)**2)
def test_xxinv(): assert xxinv(MatMul(D, Inverse(D), D, evaluate=False)) == \ MatMul(Identity(n), D, evaluate=False)
# importing sympy functions import sympy from sympy.matrices import Matrix, Inverse x1, x2 = sympy.symbols('x1, x2') XX1 = Matrix([0, 0]) # Sarting point at the origin XX1= [0,0] FUNC = (x1 + 1)**2 + (x2 + 3)**2 + 4 # Function F_PRIM = Matrix([[sympy.diff(FUNC, x1)], [sympy.diff(FUNC, x2)] ]) # Derivating FUNC with respect to x1 and than x2 H = Matrix( [[sympy.diff(F_PRIM[0], x1), sympy.diff(F_PRIM[1], x1)], [sympy.diff(F_PRIM[0], x2), sympy.diff(F_PRIM[1], x2)]] ) # Derivating F_PRIM with respect to x1 and than x2, becuase of quadratic funstion Hessian is obtained #################### NEWTON'S METHOD #################### XX2 = XX1 - Inverse(H) * F_PRIM.subs({ x1: XX1[0], x2: XX1[0] }) # XX2 = [-1, -3] print( f"Function is quadratic therefore converges in one step. Hessian = {H} is positive therefore X2 = {XX2} is function's minimum" ) ''' #Output: Function is quadratic therefore converges in one step. Hessian = [2, 0, 0, 2] is positive therefore X2 = [-1, -3] is function's minimum. '''
def test_combine_powers(): assert combine_powers(MatMul(D, Inverse(D), D, evaluate=False)) == \ MatMul(Identity(n), D, evaluate=False)
#################### NEWTON'S METHOD #################### F_PRIM = Matrix([0, 0]) # Setting up empty matrix for X_PRIM F_PRIM[0] = FUNC.diff( X[0]) # deriving FUNC with respect to x and y separatelly F_PRIM[1] = FUNC.diff(X[1]) # F_PRIM = [[1.0*x], [1000.0*y]] = H * X F_BIS = Matrix([[0, 0], [0, 0]]) # Setting up empty matrix for X_BIS F_BIS[0] = F_PRIM[0].diff( X[0]) # deriving F_PRIM with respect to x and y separatelly F_BIS[1] = F_PRIM[1].diff(X[0]) F_BIS[2] = F_PRIM[0].diff(X[1]) F_BIS[3] = F_PRIM[1].diff(X[1]) # F_BIS = [[1,0],[0,1000]] = H X2 = X - Inverse(F_BIS) * F_PRIM # X2 = [0, 0], cnvergence in one step print("Newton's Method") print(f" Newton's Method converges in one step, X2 = {list(X2)}\n") #################### GRADIENT DESCENT #################### X2_gd = X1 - F_PRIM.subs({X[0]: X1[0], X[1]: X1[1]}) X3_gd = X2_gd - F_PRIM.subs({X[0]: X2_gd[0], X[1]: X2_gd[1]}) print("Gradient Descent Method") print(f" After first step of Gradient Descent Method X2 = {list(X2_gd)}") print(f" After second step of Gradient Descent Method X3 = {list(X3_gd)}") print(" Gradient Descent Method Diverges.\n") #################### CONJUGATE DESCENT ####################