Степенной метод на python. Алгебраические проблемы собственных значений

def read_matrix_from_file(filename):
    with open(filename, 'r') as file:
        lines = file.readlines()
        matrix = []
        for line in lines:
            row = list(map(float, line.split()))
            matrix.append(row)
        return matrix
 
def matrix_multiply(A, B):
    n = len(A)
    m = len(B[0]) if isinstance(B[0], list) else 1
    result = [[0] * m for _ in range(n)]  # Инициализация результирующей матрицы
 
    for i in range(n):
        for j in range(m):
            sum_product = 0
            for k in range(len(B)):
                sum_product += A[i][k] * (B[k][j] if isinstance(B[0], list) else B[k])
            result[i][j] = sum_product
    return result
 
def matrix_power(A, k):
    n = len(A) 
    result = []
    for i in range(n):
        row = []
        for j in range(n):
            if i == j:
                row.append(1)
            else:
                row.append(0)
        result.append(row) 
 
    while k > 0:
        if k % 2 != 0:
            result = matrix_multiply(result, A)
        A = matrix_multiply(A, A)
        k //= 2 
    return result
 
def vector_norm(v):
    squared_sum = 0
    for x in v:
        squared_sum += x ** 2 
 
    norm = squared_sum ** 0.5 
    return norm
 
def normalize(v):
    norm = vector_norm(v)
    normalized_vector = []
    for x in v:
        normalized_vector.append(x / norm) 
    return normalized_vector
 
def power_method(A, max_iterations=1000, delta=1e-10):
    n = len(A) 
    y_m = [1.0] * n 
    x_m = normalize(y_m)
 
    lambda_prev = [0] * n 
 
    for k in range(1, max_iterations + 1):
        m = 1
        while m < k:  # Находим максимальную степень двойки, меньшую k
            m *= 2
        
        # Вычисляем y^(k) = A^(k-m) * y^(m)
        A_k_minus_m = matrix_power(A, k - m)  # Возводим A в степень (k - m)
 
        y_m_column = []
        for val in y_m:
            y_m_column.append([val])
 
        y_k = matrix_multiply(A_k_minus_m, y_m_column)  
 
        one_dimensional_y_k = []
        for val in y_k:
            one_dimensional_y_k.append(val[0])
 
        y_k = one_dimensional_y_k 
 
        y_k = normalize(y_k)
 
        # Вычисляем λ^(k)_i
        lambda_k = []
        for i in range(n):
            if abs(x_m[i]) > delta:
                lambda_k.append(y_k[i] / x_m[i])  # Вычисляем собственное число
            else:
                lambda_k.append(0)
 
        # Проверяем, что текущая итерация больше 1 и разница между текущими и предыдущими собственными числами меньше заданного порога delta
        if k > 1 and all(abs(lambda_k[i] - lambda_prev[i]) < delta for i in range(n)):
            eigenvalue = sum(lambda_k) / len(lambda_k)
            return eigenvalue, y_k
 
        lambda_prev = lambda_k
        x_m = y_k
 
   
    return None, None
 
def write_result_to_file(filename, eigenvalue, eigenvector):
    with open(filename, 'w') as file:
        file.write(f"Собственное значение: {eigenvalue}\n")
        file.write(f"Собственный вектор: {eigenvector}\n")
 
 
A = read_matrix_from_file('input.txt')
 
eigenvalue, eigenvector = power_method(A)
 
if eigenvalue is not None and eigenvector is not None:
    write_result_to_file('output.txt', eigenvalue, eigenvector)
else:
    with open('output.txt', 'w') as file:
        file.write("Не удалось найти собственное значение.\n")