def main(): a = matrix.Matrix(2, 3) print('a =') print(a) b = matrix.Matrix(3, 2) print('b =') print(b) print('a+1 = ') print(a + 1) print('a-2 = ') print(a - 2) print('a+b = ') print(a + b) print('a-b = ') print(a - b) print('a+a = ') print(a + a) print('b-b = ') print(b - b) print('a*2 = ') print(a * 2) print('a*b = ') print(a * b) print('a.transpose = ') print(a.transpose()) print('a*(b.transpose) = ') print(a * (b.transpose())) a = matrix.Matrix(4) print('a =') print(a) print('a.determinate = ', a.determinate())
def test_el_wise_mul(self): mat1 = matrix.Matrix([[2, 3], [8, 1]]) mat2 = matrix.Matrix([[5, 1], [6, 7]]) mat = mat1.el_wise_mul(mat2) res = matrix.Matrix([[10, 3], [48, 7]]) self.assertEqual(res, mat)
def setUp(self): self.elements1 = [ [1,2,3], [4,5,6] ] self.matrix1 = matrix.Matrix(self.elements1) self.elements2 = [ [0,0,0], [4,0,6], [1,0,0] ] self.matrix2 = matrix.Matrix(self.elements2) self.elements3 = [ [4,2,6], [1,11,5], [3,12,9] ] self.matrix3 = matrix.Matrix(self.elements3) self.elements4 = [ [0,2,6], [4,0,0], [1,11,5], [3,12,9] ] self.matrix4 = matrix.Matrix(self.elements4) self.elements5 = [ [0,0,0,0,2,6], [0,4,0,4,0,0], [0,0,0,1,11,5], [0,0,0,3,12,9] ] self.matrix5 = matrix.Matrix(self.elements5)
def getBFGS(cD, params_new, params_k, A_k): s_vector = M.subVek(params_new, params_k) y_vector = M.subVek(cV.gradPhi(params_new, cD), cV.gradPhi(params_k, cD)) # s_Matrix and y_Matix is a column, not a row, therefor copyTrans s_Matrix = M.Matrix([s_vector]).copyTrans() y_Matrix = M.Matrix([y_vector]).copyTrans() dividend = A_k.mult(s_Matrix) dividend = dividend.mult(dividend.copyTrans()) divisor = M.scal(s_vector, A_k.image(s_vector)) quotient = dividend quotient.scale(1.0 / divisor) rankOneMod = M.subMatrix(A_k, quotient) dividend2 = y_Matrix.mult(y_Matrix.copyTrans()) # here could be a division through zero. If this occurence, then I should just translate params_new a liiiitle bit... divisor2 = M.scal(y_vector, s_vector) quotient = dividend2 #print( 'vectors are') #print(y_vector) #print( s_vector) #print( cV.gradPhi(params_new , cD)) quotient.scale(1.0 / divisor2) rankTwoMod = M.addMatrix(rankOneMod, quotient) return rankTwoMod
def testEquals_otherIsEqual_returnsTrue(self): m = matrix.Matrix(1, 2) m[0][1] = 'a' other = matrix.Matrix(0, 0) other.matrix_ = [[0, 'a']] self.assertEqual(m, other)
def testSubtraction_emptyMatrices_returnsEmptyMatrix(self): m1 = matrix.Matrix(0, 0) m2 = matrix.Matrix(0, 0) m3 = m1 - m2 self.assertTrue(m3.empty())
def testAddition_emptyMatrices_returnsEmptyMatrix(self): m1 = matrix.Matrix(0, 0) m2 = matrix.Matrix(0, 0) m3 = m1 + m2 self.assertTrue(m3.empty())
def test_matmul(self): mat1 = matrix.Matrix([[2, 3], [8, 1]]) mat2 = matrix.Matrix([[2], [1]]) res = matrix.Matrix([[7], [17]]) self.assertEqual(res, mat1 @ mat2) self.assertEqual(res, mat1 * mat2)
def scale_op(path, img, points, height, width, x, y): imgTensor = pic_strong(img) m = matrix.Matrix(height, width) m_point = matrix.Matrix(height, width) m.scale(1 / x, 1 / y) m_point.scale(x, y) theta = torch.from_numpy(m.to_theta()) img_torch = imgTensor.type(torch.DoubleTensor) grid = F.affine_grid(theta.unsqueeze(0), img_torch.unsqueeze(0).size(), False) output = F.grid_sample(img_torch.unsqueeze(0), grid) newpoints = m_point.dot_point_68(points) pointTensor = pointToTensor(newpoints[0]) new_img = tensorToImage(output) out_img = new_img.resize((Config.IMAGE_SIZE, Config.IMAGE_SIZE)) # out_img = tfs.functional.resize( # new_img, [Config.IMAGE_SIZE, Config.IMAGE_SIZE], Image.BICUBIC # ) imgTensor = pic_strong(out_img) imgTensor = biaozhunhua(imgTensor) return ( imgTensor.type(torch.DoubleTensor), pointTensor, path[0], new_img, newpoints[1], )
def inverse(self): """ Calculates the inverse of a 1x1 or 2x2 Matrix. """ if not self.is_square(): raise (ValueError, "Non-square Matrix does not have an inverse.") if self.h > 2: raise (NotImplementedError, "inversion not implemented for matrices larger than 2x2.") # TODO - your code here import matrix if self.h == 1: m = matrix.Matrix([[1 / self.g[0][0]]]) return m if self.h == 2: if self.determinant() == 0: raise ZeroDivisionError( "Matrix does not have an inverse if determinant equal to zero" ) else: a = self.g[0][0] b = self.g[0][1] c = self.g[1][0] d = self.g[1][1] temp = 1 / self.determinant() inverse = [[temp * d, -temp * b], [-temp * c, temp * a]] m = matrix.Matrix(inverse) return m
def test_identitymatrixmultiplication(self): identity_matrix = matrix.Matrix(1, 0, 0, 0, 1, 0, 0, 0, 1) second_matrix = matrix.Matrix(2, 3, 1, 5, 3, 12, 54, 32, 12) result_matrix1 = identity_matrix * second_matrix result_matrix2 = second_matrix * identity_matrix self.assertEqual(second_matrix._values, result_matrix1._values) self.assertEqual(second_matrix._values, result_matrix2._values)
def densities(T): ''' This function takes in a temperature T computes all of our number densities returns a Matrix object containing all of the number densities ''' ###(3x3) b = matrix.Matrix((3 , 1) , ([[0] , [0], [1]])) A = matrix.Matrix((3 , 3)) A.elements[0][0] = ((get_B(1 , 2) * J(T , 1 , 2) + get_B(1 , 3) * J(T , 1 , 3))).value A.elements[0][1] = -1 * (get_A(2 , 1) + get_B(2 , 1) * J(T , 2 , 1)).value A.elements[0][2] = -1 * (get_A(3 , 1) + get_B(3 , 1) * J(T , 3 , 1)).value A.elements[1][1] = (get_B(2 , 1) * J(T , 2 , 1) + get_A(2 , 1) + get_B(2 , 3) * J(T , 2 , 3)).value A.elements[1][0] = -1 * (get_B(1 , 2) * J(T , 1 , 2)).value A.elements[1][2] = -1 * (get_B(3 , 2) * J(T , 3 ,2) + get_A(3 , 2)).value ''' A.elements[2][0] = -1 * (get_B(1 , 3) * J(T , 1 , 3)).value A.elements[2][1] = -1 * (get_B(2 , 3) * J(T , 2 , 3)).value A.elements[2][2] = (get_B(3 , 1) * J(T , 3 , 1) + get_A(3 , 1) + get_A(3, 2) + get_B(3 , 2) * J(T , 3 , 2)).value ''' A.elements[2][0] = 1 A.elements[2][1] = 1 A.elements[2][2] = 1 x = matrix.solve_eq(A , b) return x
def test(): I2 = m.Matrix([[1, 0], [0, 1]]) I2_neg = m.Matrix([[-1, 0], [0, -1]]) zero = m.Matrix([[0, 0], [0, 0]]) m1 = m.Matrix([[1, 2, 3], [4, 5, 6]]) m2 = m.Matrix([[7, -2], [-3, -5], [4, 1]]) m1_x_m2 = m.Matrix([[13, -9], [37, -27]]) m2_x_m1 = m.Matrix([[-1, 4, 9], [-23, -31, -39], [8, 13, 18]]) m1_m2_inv = m.Matrix([[1.5, -0.5], [2.0555556, -0.722222222]]) top_ones = m.Matrix([[1, 1], [0, 0]]) left_ones = m.Matrix([[1, 0], [1, 0]]) assert equal(-I2, I2_neg) assert equal(I2 + I2_neg, zero) assert equal(m1 * m2, m1_x_m2) assert equal(m2 * m1, m2_x_m1) assert equal(m1_x_m2.inverse(), m1_m2_inv) assert equal(I2.inverse(), I2) assert equal(top_ones.T(), left_ones) assert equal(left_ones.T(), top_ones) assert equal(top_ones - left_ones.T(), m.zeroes(2, 2)) assert (4 * m.identity(5)).trace() == 20 print("Congratulations! All tests pass. Your Matrix class is working" "as expected.")
def test_zeromatrixmultiplication(self): zero_matrix = matrix.Matrix(*[0] * 9) second_matrix = matrix.Matrix(*range(1, 10)) result_matrix1 = zero_matrix * second_matrix result_matrix2 = second_matrix * zero_matrix self.assertEqual(zero_matrix._values, result_matrix1._values) self.assertEqual(zero_matrix._values, result_matrix2._values)
def __mul__(self, other): """ Defines the behavior of * operator (matrix multiplication) """ # # TODO - your code here # product = [] current_rowA = [] current_rowB = [] Other = m.Matrix(other.g) transB = Other.T() row_results = [] for i in range(len(self.g)): for j in range(len(other.g[0])): result = 0 current_rowA = self.g[i] current_rowB = transB[j] for k in range(len(current_rowB)): result += current_rowA[k] * current_rowB[k] row_results.append(result) product.append(row_results) row_results = [] matrixMul = m.Matrix(product) return matrixMul
def test_multiplicate_fail_dimensions(self): A = matrix.Matrix(2, 2) B = matrix.Matrix(4, 1) with self.assertRaises(matrix.InvalidMatrixDimensions): matrix.Matrix.multiplicate(A, B)
def o3(): M = [ models.Matrix(read_matrix_with_space(f'o3_m{i}')) for i in range(1, 5) ] v = models.Matrix(read_matrix_with_space('o3_v')) b2 = models.Matrix(read_matrix_with_space('o3_b2')) # A - матрица линейного отображения A = models.Matrix([[0] * 4 for _ in range(2)]) for i, m in enumerate(M): p = m * v # умножаем один из базисных векторов M на v b = deepcopy(b2) b.add_column( p.columns[0] ) # добавляем полученный вектор к базису в Q^2 как третий столбец print('b=', b, sep='\n') b.to_step() # методом Гаусса приводим к ступеньчатому виду # Выражаем p через базис в Q^2 (считаем координаты) x2 = b.rows[1][2] x1 = -b.rows[0][1] * x2 + b.rows[0][2] # И записываем координаты в матрицу отображения A.rows[0][i] = x1 A.rows[1][i] = x2 print(f'x1={x1}, x2={x2}') print('\n') # Выводим матрицу отображения print(A) print(A * models.Matrix([[1], [0], [0], [0]]))
def test_is_square(self): print("\n\n####################") print("# test_is_square #") print("####################") print("\nMatrix\n") m1 = matrix.Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) print(m1.g) print("\n") print(m1.is_square()) self.assertTrue(m1.is_square() == True) print("\nMatrix\n") m2 = matrix.Matrix([[1, 2],[3, 4]]) print(m2.g) print("\n") print(m2.is_square()) self.assertTrue(m2.is_square() == True) print("\nMatrix\n") m3 = matrix.Matrix([[1, 2, 3], [4, 5, 6]]) print(m3.g) print("\n") print(m3.is_square()) self.assertTrue(m3.is_square() == False) print("\nMatrix\n") m4 = matrix.Matrix([[1],[3]]) print(m4.g) print("\n") print(m4.is_square()) self.assertTrue(m4.is_square() == False)
def test_substraction(self): first_matrix = matrix.Matrix(12, 34, 21, 5) second_matrix = matrix.Matrix(5, 13, 12, 32) result1 = first_matrix - second_matrix result2 = second_matrix - first_matrix self.assertEqual([(7, 21), (9, -27)], result1._values) self.assertEqual([(-7, -21), (-9, 27)], result2._values)
def test_matrix_multiplication(): a = matrix.Matrix([[-1, 4, -2]]) b = matrix.Matrix([[1], [2], [3]]) c = a * b d = b * a assert isinstance(c, matrix.Matrix), "The product must be a Matrix as well!" assert c.data == [[1]], "The product is not correct!" assert d.data == [[-1, 4, -2], [-2, 8, -4], [-3, 12, -6]], "The product is not correct!"
def init_gradient_matrix(self): self.gradient_matrix = mt.Matrix() self.gradient_matrix.set(self.weight_matrix.num_rows, self.weight_matrix.num_cols) self.gradient_mean_matrix = mt.Matrix() self.gradient_mean_matrix.set(self.weight_matrix.num_rows, self.weight_matrix.num_cols)
def test_assertions_for_creation_with_constructor(): with pytest.raises(AssertionError): matrix.Matrix([[1, 2, 3], [1, 2], [1, 2, 3]]) #Your class is supposed to assert that the Matrix is not ill-shaped! with pytest.raises(AssertionError): matrix.Matrix([[1, 2, 3], [1, 2, 'platypus'], [1, 2, 3]]) #Your class is supposed to assert that it can only be constructed with ints or floats matrix.Matrix([[1, 2, 3], [1, 2, 3], [1, 2, 3]])
def o2(): ls = read_matrix_with_space('o2') # Для суммы matrix = models.Matrix(ls, mod=5) b2 = models.Matrix([[x.numerator for x in matrix.columns[4]]], mod=5) b1 = models.Matrix([[x.numerator for x in matrix.columns[3]]], mod=5) to_step(matrix) print(f'b2={b2}, b1={b1}') print(f'b2 - b1 = {b2-b1}')
def o2_sup(): ls = read_matrix_with_space('o2') an = [models.Matrix([[x] for x in l], mod=5) for l in ls[:3]] bn = [models.Matrix([[x] for x in l], mod=5) for l in ls[3:]] coefs_2 = [(i, j) for i in range(5) for j in range(5)] xs = {bn[0] * b1 + bn[1] * (b1 * 4) + bn[2] * b3 for b1, b3 in coefs_2} print('\n\n'.join(map(str, xs))) print(len(xs)) print(str(bn[0] + bn[1] * 4))
def test_addition(self): first_matrix = matrix.Matrix(*range(1, 10)) second_matrix = matrix.Matrix(*range(1, 19, 2)) result1 = first_matrix + second_matrix result2 = second_matrix + first_matrix self.assertEqual([(2, 5, 8), (11, 14, 17), (20, 23, 26)], result1._values) self.assertEqual([(2, 5, 8), (11, 14, 17), (20, 23, 26)], result2._values)
def test(): m1 = m.Matrix([[1, 2, 3], [4, 5, 6]]) m2 = m.Matrix([[7, -2], [-3, -5], [4, 1]]) m1_x_m2 = m.Matrix([[13, -9], [37, -27]]) assert equal(m1 * m2, m1_x_m2), "Error in your __mul__ function"
def normalEquation(self, inputs= None): #uses matricies to skip the iterative process, more about this method can be looked up if inputs == None: inputs = self.inputs inputMatrix = matrix.Matrix(inputs) outputMatrix = matrix.Matrix([[y] for y in self.outputs]) inverse = (inputMatrix.transpose() * inputMatrix).inverse() weights = inverse * inputMatrix.transpose() * outputMatrix return [weights[x][0] for x in range(weights.rows)]
def test_multiplicate1(self): A = matrix.Matrix(2, 3, [[1, 2, 3], [2, 3, 4]]) B = matrix.Matrix(3, 5, [[2, 1, 1, 2, 1], [1, 2, 1, 6, 1], [3, 4, 2, 1, 2]]) C = matrix.Matrix.multiplicate(A, B) self.assertEqual(C.get_height(), A.get_height()) self.assertEqual(C.get_width(), B.get_width()) self.assertEqual(C.data, [[13, 17, 9, 17, 9], [19, 24, 13, 26, 13]])
def diffGetNextVertex(u, volume, point): B = M.Matrix([[-u[1]], [u[0]]]) A = M.Matrix([[-u[0], -u[1]]]) C = B.mult(A) c = M.scal(point, u) c = 2 * volume / (c**2) C.scale(c) # Matrix.plus oder Matrix.add verwenden? C.add(M.idMatrix(2)) return C
def test_get_transpose(self): mat = matrix.Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) res = matrix.Matrix([[1, 4, 7], [2, 5, 8], [3, 6, 9]]) self.assertEqual(res, mat.get_transpose()) mat = matrix.Matrix([[1, 4, 3], [8, 2, 6], [7, 8, 3], [4, 9, 6], [7, 8, 1]]) res = matrix.Matrix([[1, 8, 7, 4, 7], [4, 2, 8, 9, 8], [3, 6, 3, 6, 1]]) self.assertEqual(res, mat.get_transpose())