Funzioni reperibili qui: http://www.elegio.it/doc/tn/  Questa in rete; http://www.elegio.it/doc/tn/inversione-non-solo-con-la-lu.html

Proviamo la inversione di matrice usando la LU tradotta dal Fortran in Javascript e usando una function che fa tutto lei...

...abilitare Javascript per vedere...


Inversione fatta da una unica funzione
xalge["fainv"]=function(mat){
    var minore,xmino=function(mat,r,c){
       var j,jn=0,k,kn,id=[],ord=mat.length;
       for(j=0;ord>j;j++){
          if(j!=r){ kn=0;
             id[id.length]=[];
             for(k=0;ord>k;k++){
                if(k!=c){
                   id[jn][kn]=mat[j][k];
                   kn++;} }
             jn++;} };
       return id; }
    var xdet=function(mat){
       var j,ord=mat.length,pm=1,dd=0;
       if(ord==1){
          dd=mat[0][0];
          return dd;};
       for(j=0;ord>j;j++){
          mm=xmino(mat,0,j);
          dd+=pm*mat[0][j]*xdet(mm);
          pm=-pm;}
       return dd; }
    var j,k,m,d,id=[],ord=mat.length;
    d=1/xdet(mat);
    for(j=0;ord>j;j++){
       m=d*(1-2*(j%2));
       id[id.length]=[];
       for(k=0;ord>k;k++){
          minore=xmino(mat,k,j);
          id[j][k]=m*xdet(minore);
          m=-m;} }
    return id;}

Una tridiagonale con determinante unitario. Viene generata dell'ordine voluto...

Questa funzione è molto utile per generare anche grosse matrici di determinante unitario. Se gli elementi della matrice sono tutti interi anche gli elementi della matrice inversa devono essere tutti interi e, se qualcuno non lo è, le cifre decimali segnalano l'errore fatto nel calcolare l'inversa


Matrice tridiagonale e simmetrica
xalge["tridiagunitaria"]=function(ord){
   var j,k,a,triu=[];
   var fd=function(n){return(Math.round(
      (10+n/2)*Math.random())-6)};
   for(j=0;ord>j;j++){triu[j]=[];
      for(k=0;ord>k;k++)triu[j][k]=0;}
   triu[ord-1][ord-1]=1;
   for(j=1;ord>j;j++){a=fd(j);
      triu[j-1][j-1]=1+a*a;
      triu[j-1][j]=a;
      triu[j][j-1]=a;}
   return triu;}

In conclusione

L'inversa basata sulla LU è robusta ma solitamente meno precisa di quella basata sul calcolo dei minori e dei loro determinanti ma l'altra, a volte può dare overflow ( == traboccamento ) dato che i determinanti dei minori possono essere grandissimi... anche se il determinante dell'intera matrice, nel caso quì studiato, vale sempre 1 sia della matrice che, ovviamente, della sua inversa.