如何在不导入 Numpy 的情况下创建矩阵？

Question

import numpy as np


Matrix

A = np.array ([[0.23,0.11,0.6], [0.4,0.35,0,5],[0.05,0.2,0.75]])
b = np.array([[1],[5],[5]])

##GAUSSIAN ELIMINATION

AugmentedMatrix = np.hstack([A, b.reshape(-1, 1)])
print(AugmentedMatrix)

n = len(b)

for i in range(n):
    a = AugmentedMatrix[i]

    for j in range(i + 1, n):
        b = AugmentedMatrix[j]
        m = a[i] / b[i]
        AugmentedMatrix[j] = a - m * b

for i in range(n - 1, -1, -1):
    AugmentedMatrix[i] = AugmentedMatrix[i] / AugmentedMatrix[i, i]
    a = AugmentedMatrix[i]

    for j in range(i - 1, -1, -1):
        b = AugmentedMatrix[j]
        m = a[i] / b[i]
        AugmentedMatrix[j] = a - m * b

x = AugmentedMatrix[:, 3]

print ("X1 =",x[0])
print ("X2 =",x[1])
print ("X3 =",x[2])

基本上，我不能在这个等式中使用 numpy。关于如何在没有它的情况下创建数组的任何提示？我尝试使用列表列表，但出现错误 TypeError：不能将序列乘以“浮点”类型的非整数

Answer 1

好吧，我犯了一个小错误...
我出去在一个简单的类中实现了一些矩阵/标量操作。
然后我看了这个任务，发现主要是行操作。
我没有时间重写课程，所以主要解决方案看起来很垃圾。
矩阵类：

class Matrix:
    def __init__(self, list_of_lists):
        if isinstance(list_of_lists, Matrix):
            self.matrix = list_of_lists.matrix.copy()
        elif not isinstance(list_of_lists, list):
            raise ValueError("Not a list")
        elif not all((isinstance(x, list) for x in list_of_lists)):
            raise ValueError("Element of main list is not a list")
        elif not all((type(y) in [int, float] for x in list_of_lists for y in x)):
            raise ValueError("Element of sub list is not a number")
        else:
            self.matrix = list_of_lists

    def __len__(self):
        return max(len(self.matrix), len(self.matrix[0]))

    def __str__(self):
        s = [[str(e) for e in row] for row in self.matrix]
        lens = [max(map(len, col)) for col in zip(*s)]
        fmt = (' '*2).join('{{:{}}}'.format(x) for x in lens)
        table = [fmt.format(*row) for row in s]
        return str('\n'.join(table))

    def size(self):
        return len(self.matrix), len(self.matrix[0])

    def __repr__(self):
        return str(self)

    def __getitem__(self, row):
        return self.matrix[row]

    def __setitem__(self, row, data):
        self.matrix[row] = data

    def __internal_scalar_operation(self, row_number, scalar_value, operator):
        if operator == '+':
            self[row_number] = [float(x + scalar_value) for x in self[row_number]]
        elif operator == '-':
            self[row_number] = [float(x-scalar_value) for x in self[row_number]]
        elif operator == '*':
            self[row_number] = [float(x*scalar_value) for x in self[row_number]]
        elif operator == '/':
            self[row_number] = [float(x/scalar_value) for x in self[row_number]]

    def scalar_row_add(self, row_number, scalar_value):
        self.__internal_scalar_operation(row_number, scalar_value, '+')
    def scalar_row_sub(self, row_number, scalar_value):
        self.__internal_scalar_operation(row_number, scalar_value, '-')
    def scalar_row_mul(self, row_number, scalar_value):
        self.__internal_scalar_operation(row_number, scalar_value, '*')
    def scalar_row_div(self, row_number, scalar_value):
        self.__internal_scalar_operation(row_number, scalar_value, '/')

    def __internal_row_operation(self, row_number, row, operator):
        if not len(self[row_number]) == len(row):
            raise ArithmeticError("Matrices with not same dimensions")
        if operator == '+':
            self[row_number] = [float(x + y) for x, y in zip(self[row_number], row)]
        elif operator == '-':
            self[row_number] = [float(x - y) for x, y in zip(self[row_number], row)]
        elif operator == '*':
            self[row_number] = [float(x * y) for x, y in zip(self[row_number], row)]
        elif operator == '/':
            self[row_number] = [float(x / y) for x, y in zip(self[row_number], row)]

    def row_add_row(self, row_number, row):
        self.__internal_row_operation(row_number, row, '+')
    def row_sub_row(self, row_number, row):
        self.__internal_row_operation(row_number, row, '-')
    def row_mul_row(self, row_number, row):
        self.__internal_row_operation(row_number, row, '*')
    def row_div_row(self, row_number, row):
        self.__internal_row_operation(row_number, row, '/')

    def append_column(self, matrix_column):
        for idx, row in enumerate(matrix_column):
            self.matrix[idx].append(*row)

和主要的

m1 = Matrix([[0.05,0.55,0.25], [0.9,0.25,0],[0.05,0.2,0.75]])
m2 = Matrix([[2],[6],[2]])
m1.append_column(m2)
xn = len(m2)

for i in range(xn):
    for j in range(i + 1, xn):
        mm = m1[i][i] / m1[j][i]
        tmp1 = Matrix(m1)
        tmp2 = Matrix(m1)
        tmp2.scalar_row_mul(j, mm)
        tmp1.row_sub_row(i, tmp2[j])
        m1[j] = tmp1[i]

for i in range(xn - 1, -1, -1):
    m1.scalar_row_div(i, m1[i][i])
    for j in range(i - 1, -1, -1):
        tmp1 = Matrix(m1)
        tmp2 = Matrix(m1)
        mm = m1[i][i] / tmp2[j][i]
        tmp2.scalar_row_mul(j, mm)
        tmp1.row_sub_row(i, tmp2[j])
        m1[j] = tmp1[i]

print(m1)

最终结果看起来不错

1.0   -0.0  -0.0  6.01562500000001 
-0.0  1.0   -0.0  2.343749999999999
0.0   0.0   1.0   1.640625