def get_lambda_times_i_matrix(self, value):
vectors = []
for i in range(self.num_columns):
vector_entries = [0] * self.num_rows
vector_entries[i] = value
vectors.append(AVector(vector_entries))
return AMatrix(vectors)
def find_matrix_without_row_column(self, row, column):
new_matrix = []
for i in range(self.num_columns):
if i != column:
new_vector = []
for j in range(self.num_rows):
if j != row:
new_vector.append(self[i][j])
new_matrix.append(AVector(new_vector))
return AMatrix(new_matrix)
def multiply_with_vector(self, other):
if other.size == self.num_columns:
products = []
for i in range(self.num_rows):
products.append(0)
for j in range(self.num_columns):
products[i] += (self[j][i] * other[j])
return AVector(products)
else:
raise Exception(
'Can only multiply with vectors of size == num columns')
def get_eigenvector(self, eigenvalue):
eigenvector_matrix = self.find_eigenvector_matrix(eigenvalue)
eigenvector_entries = [0] * eigenvector_matrix.num_rows
for i in range(eigenvector_matrix.num_rows - 1, -1, -1):
if eigenvector_matrix.is_zero_row(i):
eigenvector_entries[i] = 1
else:
pos = eigenvector_matrix.find_first_non_zero_in_row(i)
for j in range(pos + 1, eigenvector_matrix.num_columns):
eigenvector_entries[i] += (
-1 * eigenvector_matrix[j][i]) * eigenvector_entries[j]
return AVector(eigenvector_entries)
def get_stochastic_matrix(self):
new_matrix = []
for vector in self.matrix:
total_of_entries = Fraction(sum(vector.entries), 1)
if total_of_entries == 0:
new_matrix.append(self.generate_personalization_vector())
else:
new_vector = []
for i in range(vector.size):
new_vector.append(vector[i] / total_of_entries)
new_matrix.append(AVector(new_vector))
return AMatrix(new_matrix)
def Create_Matrix(data):
vectors = []
for i in data:
vectors.append(AVector(i))
TheMatrix = AMatrix(vectors)
return TheMatrix
def test():
v1 = AVector([0, 0, 0])
v2 = AVector([1, 1, 1])
v3 = AVector([2, 5, 4])
print(AMatrix([v1, v2, v3]).get_stochastic_matrix())
def get_transpose(self):
new_vectors = []
for i in range(self.num_rows):
new_vectors.append(AVector(self.get_row(i)))
return AMatrix(new_vectors)
def generate_personalization_vector(self):
vector = []
for i in range(self.num_rows):
vector.append(Fraction(1, self.num_rows))
return AVector(vector)