js矩阵求逆以及乘积运算

项目场景，根据数据给定一个矩阵以及相对应值，要求将矩阵求逆后乘积，分别求出A/B/C三个值

矩阵求逆：

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

         // 方阵阶数
         const n = square.length;

         let result = 0;

         if(n > 3) {
            // n 阶
            for(let column = 0; column < n; column++) {
            // 去掉第 0 行第 column 列的矩阵
               const 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;
      }

      function transpose(matrix) {
         const 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;
      }

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

         const n = square.length;

         const 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 列的矩阵
               const matrix = [];

               for(let i = 0; i < square.length; i++) {
                  if(i !== row) {
                     const 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);
      }

      function inv(square) {
         if(square[0].length !== square.length) {
            throw new Error();
         }

         const detValue = det(square);
         const 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;
      }

      this.data_Arr = [[2, 3, 1], [5, 2, 4], [-3, 2, 0]];

      this.flip_Arr = inv(this.data_Arr);

      console.log(this.flip_Arr, 'this.flip_Arr');

矩阵乘积

//  翻转后的矩阵
      function Matrix(data) {
         // 这里必须传一个二维数组，最好严格检验一下
         if(typeof data !== 'object' || typeof data.length === 'undefined' || !data) {
            throw new Error('data\'s type is error');
         }

         this.data = data;
         this.cols = data.length;
      }

      var M = {
         findByLocation: function(data, xIndex, yIndex) {
            if(data && data[xIndex]) {
               return data[xIndex][yIndex];
            }
         },
         // 矩阵乘积
         multiply: function(m, n) {
            // eslint-disable-next-line no-unsafe-negation
            if(!m instanceof Matrix && !n instanceof Matrix) {
               throw new Error('data\'s type is error');
            }

            var mData = m.data;
            var nData = n.data;

            if(mData.length == 0 || nData.length == 0) {
               return 0;
            }

            if(mData[0].length != nData.length) {
               throw new Error('the two martrix data is not allowed to dot');
            }

            var result = [];

            for(var i = 0, len = mData.length; i < len; i++) {
               var mRow = mData[i];
               result[i] = [];

               for(var j = 0, jLen = mRow.length; j < jLen; j++) {
                  var resultRowCol = 0;

                  // 如果n矩阵没有足够的列数相乘，转入m矩阵下一行
                  if(typeof this.findByLocation(nData, 0, j) === 'undefined') {
                     break;
                  }

                  for(var k = 0, kLen = jLen; k < kLen; k++) {
                     resultRowCol += mRow[k] * this.findByLocation(nData, k, j);
                  }

                  result[i][j] = resultRowCol;
               }
            }

            console.log(result, 'result');
            return result;
         },
      };
      var m2 = new Matrix(this.flip_Arr);
      var n2 = new Matrix(this.totalCost_Arr);
      M.multiply(m2, n2);

参考：
矩阵求逆：https://blog.csdn.net/XY1790026787/article/details/106144101
矩阵乘积运算：https://www.jb51.net/article/78664.htm