计算矩阵的行列式

Question

我正在尝试在JS中计算矩阵的行列式。我使用了http://www.sanfoundry.com/java-program-compute-determinant-matrix/上的算法，但是我在最后一个条件上失去了理智。我就是不明白。你能帮我吗？

这是我现在的代码样子。在另一个函数中，我创建了一个空的二维数组，然后将其复制到det函数中。接下来，我从html中检索值，然后尝试计算矩阵的行列式。前两种情况很简单，但是我在最后一种情况上遇到了问题。我找不到JS中的可用示例。

function det() {
  var det = 0;
  var array1 = array.slice();

  for (i = 0; i < array1.length; i++) {

    for (j = 0; j < array1[i].length; j++) {
      array1[i][j] = parseInt(document.getElementById("element" + (i + 1) + (j + 1)).value, 10);
    }

  }

  if (array1.length == 1) {
    det = array1[0][0];
  } else if (array1.length == 2) {
    det = (array1[0][0] * array1[1][1]) - (array1[1][0] * array1[0][1]);
  } else {

  }

}

- kureva

---

在最后一个条件中，您创建了一个子矩阵，该子矩阵是从array1删除行和列a0j，其中j从0到N，您将a0j乘以det(subarray)，并且这些乘积的总和就是最终的determinant，这就是determinant的定义，递归调用之前编写的代码只是填充子数组而已。 - niceman

递归很好，但在js中要小心。https://dev59.com/4FoU5IYBdhLWcg3wqIO0 - Richard Tyler Miles

Answer 1

我可以建议使用递归算法的解决方案，代码行数很少，我想这适用于大多数实际应用：

const determinant = m => 
  m.length == 1 ?
  m[0][0] :
  m.length == 2 ? 
  m[0][0]*m[1][1]-m[0][1]*m[1][0] :
  m[0].reduce((r,e,i) => 
    r+(-1)**(i+2)*e*determinant(m.slice(1).map(c => 
      c.filter((_,j) => i != j))),0)

const test1 = [[3]]                      // 3
const test2 = [[3,-2],[7,4]]             // 26
const test3 = [[1,3,7],[2,-1,4],[5,0,2]] // 81

console.log(determinant(test1))
console.log(determinant(test2))
console.log(determinant(test3))

.as-console-wrapper {min-height: 100%}

- Yevhen Horbunkov

Answer 2

我创建了一个矩阵类，其中包含一些基本操作函数，其中之一是行列式计算。

下面是构造函数：

constructor(rows,cols) {
    this.rows = rows;
    this.cols = cols;
    this.vals = new Array(rows*cols);
    for(let i = 0; i < this.vals.length; i++) this.vals[i] = 0;
}

而这里是行列式函数。

determinant() {
    if (this.rows != this.cols ) {
        console.log("Matrix must be square");
        return;
    }
    let size = this.rows;
    if (size == 1) return this.vals[0];
    if (size == 2) return this.vals[0]*this.vals[3]-this.vals[1]*this.vals[2];
    let sign = 1;
    let result = 0;
    for (let k = 0 ; k < size ; k++){
        let cofactors = new Matrix(size-1,size-1);
        cofactors.vals = this.vals.slice(size,size*size).filter((_,index)=>index%size!=k);
        result += sign * this.vals[k] * cofactors.determinant();
        sign*=(-1);
    }
    return result;
}

- Alberto L. Duran

---

目前你的回答不够清晰，请编辑并添加更多细节，以帮助其他人理解它如何回答问题。你可以在帮助中心找到有关如何编写好答案的更多信息。 - Community

Answer 3

您可以在此处查看方阵行列式的定义https://en.wikipedia.org/wiki/Determinant#n_.C3.97_n_matrices。 http://www.sanfoundry.com/java-program-compute-determinant-matrix/中使用的算法利用行列式的某些性质以递归方式计算它，作为所有排列的总和。这样，您将得到N * N!次操作！即使对于小的N，也非常大。

为了解决这个问题，您可以首先将矩阵转换为具有相同行列式的三角形矩阵，然后将行列式计算为所有对角线元素的乘积。

- ivan kuklin