def testInv(self): matA = Matrix([[1, 2, 3], [0, 1, 2], [1, 2, 4]]) matAinv = matA.inv() c = matA.prod(matAinv).getRows([1, 2, 3]) self.assertTrue( matA.prod(matAinv).getRows([1, 2, 3]) == [[1, 0, 0], [0, 1, 0], [0, 0, 1]])
def testGetMatrixFromColumnFail(self): with self.assertRaises(Exception): matA = Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 0]]) matA.getMatrixFromColumn(initialX=1, initialY=1, height=-4, width=3)
def Train(self, inputs, targets): # Calc errors self.FeedForward(inputs) targets = Matrix.FromArray(targets) output_errors = Matrix.Subtract(targets, self.outputs) weights_ho_T = Matrix.Transpose(self.weights_ho) hidden_errors = Matrix.Multiply(weights_ho_T, output_errors) # Calc gradients gradient_o = Matrix.StaticMap(self.outputs, dsigmoid) gradient_o.ElementMultiply(output_errors) gradient_o.ElementMultiply(self.lr) hidden_T = Matrix.Transpose(self.hidden) delta_weights_ho = Matrix.Multiply(gradient_o, hidden_T) gradient_h = Matrix.StaticMap(self.hidden, dsigmoid) gradient_h.ElementMultiply(hidden_errors) gradient_h.ElementMultiply(self.lr) input_T = Matrix.Transpose(self.inputs) delta_weights_ih = Matrix.Multiply(gradient_h, input_T) # Adjusting weights and biases # self.weights_ih.Display() self.weights_ih.Add(delta_weights_ih) self.bias_h.Add(gradient_h) # delta_weights_ho.Display() self.weights_ho.Add(delta_weights_ho) self.bias_o.Add(gradient_o)
def test_jacobi_seidel_3x3(): #Example from https://www.maa.org/press/periodicals/loci/joma/iterative-methods-for-solving-iaxi-ibi-gauss-seidel-method # solution x=(1, 2, -1).T A = Matrix([[4, -1, -1], [-2, 6, 1], [-1, 1, 7]]) b = Matrix([[3], [9], [-6]]) solution = solve_jacobi_seidel(A, b) assert solution.is_close(Matrix([[1], [2], [-1]]))
def testSubtraction(self): testMatrix1 = Matrix() testMatrix2 = Matrix() testMatrix3 = testMatrix1 - testMatrix2 for row in range(4): for col in range(4): self.assertTrue(testMatrix3.getValue(row, col) == 0) testMatrix1.setValue(0, 3, 2.5) testMatrix1.setValue(2, 2, 4.2) testMatrix1.setValue(3, 0, -301) testMatrix2.setValue(0, 3, -1) testMatrix2.setValue(0, 0, -2) testMatrix2.setValue(3, 0, 2) testMatrix4 = testMatrix1 - testMatrix2 self.assertTrue(testMatrix4.getValue(0, 3) == 3.5) self.assertTrue(testMatrix4.getValue(2, 2) == 4.2) self.assertTrue(testMatrix4.getValue(3, 0) == -303) self.assertTrue(testMatrix4.getValue(0, 0) == 2.0) self.assertTrue(testMatrix4.getValue(2, 1) == 0)
class MainWindow(Frame): def __init__(self, master, rows, columns): Frame.__init__(self, master) self.matrix = Matrix(master, rows, columns) self.matrix.grid(row=0, column=0) self.game = Game(rows, columns) self.game.set_matrix(self.matrix) self.start_button = Button(master, text="Start") self.start_button.grid(row=1, column=0) self.start_button["command"] = self.game.start_clicked self.quit_button = Button(master, text="Quit") self.quit_button.grid(row=1, column=1) self.quit_button["command"] = self.quit self.master = master master.title("Life") # override the "X" close button self.master.protocol("WM_DELETE_WINDOW", self.quit) def quit(self): print "quitting" self.game.quit_clicked() self.master.quit()
class Network: def __init__(self, inp_length, hid_length, out_length): self.inp_size = inp_length self.hid_size = hid_length self.out_size = out_length self.inputs = Matrix(1, inp_length) self.hidden = Matrix(1, hid_length) self.outputs = Matrix(1, out_length) self.weights_ih = Matrix (inp_length, hid_length) self.weights_ho = Matrix (hid_length, out_length) randomise(self.weights_ih) randomise(self.weights_ho) def feedforward(self): self.hidden = self.inputs.multiply(self.weights_ih) self.hidden = sigmoid(self.hidden) self.outputs = softmax(self.hidden.multiply(self.weights_ho)) def print_network(self): print(self.inputs.matrix) print() print() print(self.weights_ih.matrix) print() print() print(self.hidden.matrix) print() print() print(self.weights_ho.matrix) print() print() print(self.outputs.matrix)
def __init__(self, *domains): self.domainList = list(domains) self.size = sum([len(i.nodes) * i.dofs for i in self.domainList]) self.dofs = self.size self.totalConstraints = sum( [len(i.constraintList) for i in self.domainList]) self.physics = {'gravity': 0} self.stiffnessMatrix = Matrix(0) self.stiffnessMatrixInverse = Matrix(0) self.displacementVector = Vector(0) self.loadVector = Vector(0) self.solver = None self.inverseFlag = True self.couplingList = [] self.couplingListRHS = [] self.dampingList = {} self.ivDisplacementList = {} self.__assembleConstraints__()
def findLU(n, matrixA): # Find the L U for the decomposition L = Matrix(dims=(n, n), fill=0) U = Matrix(dims=(n, n), fill=0) # Fill the value of L for i in range(n): L[i, i] = 1 # Calculate for the lower, upper matrix, i for row index, j for col index for i in range(n): for j in range(n): tmp = matrixA[i, j] for k in range(n): if j != k: tmp = tmp - L[i, k] * U[k, j] # lower matrix if i > j: if U[j, j] != 0: L[i, j] = tmp / U[j, j] else: L[i, j] = tmp # Upper matrix else: if L[j, j] != 0: U[i, j] = tmp / L[j, j] else: U[i, j] = tmp return L, U
def lanczos(A): k = len(A) b = Vector.rand(n=k) q = [Vector.new(n=k) for i in range(2)] q[1] = b / abs(b) b = [0] a = [0] for i in range(1, int(2 * sqrt(k))): z = Vector((A * q[i]).transpose()[0]) a.append(float(Matrix([q[i]]) * z)) z = z - q[i] * a[i] - q[i-1] * b[i-1] for j in q: z -= j * (z * j) for j in q: z -= j * (z * j) b.append(abs(z)) if b[i] == 0: break q.append(z / b[i]) Q = Matrix(q[-k-1:-1]).transpose() T = Q.transpose() * A * Q return (Q, T, )
def open_last_sts(data_path, head): #here data_path should be the Lucile folder mtrx_path = data_path head = head + "_0001.mtrx" my_matrix = Matrix(mtrx_path, head) #here mtrx_path should be the folder with the head file keys = list(my_matrix.IDs.keys()) last_ID = keys[-1] while last_ID: if not last_ID in my_matrix.IDs.keys(): last_ID -= 1 continue if my_matrix.IDs[last_ID]['hasDI']: last_num = my_matrix.IDs[last_ID]['nums'][-1] while last_num: try: V, didv = my_matrix.getDIDV(last_ID, last_num) break except TypeError: last_num -= 1 #plt.ion() #plt.plot(V, didv) #plt.pause(0.1) #plt.show() #plt.pause(3) #plt.close() #plt.ioff() return V, didv break else: last_ID -= 1 return None, None
def main(): m = Matrix(5, 2) b = Matrix(5, 2) print("show matrix :", m, sep='\n') m += 10 print("after adding 10:", m, sep='\n') b = b + 20 m = m + b print("after adding matrix b:", m, sep='\n') m.randomize() print("after randomize :", m, sep='\n') m *= 3 print("after multiply by 3 :", m, sep='\n') d = Matrix(2, 3) g = Matrix(3, 3) g.matrix = [ [3, 5, 8], [2, 6, 6], [7, 9, 4] ] d += 5 h = d * g print("after multiply d :\n{}\nby g :\n{}\nres :\n{}".format(d, g, h)) h = g.transpose() print("after transpose :\n{}".format(h))
def test_jacobi_example_4x4(): A = Matrix([[10, -1, 2, 0], [-1, 11, -1, 3], [2, -1, 10, -1], [0, 3, -1, 8]]) b = Matrix([[6], [25], [-11], [15]]) solution = solve_jacobi(A, b) assert solution == Matrix([[1], [2], [-1], [1]])
def parseFile(self): matrices = [] for i, line in enumerate(self): line = line.rstrip() if i == 0: problemTitle = line elif i == 1: problemSize = line elif i == 2: correctAnswer = line else: if not line.startswith("\t"): #this is a matrix newMatrix = Matrix(line) matrices.append(newMatrix) elif not line.startswith("\t\t"): #this is an object line = line.strip() newObject = Object(line) newMatrix.objects[line] = newObject else: #this is an attribute (key-value pair) line = line.strip() keyValue = line.split(":") newObject.attributes.update({keyValue[0]: keyValue[1]}) problem = Problem(problemTitle, problemSize, correctAnswer, matrices) return problem
def makeGraphFromEdges1(self, edges): """ Constructs a directional graph from edges (a list of tuple). Each tuple contains 2 vertices. For example, P -> Q is written as ('P', 'Q'). @param edges: edges @type edges: list of 2-element tuple @status: Tested method @since: version 0.1 """ if type(edges) != list: raise GraphParameterError('Edges must be a \ list of tuples') from Set import Set from Matrix import Matrix vertices = list(Set([x[0] for x in edges] + [x[1] for x in edges])) adj = Matrix(len(vertices)) adj = adj.m for e in edges: row = vertices.index(e[0]) col = vertices.index(e[1]) # fill values into lower triangular matrix adj[row][col] = adj[row][col] + 1 adj.insert(0, vertices) self.makeGraphFromAdjacency(adj)
def testWrongMatrixSumOrders(self): with self.assertRaises(Exception): matA = Matrix([[1, 1, 1, 1, 1], [2, 2, 2, 5], [3, 3, 3, 5, 3], [3, 3, 3, 5, 3], [5, 5, 5, 5, 5]]) matB = Matrix([[1, 1, 1, 1, 1], [2, 2, 2, 5, 1], [3, 3, 3, 5, 3], [3, 3, 3, 5, 3], [5, 5, 5, 5, 5]]) matA.sum(matB)
def Jacobi(self, iteration=5): """ iterate throught the jacobi method to solve the system """ Id = Identity(len(self.A.matrix)) #exctract the Diagonal from the matrix Diag = [[self.A[i][j] \ if i == j else 0 \ for j in range(len(self.A.matrix))] \ for i in range(len(self.A.matrix))] Diag = Matrix(Diag) inv_diag = Diag.reverse_diag() X_k = Matrix([[0]\ for i in range(len(self.A.matrix)) ]) # Id check # inv_diag check # A check # Y check for i in range(iteration): B = (Id - (inv_diag * self.A)) X_k = (B * X_k) + (inv_diag * self.Y) # x = Bx + (ID - B) A^-1 * Y # B = Id - D^-1A # pour avoir (Id - B) A^-1 * Y # sans le A^-1 # soit x = Bx + D^-1 * Y # (I - D^-1 * A) * X_k + D^-1 * Y #erreur potentielle de calcul, ou systeme insolvable. return (X_k)
def __init__(self, parent=None): super(GLWidget, self).__init__(parent) self.setFocusPolicy(Qt.StrongFocus) self.object = 0 self.xRot = 0 self.yRot = 0 self.zRot = 0 self.translateX = 0.0 self.translateY = 0.0 self.zoom = -15.0 self.ctlPressed = False self.matrix = Matrix(5, 5, 5) self.lastPos = QPoint() self.selectedX = 0 self.selectedY = 0 self.selectedZ = 4 self.trolltechGreen = QColor.fromCmykF(0.40, 0.0, 1.0, 0.0) self.trolltechPurple = QColor.fromCmykF(0.39, 0.39, 0.0, 0.0) self.Black = QColor.fromCmykF(0.0, 0.0, 0.0, 0.0, 0.0) self.selectedColor = self.trolltechGreen
def makeGraphFromEdges2(self, edges): """ Constructs an un-directional graph from edges (a list of tuple). Each tuple contains 2 vertices. An un-directional graph is implemented as a directional graph where each edges runs both directions. @param edges: list of edges @type edges: list of 2-element tuples""" if type(edges) != list: raise GraphParameterError('Edges must be a \ list of tuples') from Set import Set from Matrix import Matrix vertices = list(Set([x[0] for x in edges] + [x[1] for x in edges])) adj = Matrix(len(vertices)) adj = adj.m for e in edges: row = vertices.index(e[0]) col = vertices.index(e[1]) # fill values into lower triangular matrix adj[row][col] = adj[row][col] + 1 # repeat on the upper triangular matrix for undirectional graph adj[col][row] = adj[col][row] + 1 adj.insert(0, vertices) self.makeGraphFromAdjacency(adj)
def quad(self, g, quad): # Enable alpha blending/transparency self.vbuffer.sync() gl.glUseProgram(self.program.id) gl.glEnable(gl.GL_BLEND) gl.glEnable(gl.GL_DEPTH_TEST) gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA) # Bind texture gl.glUniform1i(self.program.tex, 0) gl.glBindTexture(gl.GL_TEXTURE_2D, quad.texture.id) # Set up geometry transforms worldMatrix = Matrix.scale(quad.width, quad.height, 1) worldMatrix = Matrix.translate(quad.x, quad.y, 0) * worldMatrix worldViewProjectionMatrix = g.viewProjectionMatrix * worldMatrix #worldViewProjectionMatrix = g.viewProjectionMatrix gl.glUniformMatrix4fv(self.program.worldViewProjectionMatrix, 1, 0, worldViewProjectionMatrix.data) # Draw geometry gl.glBindVertexArray(self.vao) gl.glDrawArrays(gl.GL_TRIANGLE_STRIP, 0, 4) gl.glBindVertexArray(0)
def get_matrix(self): rows, cols = self.get_size() matrix = Matrix(rows, cols) for child in self.get_children(): box = self.find_box_child(child) matrix.set(child, box.left, box.top, box.right, box.bottom) return matrix
def test_slice(self): A = Matrix([1, 2, 3, 4], [5, 6, 7, 9], [1, 2, 3, 4]) s = A.slice(0, 2) self.assertEqual(s, Matrix( [3, 4], [7, 9], [3, 4]))
def spline_cubic(data, value, is_natural=True, first_der=0, last_der=0): """ Using cubic plaine to calculate an interpolation of a point according to data points :param data: the data points pairs of x,y :param value: The value to calculate it's interpolation :param is_natural: a boolean if the cubic splaine is natural or not :param first_der: in case of none natural cubic splaine it's the first derived of the function :param last_der: in case of none natural cubic splaine it's the last derived of the function :return: A vector with the results of each function corresponding to each pair of points """ if len(data) < 2: return 'failed' def x(i): return data[i][0] def y(i): return data[i][1] def h(i): return x(i + 1) - x(i) n = len(data) A = np.identity(n) b = list(((y(i + 1) - y(i)) / (h(i)) - (y(i) - y(i - 1)) / (h(i - 1)) for i in range(1, n - 1))) if not is_natural: b.insert(0, ((y(1) - y(0)) / h(0)) - first_der) b.append((last_der - ((y(n - 1) - y(n - 2)) / h(n - 2)))) A[0][0] = h(0) / 3 A[0][1] = h(0) / 6 A[n - 1][n - 2] = h(n - 2) / 6 A[n - 1][n - 1] = h(n - 2) / 3 else: # handles natural splaine. b.insert(0, 0) b.append(0) for i in range(1, n - 1): A[i][i - 1] = h(i - 1) / 6 A[i][i] = ((h(i - 1) + h(i)) / 3) A[i][i + 1] = h(i) / 6 Mat = Matrix(A, b) print("The matrix and the solution vector of the cubic spline:\n", A, b) print("\ncalculating the matrix results with gauss seidel.....") Mi = Mat.gauss_seidel(list(0.0 for _ in range(len(b)))) print("Mi - vector: ", Mi) print("\n") results = [0.0 for _ in range(n - 1)] for i in range(n - 1): print("S{0}(x)= ({1}(x-{2})/{3})-({4}(x-{5})/{3})+" "({6}/6)[((x-{2})^3)/{3}) -{3}(x-{2}))] - " "({7}/6)[((x-{5})^3)/{3}) - {3}(x-{5})]\n".format( i, y(i + 1), x(i), h(i), y(i), x(i + 1), Mi[i + 1], Mi[i])) results[i] = (y(i + 1) * (value - x(i)) / h(i)) - (y(i) * (value - x(i + 1)) / h(i)) + \ (Mi[i + 1] / 6) * ((((value - x(i)) ** 3) / h(i)) - h(i) * (value - x(i))) - \ (Mi[i] / 6) * ((((value - x(i + 1)) ** 3) / h(i)) - h(i) * (value - x(i + 1))) print(results) return results
def test_single(): """ Test single element :return: """ a = Matrix([[1]]) x = solve_gauss(a, Matrix()) assert x == []
def creating(q): while True: size = randint(2, 7) a = Matrix(a=size, b=size, random=True) b = Matrix(a=size, b=size, random=True) print(f"Сгенерированы матрицы:\n{a}\n{b}\n--------------------------") q.put([a, b]) sleep(8) # Эта функция выполняется намного быстрее умножения, поэтому ждём
def __init__(self, nRows, nCols): self.rows = nRows self.cols = nCols self.matrix = Matrix(nRows, nCols) # fill the sheet with zero numbercells for row in range(self.rows): for col in range(self.cols): self.updateValue(row, col, "0")
def feedforword(self, inputs): if len(inputs) == self.sizes[0]: output = Matrix(1, len(inputs), [inputs]).transpose() for i in range(len(self.sizes) - 1): output = self.weights[i] * output + self.biases[i] output = output.apply(sigmoid) return output raise Exception("Invalid input length")
def Matrix_Rotation(n, theta): I = Matrix(n, n) if (n == 2): return Matrix([ [cos(theta), -sin(theta)], [sin(theta), cos(theta)], ]) return I
def testGetMatrixFromColumnException(self): with self.assertRaises(Exception): matA = Matrix([[1, 1, 1, 1, 1], [2, 2, 2, 2, 2], [3, 3, 3, 3, 3], [4, 4, 4, 4, 4], [5, 5, 5, 5, 5]]) matA.getMatrixFromColumn(initialX=2, initialY=2, height=3, width=10)
def main(): matrix = Matrix(2, 4) matrix.list_fill([[9, 9], [1, 10], [6, 5], [6, 2]]) collection = Collection() collection.matrix_as_collection(matrix) print(collection) collected = Collection.compute_basis(collection) print(collected)
def calculate_normal(self, triangle): vertex_0, vertex_1, vertex_2 = triangle edge_1 = Matrix.subtract(vertex_1, vertex_0) edge_2 = Matrix.subtract(vertex_2, vertex_0) normal = Matrix.cross_product(edge_1, edge_2) normal = Matrix.normalize(normal) return normal
def __init__(self,rows,cols): self.rows = rows self.cols = cols self.matrix = Matrix(rows, cols) # fill the sheet with zero numbercells for row in range(self.rows): for col in range(self.cols): self.modifyValue(row, col, "0")
def __init__(self): self.rows = 3 self.cols = 5 self.matrix = Matrix(3, 5) # fill the sheet with zero numbercells for row in range(self.rows): for col in range(self.cols): self.updateValue(row, col, "0")
def test_transpose_square(): """ Check transpose of square 3x3 matrix :return: """ A = Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) A_transpose = Matrix([[1, 4, 7], [2, 5, 8], [3, 6, 9]]) assert A.T == A_transpose
def setCenterPosition(self, center: Vector) -> None: if self._mesh_data: m = Matrix() m.setByTranslation(-center) self._mesh_data = self._mesh_data.getTransformed(m).set( center_position=center) for child in self._children: child.setCenterPosition(center)
def set_covariance(self): for i in self.matrices: a = i.subtract(self.mean) a_transpose = Matrix(a.get_data()) a_transpose.transpose() b = a_transpose.multiply(a) self.covariance = self.covariance.add(b) self.covariance.scaler(1 / len(self.matrices))
def __init__(self): self.data = [] self.matrices = [] self.mean = Matrix([[0, 0]]) self.covariance = Matrix([[0, 0], [0, 0]]) self.setup() self.set_mean() self.set_covariance() print(len(self.matrices))
def reset(self): '''resets the whole sugarscape''' self.agents = [] self.gov.tax_rate = self.tax_rate Matrix.__init__(self,51,51) self.agents = [] self.populate_sugarscape() self.timestamp = 0 return True
def test_setrowcol(self): A = Matrix([1, 2, 3, 4], [5, 6, 7, 8]) A.set_row(0, [4, 3, 2, 1]) self.assertEqual(A, Matrix([4, 3, 2, 1], [5, 6, 7, 8])) A.set_col(2, [9, 8]) self.assertEqual(A, Matrix([4, 3, 9, 1], [5, 6, 8, 8]))
def cg(A,b): #guess x all 0s x = Matrix(i=A.columns,j=1) #set r and p r = b.subtract(A.multiply(x)) p = b.subtract(A.multiply(x)) r_norm_inf = 0 for i in range(1,r.rows+1): v = r.get(i,1) if (v > r_norm_inf): r_norm_inf = v r_norm_2 = 0 r_norm_2 = math.sqrt(r.transpose().multiply(r).get(1,1)) iteration = 1 while( r_norm_2 > LIMITERROR): p_t = p.transpose() alpha = p_t.multiply(r).get(1,1) / p_t.multiply(A.multiply(p)).get(1,1) # a_p for alpha*p a_p = copy.deepcopy(p) for i in range(1,a_p.rows+1): for j in range(1,a_p.columns+1): a_p.set(i,j,a_p.get(i,j)*alpha) x = x.add(a_p) r = b.subtract(A.multiply(x)) beta = -1 * (p_t.multiply(A.multiply(r)).get(1,1) / p_t.multiply(A.multiply(p)).get(1,1)) # b_p for beta*p b_p = p #no need to copy (as we update cell by cell of p to b_p and we don't need it later) for i in range(1,b_p.rows+1): for j in range(1,b_p.columns+1): b_p.set(i,j,p.get(i,j)*beta) p = r.add(b_p) # compute r norms and f.write r_norm_inf = 0 for i in range(1,r.rows+1): v = r.get(i,1) if (v > r_norm_inf): r_norm_inf = v r_norm_2 = math.sqrt(r.transpose().multiply(r).get(1,1)) f.write(str(iteration)+","+str(r_norm_inf)+","+str(r_norm_2)+"\n") iteration+=1 f.write(",,,"+str(iteration-1)) return x
def test_construction(self): m1 = Matrix(2, 3) self.assertEqual(m1.size(), [2, 3]) # Verify the matrix is filled with 0s self.assertEqual(m1.data, [[0 for i in range(3)] for j in range(2)]) m2 = Matrix([0, 1, 2], [3, 4, 5], [6, 7, 8]) self.assertEqual(m2.size(), [3, 3]) # Verify the matrix has values 0-8 self.assertEqual(m2.data, [[(j * 3 + i) for i in range(3)] for j in range(3)])
def test_multplication(self): # Test dot products # Row vectors v1 = Matrix([1, 2]) v2 = Matrix([5], [6]) self.assertEqual(v1 * v2, 17) self.assertEqual(v1 * [5, 6], 17) # Column vectors v1 = Matrix([10], [7]) v2 = Matrix([5 ], [8]) self.assertEqual(v1 * v2.transposed(), Matrix([50, 80], [35, 56])) # Test matrix scalar multiplication m = Matrix([1, 4, 5, 6], [3, 8, 9, 2], [9, 12, 4, 13]) self.assertEqual((m * 4).data, [[(m[j][i] * 4) for i in range(m.cols)] for j in range(m.rows)]) # Test matrix multiplication m1 = Matrix([2, 3], [4, 5], [6, 7]) m2 = Matrix([1, 2, 3], [4, 5, 6]) r = Matrix([14, 19, 24], [24, 33, 42], [34, 47, 60]) self.assertEqual(m1 * m2, r) self.assertEqual(m1 * [[1, 2, 3], [4, 5, 6]], r) # Test swapping rows of a matrix with a permutation matrix m = Matrix([11, 9 , 24, 2], [1 , 5 , 2 , 6], [3 , 17, 18, 1], [2 , 5 , 7 , 1]) p = Matrix([1, 0, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1], [0, 1, 0, 0]) self.assertEqual(p * m, Matrix( [11, 9 , 24, 2], [3 , 17, 18, 1], [2 , 5 , 7 , 1], [1 , 5 , 2 , 6])) # Test swapping of cols of a matrix with the same permutation matrix self.assertEqual(m * p, Matrix( [11, 2, 9 , 24 ], [1 , 6, 5 , 2 ], [3 , 1, 17, 18 ], [2 , 1, 5 , 7 ])) # Multiplication of matrix with a matrix of 3 columns and list of 3 components self.assertEqual( Matrix([24 , 1, 8 ], [6 , 0, 2 ], [-12, 1, -3]) * Matrix([1], [9], [-2]), Matrix([17], [2], [3])) self.assertEqual( Matrix([24 , 1, 8 ], [6 , 0, 2 ], [-12, 1, -3]) * [1, 9, -2], Matrix([17], [2], [3]))
def add_padding(self, padding, matrix): #validate inputs if (not type(padding) is int or padding <= 0 or not type(matrix) is Matrix): raise LedError("Invalid inputs. Padding must be a positive, non-zero integer") output = Matrix(matrix.m, padding) output = output.concatenate(matrix) output = output.concatenate(matrix.m, padding) return output
def convert_message_led(self): checker = False output = Matrix(1,1) for char in self.message: temp = self.char_map[char] if (temp): if (checker): output = output.concatenate(temp) else: output.copy(temp) checker = True return output
def __init__(self, num_agents = 500, max_sugar=5, sugar_growth_rate=.5, agent_vision=3, agent_metabolism=4, tax_rate=.5): ''' The sugarscape is a matrix of Location objects.''' Matrix.__init__(self, 51, 51) self.max_sugar = max_sugar self.sugar_growth_rate = sugar_growth_rate self.agent_vision = agent_vision self.agent_metabolism = agent_metabolism self.tax_rate = tax_rate self.agents = [] self.total_wealth = 0 self.num_agents = num_agents self.timestamp = 0 self.gov = Government(tax_rate=self.tax_rate, sugarscape=self) self.populate_sugarscape()
def testCreation(self): testMatrix = Matrix() for row in range(4): for col in range(4): self.assertTrue(testMatrix.getValue(row, col) == 0) testMatrix.setValue(0, 0, 1.893) testMatrix.setValue(2, 1, -200.1) testMatrix.setValue(3, 2, 4) self.assertTrue(testMatrix.getValue(0, 0) == 1.893) self.assertTrue(testMatrix.getValue(2, 1) == -200.1) self.assertTrue(testMatrix.getValue(3, 2) == 4)
def QRalg(m): from copy import deepcopy as copy from math import cos, sin, atan, pi def get_rotate_matrix(n, i, j, angle): m = Matrix.new(n, n) for k in range(n): if k not in [i, j]: m[k][k] = 1 s = sin(angle) c = cos(angle) m[i][j] = -s m[j][i] = s m[i][i] = c m[j][j] = c return m m = copy(m) n = len(m) u = Matrix.new(n, n) for i in range(n): u[i][i] = 1 iter_n = 1 f = True while f and iter_n < 1000: q = 0 qi, qj = 0, 0 for i in range(n): for j in range(n): if i != j and abs(m[i][j]) > q: q, qi, qj = abs(m[i][j]), i, j angle = pi / 4 if abs(m[qi][qi] - m[qj][qj]) > 0.000001: angle = atan(2 * m[qi][qj] / (m[qi][qi] - m[qj][qj])) / 2 rm = get_rotate_matrix(n, qi, qj, angle) rmt = rm.transpose() nm = rmt * m * rm u = u * rm #l.write('{}: '.format(iter_n)) #l.write(nm) s = 0 for i in range(n): for j in range(n): if i != j: s += nm[i][j] ** 2 f = abs(s) > (0.1 ** 5) m = copy(nm) iter_n += 1 values = Vector([m[i][i] for i in range(n)]) vectors = u.transpose() for i in range(len(vectors)): if abs(vectors[i][-1]) > 0.001: vectors[i] *= 1/vectors[i][-1] return (values, vectors, )
def getEquilibriumMatrix(self): self.matrix = [] for node in self.nodes: self.addXEquation(node) self.addYEquation(node) self.matrix = Matrix(self.matrix) return self.matrix
def compute_led_screen (text, padding): #validate inputs if (not type(text) is str or not type(padding) is int or padding <= 0): raise LedError("Only message strings are supported and padding must be a positive, non-zero integer") #pad pixels left output = Matrix(self.board_height, padding) for char in text: addition = self.char_map[char] output = output.concatenate(addition) #pad pixels right output = output.concatenate(Matrix(self.board_height, padding)) return output
def test_swap(self): m = Matrix([1, 2, 3], [4, 5, 6]) m.swap(0, 1) self.assertEqual(m, Matrix([4, 5, 6], [1, 2, 3])) m = Matrix([1, 2], [3, 4], [5, 6], [7, 8], [9, 10]) m.swap(0, 4) m.swap(1, 3) # Middle row shouldn't move m.swap(2, 2) self.assertEqual(m, Matrix([9, 10], [7, 8], [5, 6], [3, 4], [1, 2]))
def init(self): # Initialize the renderer, set up the Window. glfw.init() glfw.window_hint(glfw.CONTEXT_VERSION_MAJOR, 3) glfw.window_hint(glfw.CONTEXT_VERSION_MINOR, 3) glfw.window_hint(glfw.OPENGL_FORWARD_COMPAT, gl.GL_TRUE) glfw.window_hint(glfw.OPENGL_PROFILE, glfw.OPENGL_CORE_PROFILE) glfw.window_hint(glfw.DECORATED, gl.GL_TRUE) glfw.window_hint(glfw.DECORATED, gl.GL_TRUE) glfw.window_hint(glfw.RESIZABLE, gl.GL_FALSE) width = Config.windowWidth height = Config.windowHeight self.aspect = width/height # Initialize the window self.window = glfw.create_window(width, height, "Magic", None, None) glfw.make_context_current(self.window) self.renderer = Renderer() self.quad = [] self.text = [] # Set up camera self.viewMatrix = Matrix.identity() # Set up view transform. View is always 16 units high, and 16 * aspect units # wide. The extra space outside of a 4:3 ratio is unused, to make sure that # all the cards always fit in a 4:3 aspect monitor. vHeight = 2 vWidth = vHeight * self.aspect self.projectionMatrix = Matrix.ortho(-vWidth/2, vWidth/2, vHeight/2, -vHeight/2, -1, 1) self.viewProjectionMatrix = self.projectionMatrix * self.viewMatrix # Set up viewport fbWidth, fbHeight = glfw.get_framebuffer_size(self.window) gl.glViewport(0, 0, fbWidth, fbHeight) q = Quad(Texture('Images/Sen Triplets.jpg')) # Natural resolution of cards is 480x680 cardAspect = 480/680 q.x = 0 q.y = 0 q.height = .8 q.width = q.height * cardAspect self.quad.append(q)
def eval(self, destinations): """Produce a travel time matrix from the origins to all destinations""" if isinstance(destinations, str): destinations = PointSet(destinations) mat = Matrix(len(self._origins), len(destinations)) graphId = self._graph.getId() if not destinations._samples.has_key(graphId): destinations.link(self._graph) destSamples = destinations._samples[graphId] for i in xrange(len(self._origins)): mat.setRow(i, destSamples.eval(self.results[i])) return mat
def __init__(self, group_id, matrix_size): # Determine the sizes of all the matrices (these are the same) and # use it to assign addresses to each of them. matrices_size = Matrix.calculate_size(4, matrix_size, matrix_size) address_A, address_B, address_C = Address.assign_object_sizes(group_id, [matrices_size, matrices_size, matrices_size]) # Construct actual matrices on assigned addresses. self.matrix_A = Matrix(address_A, 4, matrix_size, matrix_size) self.matrix_B = Matrix(address_B, 4, matrix_size, matrix_size) self.matrix_C = Matrix(address_C, 4, matrix_size, matrix_size)
def test_rowcol(self): m = Matrix([1, 2, 3], [4, 5, 6]) self.assertEqual(m.row(0), [1, 2, 3]) self.assertEqual(m.row(1), [4, 5, 6]) # row() should only return a copy m.row(1)[1] = 0 self.assertEqual(m[1][1], 5) self.assertEqual(m.col(0), [1, 4]) self.assertEqual(m.col(1), [2, 5]) self.assertEqual(m.col(2), [3, 6]) # col() should only return copy m.col(1)[1] = 0 self.assertEqual(m[1][1], 5)
def test_subtraction(self): m1 = Matrix(4, 4) m2 = Matrix([0 , 1 , 2 , 3 ], [4 , 5 , 6 , 7 ], [8 , 9 , 10, 11], [12, 13, 14, 15]) res = m1 - m2 m1 -= m2 self.assertEqual(res.size(), [4, 4]) self.assertEqual(res.data, [[-(j * 4 + i) for i in range(4)] for j in range(4)]) self.assertEqual(m1.data, [[-(j * 4 + i) for i in range(4)] for j in range(4)]) m3 = Matrix([4, 5, 2, 9], [2, 1, 2, 1]) m4 = Matrix([2 , 1, 9, 11], [12, 4, 2, 12]) r,c = m3.size() # Data should be componenet wise addition self.assertEqual((m3 - m4).data, [[(m3[j][i] - m4[j][i]) for i in range(c)] for j in range(r)]) m4 += 3
def set_distances(self): for i in range(1, 15): temp = [] for j in range(1, 15): x1 = self.points[i].get_data()[0][0] y1 = self.points[i].get_data()[0][1] x2 = self.points[j].get_data()[0][0] y2 = self.points[j].get_data()[0][1] temp.append(math.hypot(x2 - x1, y2 - y1)) self.temp_dist.append(temp) self.distance = Matrix(self.temp_dist)
def get_rotate_matrix(n, i, j, angle): m = Matrix.new(n, n) for k in range(n): if k not in [i, j]: m[k][k] = 1 s = sin(angle) c = cos(angle) m[i][j] = -s m[j][i] = s m[i][i] = c m[j][j] = c return m