程序代写 from math import *

from math import *

class matrix(object):

Copyright By PowCoder代写 加微信 powcoder

# implements basic operations of a matrix class

# ————
# initialization – can be called with an initial matrix

def __init__(self, value = [[]]):
self.value = value
self.dimx = len(value)
self.dimy = len(value[0])
if value == [[]]:
self.dimx = 0
# ———–
# defines matrix equality – returns true if corresponding elements
# in two matrices are within epsilon of each other.

def __eq__(self, other):
epsilon = 0.01
if self.dimx != other.dimx or self.dimy != other.dimy:
return False
for i in range(self.dimx):
for j in range(self.dimy):
if abs(self.value[i][j] – other.value[i][j]) > epsilon:
return False
return True

def __ne__(self, other):
return not (self == other)
def __getitem__(self, item):
return self.value[item]

def zero(self, dimx, dimy):
# check if valid dimensions
if dimx < 1 or dimy < 1: raise ValueError self.dimx = dimx self.dimy = dimy self.value = [[0 for col in range(dimy)] for row in range(dimx)] # ------------ # makes matrix of a certain (square) size and turns matrix into identity matrix def identity(self, dim): # check if valid dimension if dim < 1: raise ValueError self.dimx = dim self.dimy = dim self.value = [[0 for col in range(dim)] for row in range(dim)] for i in range(dim): self.value[i][i] = 1 def show(self): for i in range(self.dimx): print(self.value[i]) print(' ') # ------------ # defines elmement-wise matrix addition. Both matrices must be of equal dimensions def __add__(self, other): # check if correct dimensions if self.dimx != other.dimx or self.dimy != other.dimy: raise ValueError # add if correct dimensions res = matrix([[]]) res.zero(self.dimx, self.dimy) for i in range(self.dimx): for j in range(self.dimy): res.value[i][j] = self.value[i][j] + other.value[i][j] return res # ------------ # defines elmement-wise matrix subtraction. Both matrices must be of equal dimensions def __sub__(self, other): # check if correct dimensions if self.dimx != other.dimx or self.dimy != other.dimy: raise ValueError # subtract if correct dimensions res = matrix() res.zero(self.dimx, self.dimy) for i in range(self.dimx): for j in range(self.dimy): res.value[i][j] = self.value[i][j] - other.value[i][j] return res # ------------ # defines multiplication. Both matrices must be of fitting dimensions def __mul__(self, other): # check if correct dimensions if self.dimy != other.dimx: raise ValueError # multiply if correct dimensions res = matrix() res.zero(self.dimx, other.dimy) for i in range(self.dimx): for j in range(other.dimy): for k in range(self.dimy): res.value[i][j] += self.value[i][k] * other.value[k][j] return res # ------------ # returns a matrix transpose def transpose(self): # compute transpose res = matrix() res.zero(self.dimy, self.dimx) for i in range(self.dimx): for j in range(self.dimy): res.value[j][i] = self.value[i][j] return res # ------------ # creates a new matrix from the existing matrix elements. # Example: # l = matrix([[ 1, 2, 3, 4, 5], # [ 6, 7, 8, 9, 10], # [11, 12, 13, 14, 15]]) # l.take([0, 2], [0, 2, 3]) # results in: # [[1, 3, 4], # [11, 13, 14]] # take is used to remove rows and columns from existing matrices # list1/list2 define a sequence of rows/columns that shall be taken # is no list2 is provided, then list2 is set to list1 (good for symmetric matrices) def take(self, list1, list2 = []): if list2 == []: list2 = list1 if len(list1) > self.dimx or len(list2) > self.dimy:
raise ValueError(“list invalid in take()”)

res = matrix()
res.zero(len(list1), len(list2))
for i in range(len(list1)):
for j in range(len(list2)):
res.value[i][j] = self.value[list1[i]][list2[j]]
return res

# ————
# creates a new matrix from the existing matrix elements.
# Example:
# l = matrix([[1, 2, 3],
# [4, 5, 6]])
# l.expand(3, 5, [0, 2], [0, 2, 3])
# results in:
# [[1, 0, 2, 3, 0],
# [0, 0, 0, 0, 0],
# [4, 0, 5, 6, 0]]
# expand is used to introduce new rows and columns into an existing matrix
# list1/list2 are the new indexes of row/columns in which the matrix
# elements are being mapped. Elements for rows and columns
# that are not listed in list1/list2
# will be initialized by 0.0.

def expand(self, dimx, dimy, list1, list2 = []):
if list2 == []:
list2 = list1
if len(list1) > self.dimx or len(list2) > self.dimy:
raise ValueError(“list invalid in expand()”)

res = matrix()
res.zero(dimx, dimy)
for i in range(len(list1)):
for j in range(len(list2)):
res.value[list1[i]][list2[j]] = self.value[i][j]
return res

def Cholesky(self, ztol=1.0e-25):
# Computes the upper triangular Cholesky factorization of
# a positive definite matrix.
# This code is based on http://adorio-research.org/wordpress/?p=4560
res = matrix()
res.zero(self.dimx, self.dimx)

for i in range(self.dimx):
S = sum([(res.value[k][i])**2 for k in range(i)])
d = self.value[i][i] – S
if abs(d) < ztol: res.value[i][i] = 0.0 if d < 0.0: raise ValueError res.value[i][i] = sqrt(d) for j in range(i+1, self.dimx): S = sum([res.value[k][i] * res.value[k][j] for k in range(i)]) if abs(S) < ztol: res.value[i][j] = (self.value[i][j] - S) / res.value[i][i] except Exception: raise ValueError return res # ------------ # Computes inverse of matrix given its Cholesky upper Triangular # decomposition of matrix. # This code is based on http://adorio-research.org/wordpress/?p=4560 def CholeskyInverse(self): res = matrix() res.zero(self.dimx, self.dimx) # Backward step for inverse. for j in reversed(list(range(self.dimx))): tjj = self.value[j][j] S = sum([self.value[j][k]*res.value[j][k] for k in range(j+1, self.dimx)]) res.value[j][j] = 1.0 / tjj**2 - (S / tjj) for i in reversed(list(range(j))): res.value[i][j] = -sum([self.value[i][k] * res.value[k][j] for k in range(i + 1, self.dimx)]) / self.value[i][i] res.value[j][i] = res.value[i][j] return res def inverse(self): aux = self.Cholesky() res = aux.CholeskyInverse() return res # ------------ # prints matrix (Could be nicer!) def __repr__(self): return "\n".join([" ".join(format(y, "10.4f") for y in x) for x in self.value]) 程序代写 CS代考 加微信: powcoder QQ: 1823890830 Email: powcoder@163.com