JS实现矩阵相乘、行列式、逆矩阵

一、矩阵运算

1.1 矩阵相乘

• ${\mathrm{A}}_{\mathrm{m}\times \mathrm{p}}$、${\mathrm{B}}_{\mathrm{p}\times \mathrm{n}}$
• ${\mathrm{C}}_{\mathrm{m}\times \mathrm{n}}={\mathrm{A}}_{\mathrm{m}\times \mathrm{p}}\times {\mathrm{B}}_{\mathrm{p}\times \mathrm{n}}$
• ${\mathrm{C}}_{\mathrm{i}\mathrm{j}}={\sum }_{\mathrm{k}=1}^{\mathrm{p}}{a}_{\mathrm{i}\mathrm{k}}\cdot b_{\mathrm{k}\mathrm{j}}$

function multiply(a, b) {
    // 相乘约束
    if (a[0].length !== b.length) {
        throw new Error();
    }
    let m = a.length;
    let p = a[0].length;
    let n = b[0].length;

    // 初始化 m*n 全 0 二维数组
    let c = new Array(m).fill(0).map(arr => new Array(n).fill(0));

    for (let i = 0; i < m; i++) {
        for (let j = 0; j < n; j++) {
            for (let k = 0; k < p; k++) {
                c[i][j] += a[i][k] * b[k][j];
            }
        }
    }

    return c;
}

1.2 行列式

• 1 阶：$\left|\begin{array}{c}{a}_{11}\end{array}\right|=a_{11}$

• 2 阶：$\left|\begin{array}{cc}{a}_{11}& a_{12}\\ a_{21}& a_{22}\end{array}\right|=a_{11}\cdot a_{22}-a_{12}\cdot a_{21}$

• 3 阶：$\left|\begin{array}{ccc}{a}_{11}& a_{12}& a_{13}\\ a_{21}& a_{22}& a_{23}\\ a_{31}& a_{32}& a_{33}\end{array}\right|=a_{11}{a}_{22}{a}_{33}+a_{12}{a}_{23}{a}_{31}+a_{13}{a}_{21}{a}_{32}-a_{13}{a}_{22}{a}_{31}-a_{12}{a}_{21}{a}_{33}-a_{11}{a}_{23}{a}_{32}$

• n 阶：任意某行（或某列）的各元素与其对应的代数余子式乘积之和

• 3 阶行列式：对应行平移后公式也可认为『主对角线元素积与副对角线元素积之差

• 代数余子式：『$(-1{)}^{\mathrm{i}+\mathrm{j}}$ 』乘以『去掉方阵第 i 行第 j 列的元素后构成的方阵的行列式』的值

n 阶行列式可取第 1 行的各元素与其对应的代数余子式乘积之和，如：
$$\left|\begin{array}{cccc}{a}_{11}& a_{12}& a_{13}& a_{14}\\ a_{21}& a_{22}& a_{23}& a_{24}\\ a_{31}& a_{32}& a_{33}& a_{34}\\ a_{41}& a_{42}& a_{43}& a_{44}\end{array}\right|=a_{11}\cdot (-1{)}^{1+1}\cdot \left|\begin{array}{ccc}{a}_{22}& a_{23}& a_{24}\\ a_{32}& a_{33}& a_{34}\\ a_{42}& a_{43}& a_{44}\end{array}\right|+a_{12}\cdot (-1{)}^{1+2}\cdot \left|\begin{array}{ccc}{a}_{21}& a_{23}& a_{24}\\ a_{31}& a_{33}& a_{34}\\ a_{41}& a_{43}& a_{44}\end{array}\right|+a_{13}\cdot (-1{)}^{1+3}\cdot \left|\begin{array}{ccc}{a}_{21}& a_{22}& a_{24}\\ a_{31}& a_{32}& a_{34}\\ a_{41}& a_{42}& a_{44}\end{array}\right|+a_{14}\cdot (-1{)}^{1+4}\cdot \left|\begin{array}{ccc}{a}_{21}& a_{22}& a_{23}\\ a_{31}& a_{32}& a_{33}\\ a_{41}& a_{42}& a_{43}\end{array}\right|$$

function det(square) {
    // 方阵约束
    if (square.length !== square[0].length) {
        throw new Error();
    }
    // 方阵阶数
    let n = square.length;

    let result = 0;
    if (n > 3) {
        // n 阶
        for (let column = 0; column < n; column++) {
            // 去掉第 0 行第 column 列的矩阵
            let matrix = new Array(n - 1).fill(0).map(arr => new Array(n - 1).fill(0));
            for (let i = 0; i < n - 1; i++) {
                for (let j = 0; j < n - 1; j++) {
                    if (j < column) {
                        matrix[i][j] = square[i + 1][j];
                    } else {
                        matrix[i][j] = square[i + 1][j + 1];
                    }
                }
            }
            result += square[0][column] * Math.pow(-1, 0 + column) * det(matrix);
        }
    } else if (n === 3) {
        // 3 阶
        result = square[0][0] * square[1][1] * square[2][2] +
                 square[0][1] * square[1][2] * square[2][0] +
                 square[0][2] * square[1][0] * square[2][1] -
                 square[0][2] * square[1][1] * square[2][0] -
                 square[0][1] * square[1][0] * square[2][2] -
                 square[0][0] * square[1][2] * square[2][1];
    } else if (n === 2) {
        // 2 阶
        result = square[0][0] * square[1][1] - square[0][1] * square[1][0];
    } else if (n === 1) {
        // 1 阶
        result = square[0][0];
    }
    return result;
}

1.2 转置矩阵

function transpose(matrix) {
    let result = new Array(matrix.length).fill(0).map(arr => new Array(matrix[0].length).fill(0));
    for (let i = 0; i < result.length; i++) {
        for (let j = 0; j < result[0].length; j++) {
            result[i][j] = matrix[j][i];
        }
    }
    return result;
}

1.3 伴随矩阵

• 伴随矩阵：矩阵中每个元素对应的代数余子式所构成矩阵的转置矩阵

function adjoint(square) {
    // 方阵约束
    if (square[0].length !== square.length) {
        throw new Error();
    }

    let n = square.length;

    let result = new Array(n).fill(0).map(arr => new Array(n).fill(0));
    for (let row = 0; row < n; row++) {
        for (let column = 0; column < n; column++) {
            // 去掉第 row 行第 column 列的矩阵
            let matrix = [];
            for (let i = 0; i < square.length; i++) {
                if (i !== row) {
                    let arr = [];
                    for (let j = 0; j < square.length; j++) {
                        if (j !== column) {
                            arr.push(square[i][j]);
                        }
                    }
                    matrix.push(arr);
                }
            }
            result[row][column] = Math.pow(-1, row + column) * det(matrix);
        }
    }
    return transpose(result);
}

PS

和 det()函数里求『去掉第 0 行第 column 列矩阵』的复制方法相比较，求『去掉第 row 行第 column 列矩阵』里采用尾插法相对更加简洁可读一些。不过还是太 low …

1.4 逆矩阵

• $[\mathrm{A}\mathrm{E}]\stackrel{初等变换}{⟶}[\mathrm{E}{\mathrm{A}}^{-1}]$

• $A^{-1}=\frac{1}{|\mathrm{A}|}\cdot {\mathrm{A}}^{\ast }$

function inv(square) {
    if (square[0].length !== square.length) {
        throw new Error();
    }
    let detValue = det(square);
    let result = adjoint(square);
    
    for (let i = 0; i < result.length; i++) {
        for (let j = 0; j < result.length; j++) {
            result[i][j] /= detValue;
        }
    }
    return result;
}

1.5 秩

// TODO