[TypeScript] 实现简单矩阵类(四则运算、行列式、逆矩阵...)

Typescript 实现矩阵类，包含矩阵与矩阵的四则运算，矩阵与实数的乘法；矩阵的余子式与代数余子式计算，方阵的行列式计算，伴随矩阵计算，方阵的逆矩阵计算，转置矩阵等。

对于是否是方阵没有作多于判断（懒

方法注释在代码中都有

class Matrix {
    private mm: Array<Array<number>>;
    private _row: number;
    private _col: number;

    /**
     * 可以使用一个二维数组赋值给 mat 以修改矩阵。修改矩阵会同时修改行数列数的变量
     */
    set mat(arr: Array<Array<number>>) {
        this.mm = this.dim2ArrDeepCopy(arr);
        this._row = this.mm.length;
        this._col = this.mm[0].length;
    }

    /**
     * Matrix 构造函数，返回所有元素为0的矩阵。当传入1个参数时，为方阵
     * @param{number}row_num 行数
     * @param{number}col_num 列数
     */
    constructor(row_num: number, col_num?: number) {
        this.mm = [];
        this._row = row_num;
        if (col_num) {
            this._col = col_num;
            for (let i = 0; i < row_num; i++) {
                this.mm.push([]);
                for (let j = 0; j < col_num; j++) {
                    this.mm[i][j] = 0;
                }
            }
        }
        else {
            this._col = row_num;
            for (let i = 0; i < row_num; i++) {
                this.mm.push([]);
                for (let j = 0; j < row_num; j++) {
                    this.mm[i][j] = 0;
                }
            }
        }
    }

    /**
     * 深拷贝二维数组
     * @param{Array<Array<number>>}arr 所要拷贝的二维数组
     * @returns 返回拷贝的二维数组
     */
    private dim2ArrDeepCopy(arr: Array<Array<number>>): Array<Array<number>> {
        let tmp: Array<Array<number>> = [];
        for (let i = 0; i < arr.length; i++) {
            tmp.push([]);
            for (let j = 0; j < arr[0].length; j++) {
                tmp[i][j] = arr[i][j];
            }
        }
        return tmp;
    }

    /**
     * 得到矩阵对应地二维数组的深拷贝
     * @returns 矩阵对应的二维数组
     */
    public getArr(): Array<Array<number>> {
        /* let tmp: Array<Array<number>> = [];
        for (let i = 0; i < this._row; i++) {
            tmp.push([]);
            for (let j = 0; j < this._col; j++) {
                tmp[i][j] = this.mm[i][j];
            }
        } */
        let tmp = this.dim2ArrDeepCopy(this.mm);
        return tmp;
    }

    /**
     * 深拷贝一个矩阵实例
     * @param{Matrix}m 拷贝对象
     */
    public copy(m: Matrix): void {
        this.mat = m.mm;
    }

    /**
     * 遍历矩阵并用函数修改值
     * @param{Function}fn 可传入3个参数: 1.修改的值 2.行索引 3.列索引
     */
    public mapMat(fn: Function): void {
        for (let i = 0; i < this._row; i++) {
            for (let j = 0; j < this._col; j++) {
                // this.mm[i][j] = fn(this.mm[i][j], i, j);
                fn(this.mm[i][j], i, j) &&
                    this.setMatVal(i + 1, j + 1, fn(this.mm[i][j], i, j));
            }
        }
    }

    /**
     * 修改矩阵指定行列的值
     * @param{number}row 指定行
     * @param{number}col 指定列
     * @param{number}value 值
     */
    public setMatVal(row: number, col: number, value: number) {
        this.mm[row - 1][col - 1] = value;
    }

    /**
     * 打印矩阵 用' '和'\n'隔开
     */
    public show(): void {
        let s: string = '';
        for (let i = 0; i < this._row; i++) {
            for (let j = 0; j < this._col; j++) {
                s += this.mm[i][j];
                if (j < this._col - 1) s += ' ';
            }
            if (i < this._row - 1) s += '\n';
        }
        console.log(s);
    }

    /**
     * 求方阵的行列式结果。所求矩阵必须行列数相等
     * @returns 行列式结果
     */
    public det(): number {
        if (this._row == 1 && this._col == 1) {
            return this.mm[0][0];
        }

        const r = 1;  // 取第1行

        let result: number = 0;
        for (let i = 1; i <= this._col; i++) {
            result += this.mm[r - 1][i - 1] * this.alCofactor(r, i);
        }

        return result;
    }

    /**
     * 求余子式
     * @param{number}row 指定行
     * @param{number}col 指定列
     * @returns{number}余子式结果
     */
    public cofactor(row: number, col: number) {
        let tmpMat: Matrix = new Matrix(this._row - 1, this._col - 1);

        for (let i = 0; i < this._row; i++) {
            let _i;
            if (i + 1 < row) _i = i;
            else if (i + 1 > row) _i = i - 1;
            else _i = -1;

            for (let j = 0; j < this._col; j++) {
                let _j;
                if (j + 1 < col) _j = j;
                else if (j + 1 > col) _j = j - 1;
                else _j = -1;

                if (_i == -1 || _j == -1) continue;

                tmpMat.mm[_i][_j] = this.mm[i][j];
            }
        }

        return tmpMat.det();
    }

    /**
     * 求代数余子式
     * @param{number}row 指定行
     * @param{number}col 指定列
     * @returns{number}代数余子式结果
     */
    public alCofactor(row: number, col: number) {
        let c = this.cofactor(row, col);
        if ((row + col) % 2 == 0) return c;
        else return -c;
    }

    /**
     * 矩阵加法，会改变自身。
     * @param{Matrix}m2 所加的矩阵。行列数必须与调用者行列数相等
     * @returns 改变后的调用者
     */
    public plus(m2: Matrix): Matrix {
        // 必须行列相等
        this.mapMat((el: number, i: number, j: number): number => el + m2.mm[i][j]);
        return this;
    }

    /**
     * 矩阵加法的静态方法
     * @param{Matrix}m1 矩阵1
     * @param{Matrix}m2 矩阵2
     * @returns 结果矩阵的实例
     */
    public static plus(m1: Matrix, m2: Matrix): Matrix {
        // 两个矩阵必须行列相等
        let resMat = new Matrix(m1._row, m1._col);
        resMat.mapMat((el: number, i: number, j: number) => m1.mm[i][j] + m2.mm[i][j]);
        return resMat;
    }

    /**
     * 矩阵减法，会改变自身
     * @param{Matrix}m2 被减矩阵。行列数必须与调用者行列数相等
     * @returns 改变后的调用者
     */
    public minus(m2: Matrix): Matrix {
        this.mapMat((el: number, i: number, j: number): number => el - m2.mm[i][j]);
        return this;
    }

    /**
     * 矩阵减法的静态方法
     * @param{Matrix}m1 矩阵1
     * @param{Matrix}m2 矩阵2
     * @returns 结果矩阵的实例
     */
    public static minus(m1: Matrix, m2: Matrix): Matrix {
        // 两个矩阵必须行列相等
        let resMat = new Matrix(m1._row, m1._col);
        resMat.mapMat((el: number, i: number, j: number) => m1.mm[i][j] - m2.mm[i][j]);
        return resMat;
    }

    /**
     * 右乘矩阵，会改变自身
     * @param{Matrix}m2 被乘矩阵。行数必须与调用者列数相等
     * @returns 改变后的调用者
     */
    public multMat(m2: Matrix): Matrix {
        // 行数 = m2的列数
        let resMat: Matrix = new Matrix(this._row, m2._col);
        resMat.mapMat((el: number, i: number, j: number): number => {
            let tmp = 0;
            for (let ii = 0; ii < this._col; ii++) {
                tmp += this.mm[i][ii] * m2.mm[ii][j];
            }
            return tmp;
        })
        this.copy(resMat);
        return this;
    }

    /**
     * 矩阵乘矩阵的静态方法 m1*m2
     * @param{Matrix}m1 矩阵1
     * @param{Matrix}m2 矩阵2
     * @returns 结果矩阵的实例
     */
    public static multMat(m1: Matrix, m2: Matrix): Matrix {
        let resMat: Matrix = new Matrix(m1._row, m2._col);
        resMat.mapMat((el: number, i: number, j: number): number => {
            let tmp = 0;
            for (let ii = 0; ii < m1._col; ii++) {
                tmp += m1.mm[i][ii] * m2.mm[ii][j];
            }
            return tmp;
        })
        return resMat;
    }

    /**
     * 矩阵乘一个实数，会改变自身
     * @param{number}n 乘数
     * @returns 改变后的调用者
     */
    public multNum(n: number): Matrix {
        this.mapMat((el: number, i: number, j: number): number => el * n);
        return this;
    }

    /**
     * 矩阵乘一个实数的静态方法
     * @param{Matrix}m 矩阵
     * @param{number}n 乘数
     * @returns 结果矩阵的实例
     */
    public static multNum(m: Matrix, n: number): Matrix {
        let resMat: Matrix = new Matrix(m._row, m._col);
        resMat.copy(m);
        resMat.mapMat((el: number, i: number, j: number): number => el * n);
        return resMat;
    }

    /**
     * 伴随矩阵
     * @returns{Matrix}伴随矩阵的实例
     */
    public adjointMat(): Matrix {
        let adMat = new Matrix(this._col, this._row);
        adMat.mapMat((el: number, i: number, j: number): number => this.alCofactor(j + 1, i + 1));
        return adMat;
    }

    /**
     * 逆矩阵。必须为方阵，且行列式不为0
     * @returns{Matrix}逆矩阵的实例
     */
    public inv(): Matrix | undefined {
        if (this.det() == 0) {
            console.log('该方阵行列式为0，逆矩阵不存在！');
            return;
        }
        let adMat = this.adjointMat();
        adMat.multNum(1 / this.det());
        return adMat;
    }

    /**
     * 构造一个指定大小的单位矩阵
     * @param{number}n 单位矩阵维数
     * @returns 单位矩阵实例
     */
    public static eye(n: number): Matrix {
        let resMat = new Matrix(n);
        resMat.mapMat((el: number, i: number, j: number) => {
            if (i == j) return 1;
        })
        return resMat;
    }

    /**
     * 求转置矩阵
     * @returns 转置矩阵实例
     */
    public T(): Matrix {
        let resMat = new Matrix(this._col, this._row);
        resMat.mapMat((el: number, i: number, j: number) => this.mm[j][i]);
        return resMat;
    }
}

使用很简单

初始化，每个元素随机值

 实例方法和静态方法的四则运算

可链式调用

转置矩阵

求行列式和逆矩阵

行列式为0时逆矩阵不存在

余子式在逆矩阵中有使用，不做单独演示。

因为二维矩阵比较好观察正确率，所以演示使用二维矩阵。矩阵与其逆矩阵相乘时，可能结果不为单位矩阵，有细微的误差，这和计算精度相关非算法问题。精度方面这里没做过多考虑。

有问题欢迎指正~