| from visma.functions.constant import Constant | |
| from visma.functions.operator import Multiply | |
| from visma.functions.operator import Minus | |
| from visma.functions.operator import Plus | |
| from visma.functions.constant import Zero | |
| from visma.functions.structure import Expression | |
| import numpy as np | |
| from visma.functions.operator import Binary | |
| class Matrix(object): | |
| """Class for matrix type | |
| The elements in the matrix are function tokens. | |
| Example: | |
| [ 1 , 2xy^2 ; | |
| 4xy , x+y ] | |
| is tokenized to | |
| [[ [Constant] , [Variable] ], | |
| [ [Variable] , [Variable, Binary, Variable]]] | |
| and stored in matrix.value. | |
| """ | |
| def __init__(self, value=None, coefficient=None, power=None, dim=None, scope=None): | |
| self.scope = None | |
| if value is not None: | |
| self.value = value | |
| else: | |
| self.value = [] | |
| if coefficient is not None: | |
| self.coefficient = coefficient | |
| else: | |
| self.coefficient = 1 | |
| if power is not None: | |
| self.power = power | |
| else: | |
| self.power = 1 | |
| if dim is not None: | |
| self.dim = dim | |
| else: | |
| self.dim = [0, 0] | |
| def convertMatrixToString(self, Latex=False): | |
| from visma.io.parser import tokensToString | |
| MatrixString = '' | |
| self.dim[0] = len(self.value) | |
| self.dim[1] = len(self.value[0]) | |
| for i in range(self.dim[0]): | |
| for j in range(self.dim[1]): | |
| if not Latex: | |
| MatrixString += tokensToString(self.value[i][j]) + '\t' | |
| else: | |
| MatrixString += tokensToString(self.value[i][j]) + ' ' | |
| MatrixString += '\n' | |
| return MatrixString | |
| def __add__(self, other): | |
| """Adds two matrices | |
| Arguments: | |
| self {visma.matrix.structure.Matrix} -- matrix token | |
| other {visma.matrix.structure.Matrix} -- matrix token | |
| Returns: | |
| matSum {visma.matrix.structure.Matrix} -- sum matrix token | |
| Note: | |
| Make dimCheck before calling addMatrix | |
| """ | |
| matSum = Matrix() | |
| matSum.empty(self.dim) | |
| for i in range(self.dim[0]): | |
| for j in range(self.dim[1]): | |
| matSum.value[i][j].extend(self.value[i][j]) | |
| matSum.value[i][j].append(Binary('+')) | |
| matSum.value[i][j].extend(other.value[i][j]) | |
| from visma.matrix.operations import simplifyMatrix | |
| matSum = simplifyMatrix(matSum) | |
| return matSum | |
| def __sub__(self, other): | |
| """Subtracts two matrices | |
| Arguments: | |
| self {visma.matrix.structure.Matrix} -- matrix token | |
| other {visma.matrix.structure.Matrix} -- matrix token | |
| Returns: | |
| matSub {visma.matrix.structure.Matrix} -- subtracted matrix token | |
| Note: | |
| Make dimCheck before calling subMatrix | |
| """ | |
| matSub = Matrix() | |
| matSub.empty(self.dim) | |
| for i in range(self.dim[0]): | |
| for j in range(self.dim[1]): | |
| matSub.value[i][j].extend(self.value[i][j]) | |
| matSub.value[i][j].append(Binary('-')) | |
| matSub.value[i][j].extend(other.value[i][j]) | |
| from visma.matrix.operations import simplifyMatrix | |
| matSub = simplifyMatrix(matSub) | |
| return matSub | |
| def __mul__(self, other): | |
| """Multiplies two matrices | |
| Arguments: | |
| self {visma.matrix.structure.Matrix} -- matrix token | |
| other {visma.matrix.structure.Matrix} -- matrix token | |
| Returns: | |
| matPro {visma.matrix.structure.Matrix} -- product matrix token | |
| Note: | |
| Make mulitplyCheck before calling multiplyMatrix | |
| Not commutative | |
| """ | |
| matPro = Matrix() | |
| matPro.empty([self.dim[0], other.dim[1]]) | |
| for i in range(self.dim[0]): | |
| for j in range(other.dim[1]): | |
| for k in range(self.dim[1]): | |
| if matPro.value[i][j] != []: | |
| matPro.value[i][j].append(Binary('+')) | |
| if len(self.value[i][k]) != 1: | |
| matPro.value[i][j].append(Expression(self.value[i][k])) | |
| else: | |
| matPro.value[i][j].extend(self.value[i][k]) | |
| matPro.value[i][j].append(Binary('*')) | |
| if len(other.value[k][j]) != 1: | |
| matPro.value[i][j].append(Expression(other.value[k][j])) | |
| else: | |
| matPro.value[i][j].extend(other.value[k][j]) | |
| from visma.matrix.operations import simplifyMatrix | |
| matPro = simplifyMatrix(matPro) | |
| return matPro | |
| def __str__(self): | |
| represent = "[" | |
| for i in range(self.dim[0]): | |
| for j in range(self.dim[1]): | |
| for tok in self.value[i][j]: | |
| represent += tok.__str__() | |
| represent += "," | |
| represent = represent[:-1] + ";" | |
| represent = represent[:-1] + "]" | |
| return represent | |
| def empty(self, dim=None): | |
| """Empties the matrix into a matrix of dimension dim | |
| Keyword Arguments: | |
| dim {list} -- dimension of matrix (default: {None}) | |
| """ | |
| if dim is not None: | |
| self.dim = dim | |
| self.value = [[[] for _ in range(self.dim[1])] for _ in range(self.dim[0])] | |
| def prop(self, scope=None, value=None, coeff=None, power=None, operand=None, operator=None): | |
| if scope is not None: | |
| self.scope = scope | |
| if value is not None: | |
| self.value = value | |
| if coeff is not None: | |
| self.coefficient = coeff | |
| if power is not None: | |
| self.power = power | |
| def isSquare(self): | |
| """Checks if matrix is square | |
| Returns: | |
| bool -- if square matrix or not | |
| """ | |
| if self.dim[0] == self.dim[1]: | |
| self.__class__ = SquareMat | |
| return True | |
| else: | |
| return False | |
| def isIdentity(self): | |
| """Checks if matrix is identity | |
| Returns: | |
| bool -- if identity matrix or not | |
| """ | |
| if self.isDiagonal(): | |
| for i in range(0, self.dim[0]): | |
| if self.value[i][i][0].value != 1: | |
| return False | |
| self.__class__ = IdenMat | |
| return True | |
| else: | |
| return False | |
| def isDiagonal(self): | |
| """Checks if matrix is diagonal | |
| Returns: | |
| bool -- if diagonal matrix or not | |
| """ | |
| if self.isSquare(): | |
| for i in range(0, self.dim[0]): | |
| for j in range(0, self.dim[1]): | |
| if i != j and (self.value[i][j][0].value != 0 or len(self.value[i][j]) > 1): | |
| return False | |
| self.__class__ = DiagMat | |
| return True | |
| else: | |
| return False | |
| def dimension(self): | |
| """Gets the dimension of the matrix | |
| dim[0] -- number of rows | |
| dim[1] -- number of columns | |
| """ | |
| self.dim[0] = len(self.value) | |
| self.dim[1] = len(self.value[0]) | |
| def transposeMat(self): | |
| """Returns Transpose of Matrix | |
| Returns: | |
| matRes {visma.matrix.structure.Matrix} -- result matrix token | |
| """ | |
| matRes = Matrix() | |
| matRes.empty([self.dim[1], self.dim[0]]) | |
| for i in range(self.dim[0]): | |
| for j in range(self.dim[1]): | |
| matRes.value[j][i] = self.value[i][j] | |
| return matRes | |
| class SquareMat(Matrix): | |
| """Class for Square matrix | |
| Square matrix is a matrix with equal dimensions. | |
| Extends: | |
| Matrix | |
| """ | |
| def determinant(self, mat=None): | |
| """Calculates square matrices' determinant | |
| Returns: | |
| list of tokens forming the determinant | |
| """ | |
| from visma.simplify.simplify import simplify | |
| if mat is None: | |
| self.dimension() | |
| mat = np.array(self.value) | |
| if(mat.shape[0] > 2): | |
| ans = [] | |
| for i in range(mat.shape[0]): | |
| mat1 = SquareMat() | |
| mat1.value = np.concatenate((mat[1:, :i], mat[1:, i+1:]), axis=1).tolist() | |
| a, _, _, _, _ = simplify(mat1.determinant()) | |
| if(a[0].value != 0 and a != []): | |
| a, _, _, _, _ = simplify(a + [Multiply()] + mat[0][i].tolist()) | |
| if(i % 2 == 0): | |
| if(ans != []): | |
| ans, _, _, _, _ = simplify(ans + [Plus()] + a) | |
| else: | |
| ans = a | |
| else: | |
| ans, _, _, _, _ = simplify(ans + [Minus()] + a) | |
| elif(mat.shape[0] == 2): | |
| a = Multiply() | |
| b = Minus() | |
| mat = mat.tolist() | |
| a1, _, _, _, _ = simplify(mat[0][0] + [a] + mat[1][1]) | |
| a2, _, _, _, _ = simplify(mat[0][1] + [a] + mat[1][0]) | |
| ans, _, _, _, _ = simplify([a1[0], b, a2[0]]) | |
| if (isinstance(ans[0], Minus) or isinstance(ans[0], Plus)) and ans[0].value not in ['+', '-']: | |
| ans[0] = Constant(ans[0].value) | |
| else: | |
| ans, _, _, _, _ = simplify(mat[0][0]) | |
| if not ans: | |
| ans = Zero() | |
| return ans | |
| def traceMat(self): | |
| """Returns the trace of a square matrix (sum of diagonal elements) | |
| Arguments: | |
| mat {visma.matrix.structure.Matrix} -- matrix token | |
| Returns: | |
| trace {visma.matrix.structure.Matrix} -- string token | |
| """ | |
| from visma.simplify.simplify import simplify | |
| trace = [] | |
| self.dim[0] = len(self.value) | |
| self.dim[1] = len(self.value[0]) | |
| for i in range(self.dim[0]): | |
| trace.extend(self.value[i][i]) | |
| trace.append(Binary('+')) | |
| trace.pop() | |
| trace, _, _, _, _ = simplify(trace) | |
| return trace | |
| def inverse(self): | |
| """Calculates the inverse of the matrix using Gauss-Jordan Elimination | |
| Arguments: | |
| matrix {visma.matrix.structure.Matrix} -- matrix token | |
| Returns: | |
| inv {visma.matrix.structure.Matrix} -- result matrix token | |
| """ | |
| from visma.simplify.simplify import simplify | |
| from visma.io.tokenize import tokenizer | |
| from visma.io.parser import tokensToString | |
| if tokensToString(self.determinant()) == "0": | |
| return -1 | |
| self.dim[0] = len(self.value) | |
| self.dim[1] = len(self.value[0]) | |
| n = self.dim[0] | |
| mat = Matrix() | |
| mat.empty([n, 2*n]) | |
| for i in range(0, n): | |
| for j in range(0, 2*n): | |
| if j < n: | |
| mat.value[i][j] = self.value[i][j] | |
| else: | |
| mat.value[i][j] = [] | |
| for i in range(0, n): | |
| for j in range(n, 2*n): | |
| if j == (i + n): | |
| mat.value[i][j].extend(tokenizer('1')) | |
| else: | |
| mat.value[i][j].extend(tokenizer("0")) | |
| for i in range(n-1, 0, -1): | |
| if mat.value[i-1][0][0].value < mat.value[i][0][0].value: | |
| for j in range(0, 2*n): | |
| temp = mat.value[i][j] | |
| mat.value[i][j] = mat.value[i-1][j] | |
| mat.value[i-1][j] = temp | |
| for i in range(0, n): | |
| for j in range(0, n): | |
| if j != i: | |
| temp = [] | |
| if len(mat.value[j][i]) != 1: | |
| temp.append(Expression(mat.value[j][i])) | |
| else: | |
| temp.extend(mat.value[j][i]) | |
| temp.append(Binary('/')) | |
| if len(mat.value[i][i]) != 1: | |
| temp.append(Expression(mat.value[i][i])) | |
| else: | |
| temp.extend(mat.value[i][i]) | |
| temp, _, _, _, _ = simplify(temp) | |
| for k in range(0, 2*n): | |
| t = [] | |
| if mat.value[i][k][0].value != 0: | |
| if len(mat.value[i][k]) != 1: | |
| t.append(Expression(mat.value[i][k])) | |
| else: | |
| t.extend(mat.value[i][k]) | |
| t.append(Binary('*')) | |
| if len(temp) != 1: | |
| t.append(Expression(temp)) | |
| else: | |
| t.extend(temp) | |
| t, _, _, _, _ = simplify(t) | |
| mat.value[j][k].append(Binary('-')) | |
| if len(t) != 1: | |
| mat.value[j][k].append(Expression(t)) | |
| else: | |
| mat.value[j][k].extend(t) | |
| mat.value[j][k], _, _, _, _ = simplify(mat.value[j][k]) | |
| for i in range(0, n): | |
| temp = [] | |
| temp.extend(mat.value[i][i]) | |
| for j in range(0, 2*n): | |
| if mat.value[i][j][0].value != 0: | |
| mat.value[i][j].append(Binary('/')) | |
| mat.value[i][j].extend(temp) | |
| mat.value[i][j], _, _, _, _ = simplify(mat.value[i][j]) | |
| inv = SquareMat() | |
| inv.empty([n, n]) | |
| for i in range(0, n): | |
| for j in range(n, 2*n): | |
| inv.value[i][j-n] = mat.value[i][j] | |
| return inv | |
| def cofactor(self): | |
| """Calculates cofactors matrix of the Square Matrix | |
| Returns: | |
| An object of type SquareMat | |
| """ | |
| mat1 = SquareMat() | |
| mat1.value = [] | |
| for i in range(self.dim[0]): | |
| if(i % 2 == 0): | |
| coeff = -1 | |
| else: | |
| coeff = 1 | |
| mat1.value.append([]) | |
| for j in range(self.dim[1]): | |
| coeff *= -1 | |
| mat = SquareMat() | |
| temp = np.array(self.value) | |
| mat.value = np.concatenate((np.concatenate((temp[:i, :j], temp[i+1:, :j])), np.concatenate((temp[:i, j+1:], temp[i+1:, j+1:]))), axis=1).tolist() | |
| val = mat.determinant()[0] | |
| val.value *= coeff | |
| mat1.value[i].append([val]) | |
| mat1.dimension() | |
| return mat1 | |
| class DiagMat(SquareMat): | |
| """Class for Diagonal matrix | |
| Diagonal matrix is a square matrix with all elements as 0 except for the diagonal elements. | |
| Extends: | |
| SquareMat | |
| """ | |
| def __init__(self, dim, diagElem): | |
| """ | |
| dim {list} -- dimension of matrix | |
| diagElem {list} -- list of tokens list | |
| """ | |
| super().__init__() | |
| self.dim = dim | |
| for i in range(0, dim[0]): | |
| row = [] | |
| for j in range(0, dim[1]): | |
| if i == j: | |
| row.append(diagElem[i]) | |
| else: | |
| row.append([Constant(0)]) | |
| self.value.append(row) | |
| class IdenMat(DiagMat): | |
| """Class for identity matrix | |
| Identity matrix is a diagonal matrix with all elements as 0 except for the diagonal elements which are 1. | |
| Extends: | |
| DiagMat | |
| """ | |
| def __init__(self, dim): | |
| super().__init__(dim, [[Constant(1)]]*dim[0]) | |
| for i in range(0, dim[0]): | |
| self.value[i][i] = Constant(1) | |