javascriptで行列の演算をする

class Matrix {
  constructor (ary) { this.matrix = ary }
  add (arg) { this.matrix = this.constructor.add (this.matrix, arg.matrix) }
  sub (arg) { this.matrix = this.constructor.sub (this.matrix, arg.matrix) }
  mult (arg) { this.matrix = this.constructor.mult (this.matrix, arg.matrix) }
  get transpose () { return this.constructor.transpose (this.matrix) }
  get inverse () { return this.constructor.inverse (this.matrix) }


  //行列の加算        
  static add (a, b) { return a.map((a,i)=> b[i].map((b,j)=> a[j]+b)) }
  //行列の減算
  static sub (a, b) { return a.map((a,i)=> b[i].map((b,j)=> a[j]-b)) }
  //行列の積
  static mult (a, b) { return a.map(a=> a.map((_, i)=> b.reduce((g,_,j)=> g + a[j]*b[j][i],0))) }
  //転置
  static transpose (a) { return a[0].map((_,i)=> a.map ((_,j)=> a[j][i]))}
  //単位行列
  static identity (n) { return [...Array(n)].fill(0).map((a,b,c,d=[...c])=>(d[b]=1,d)) }
  //逆行列
  static inverse (A) { return A.reduce((a,b,c,d,e=b[c],f=a[c])=>A.reduce((a,h,i,_,j=h[c],k=A[i],l=a[i])=>(c==i||A.forEach((_,m)=>(k[m]-=b[m]*j,l[m]-=f[m]*j)),a),(A.forEach((_,i)=>(b[i]/=e,f[i]/=e)),a)),this.identity(A.length))}
}

//＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿

let mt0 = [
  [ 1, 2, 0,-1],
  [-1, 1, 2, 0],
  [ 2, 0, 1, 1],
  [ 1,-2,-1, 1]
];
let rst = Matrix.inverse (mt0);

console.log(rst);

2*2

/*
| a b |
| c d |
*/
class Matrix22 {
  #matrix=new Array(4);
  constructor(A=1,B=0,C=0,D=1){this.#matrix=[A,B,C,D]}
  add(M){let[A,B,C,D]=this.#matrix,[a,b,c,d]=M.matrix;this.#matrix=[A+a,B+b,C+c,D+d];return this}//加算
  sub(M){let[A,B,C,D]=this.#matrix,[a,b,c,d]=M.matrix;this.#matrix=[A-a,B-b,C-c,D-d];return this}//減算
  scalarMultiple(n=1){let[A,B,C,D]=this.#matrix;this.#matrix=[A*n,B*n,C*n,D*n];return this}//スカラー倍
  multiply(M){let[A,B,C,D]=this.#matrix,[a,b,c,d]=M.matrix;this.#matrix=[A*a+B*c,A*b+B*d,C*a+D*c,C*b+D*d];return this}//乗算
  get matrix(){return this.#matrix}//内部の値を配列で返す
  get det(){let[A,B,C,D]=this.#matrix;return A*D-B*C}//行列式(determinant)
  get transpose(){let[A,B,C,D]=this.#matrix;return new this.constructor(A,C,B,D)}//転置
  get inverse(){let[A,B,C,D]=this.#matrix,e=1/this.det;return new this.constructor(D*e,-B*e,-C*e,A*e)}//逆数
}

/*
| a b c | 
| d e f | 
| g h i | 
*/
class Matrix33 {
  #matrix=new Array(9);
  constructor(a=1,b=0,c=0,d=0,e=1,f=0,g=0,h=0,i=1){this.#matrix=[a,b,c,d,e,f,g,h,i]}
  add(M){let[A,B,C,D,E,F,G,H,I]=this.#matrix,[a,b,c,d,e,f,g,h,i]=M.matrix;this.#matrix=[A+a,B+b,C+c,D+d,E+e,F+f,G+g,H+h,I+i];return this}//加算
  sub(M){let[A,B,C,D,E,F,G,H,I]=this.#matrix,[a,b,c,d,e,f,g,h,i]=M.matrix;this.#matrix=[A-a,B-b,C-c,D-d,E-e,F-f,G-g,H-h,I-i];return this}//減算
  scalarMultiple(n=1){let[A,B,C,D,E,F,G,H,I]=this.#matrix;this.#matrix=[A*n,B*n,C*n,D*n,E*n,F*n,G*n,H*n,I*n];return this}//スカラー倍
  multiply (M) {let[A,B,C,D,E,F,G,H,I]=this.#matrix,[a,b,c,d,e,f,g,h,i]=M.matrix;this.#matrix=[A*a+B*d+C*g,A*b+B*e+C*h,A*c+B*f+C*i,D*a+E*d+F*g,D*b+E*e+F*h,D*c+E*f+F*i,G*a+H*d+I*g,G*b+H*e+I*h,G*c+H*f+I*i];return this}//乗算
  get transpose(){let[A,B,C,D,E,F,G,H,I]=this.#matrix;return new this.constructor(A,D,G,B,E,H,C,F,I)}//転置
  get det(){let[A,B,C,D,E,F,G,H,I]=this.#matrix;return A*E*I-A*F*H+B*F*G-B*D*I+C*D*H-C*E*G}//行列式(determinant)
  get inverse(){let[A,B,C,D,E,F,G,H,I]=this.#matrix,e=1/this.det;return new this.constructor((E*I-F*H)*e,-(B*I-C*H)*e,(B*F-C*E)*e,-(D*I-F*G)*e,(A*I-C*G)*e,-(A*F-C*D)*e,(D*H-E*G)*e,-(A*H-B*G)*e,(A*E-B*D)*e)}//逆数
}