用python实现矩阵和矩阵的相乘_线性代数_day16

from playLA.Vector import Vector


class Matrix(object):
    def __init__(self, list2d):
        """初始化矩阵类"""
        self._values = [row[:] for row in list2d]

    @classmethod
    def zero(cls, r, c):
        """返回一个r行，c列的零矩阵"""
        return cls([[0]*c for _ in range(r)])

    def __add__(self, other):
        """返回两个矩阵的加法的结果"""
        assert self.shape() == other.shape(), \
            "这两个矩阵的大小必须是一样的"
        return Matrix([a + b for a, b in zip(self.row_vector(i), other.row_vector(i))]
                      for i in range(self.row_num()))

    def __sub__(self, other):
        """返回两个矩阵的减法的结果"""
        assert self.shape() == other.shape(), \
            "这两个矩阵的大小必须是一样的"
        return Matrix([a - b for a, b in zip(self.row_vector(i), other.row_vector(i))]
                      for i in range(self.row_num()))

    def dot(self, another):
        """返回矩阵和矩阵 或 矩阵和向量的 相乘的结果"""
        if isinstance(another, Vector):
            # 矩阵和向量的相乘
            assert self.col_num()==len(another), \
                "矩阵 和 向量的长度不一致"
            return Vector([self.row_vector(i).dot(another) for i in range(self.row_num())])


        if isinstance(another, Matrix):
            # 矩阵和矩阵的相乘
            assert self.col_num() == another.row_num(), \
                "矩阵和矩阵的维度不相同"
            return Matrix([[self.row_vector(i).dot(another.col_vector(j)) for j in range(another.col_num())
                            for i in range(self.row_num())]])


    def __mul__(self, k):
        """返回矩阵的数量乘法"""
        return Matrix([e * k for e in self.row_vector(i)] for i in range(self.row_num()))

    def __rmul__(self, k):
        """返回矩阵的数量乘法,这次返回的是k * self的值"""
        return self * k

    def __truediv__(self, k):
        """返回矩阵的数量除法： self / k"""
        return (1 / k) * self

    def __pos__(self):
        """返回矩阵取正的结果"""
        return 1 * self

    def __neg__(self):
        """返回矩阵取负的方法"""
        return -1 * self

    def row_vector(self, index):
        """返回矩阵的第index个行向量"""
        return Vector(self._values[index])

    def col_vector(self, index):
        """返回矩阵的第index个列向量"""
        return Vector([row[index] for row in self._values])

    def __getitem__(self, pos):
        """返回矩阵pos位置的元素"""
        r, c = pos
        return self._values[r][c]

    def size(self):
        """返回矩阵中的元素的个数"""
        r, c = self.shape()
        return r * c

    def shape(self):
        """返回矩阵的形状：（行数， 列数）"""
        return len(self._values), len(self._values[0])

    def row_num(self):
        """返回矩阵的行数"""
        return self.shape()[0]

    __len__ = row_num

    def col_num(self):
        """返回矩阵的列数"""
        return self.shape()[1]

    def __repr__(self):
        return "Matrix({})".format(self._values)

    __str__ = __repr__


if __name__ == '__main__':
    matrix = Matrix([[1, 2], [3, 4]])
    print(matrix)

    print("matrix.shape = {}".format(matrix.shape()))
    print("matrix.size = {}".format(matrix.size()))
    print("len(matrix) = {}".format(len(matrix)))
    print("matrix[0][0] = {}".format(matrix[0, 0]))

    # -------------- 实现矩阵的基本运算-----------------
    matrix2 = Matrix([[5, 6], [7, 8]])
    print("add: {}".format(matrix + matrix2))
    print("subtract: {}".format(matrix - matrix2))
    print("scalar-mul: {}".format(matrix * 2))
    print("scalar-mul: {}".format(2 * matrix ))
    print("zero 2 3: {}".format(Matrix.zero(2, 3)))

    # 矩阵和矩阵之间的点乘
    T = Matrix([[1.5, 0],[0, 2]])
    p = Vector([5, 3])
    print("T.dot(p) = {}".format(T.dot(p)))

    p = Matrix([[0, 4, 5], [0, 0, 3]])
    print("T.dot(P) = {}".format(T.dot(p)))

    print("A.dot(B) = {}".format(matrix.dot(matrix2)))
    print("B.dot(A) = {}".format(matrix2.dot(matrix)))