//
// Ecco come va fatto il file del Web Worker 
// che spedisce, al file che lo attiva,
// i risultati ottenuti usando
// la function postMessage(calcolo)
//
//
// Riceve l'ordine dal file che attiva il Web Worker
//
var $calcolo=0;
var $ricevuto=-1,$attesa=1;
onmessage=function(eccoqua){
        $ricevuto=eccoqua.data }
//
// ================================================
//
// Operazioni algebriche tradizionali 
//
var $_1_={versione:20170619,br:"\u003cbr/\u003e"}
//
// Stampa un vettore
//
$_1_["vedov"]=function(ve){
    var k,n,ss=[];
    if(!Array.isArray(ve)) return ve;
    n=ve.length;for(k=0;n>k;k++){
       if(Array.isArray(ve[k])){
          ss[k]=$_1_.vedov(ve[k])}
       else{ss[k]=ve[k];}}
    return "["+ss.join(", ")+"]";
    }
//
// Stampa le matrici come tabelle per cui l'ordine
// di una matrice non puo' essere molto grande.
// Matrici piccole sono spesso usate nel calcolo
// tensoriale.
//
$_1_["vedom"]=function(ma){
    var j,n,sm;
    var xtab="\u003ctable border='1' style="+
        "'display:inline-block;vertical-align:middle'\u003e";
    var ytab="\u003c/table\u003e";
    var xtr="\u003ctr\u003e",ytr="\u003c/tr\u003e";
    var xtd="\u003ctd\u003e",ytd="\u003c/td\u003e";
    if(!Array.isArray(ma)){return "("+ma+")"}
    n=ma.length;
    for(j=0;n>j;j++){if(!Array.isArray(ma[j])){
           return $_1_.vedov(ma);}
       if(ma[j].length!=n){return $_1_.vedov(ma);}}
    sm=xtab;
    for(j=0;n>j;j++)sm+=xtr+xtd+ma[j].join(ytd+xtd)+ytd+ytr;
    return sm+ytab;
    }
//
// Traspone la matrice assegnata e fatta tradizionalmente
// usando due indici.
//
$_1_["traspmat"]=function(ma){
    var j,k,mr=[],n=ma.length;
    for(j=0;n>j;j++){mr[j]=[[]];
       for(k=0;n>k;k++)mr[j][k]=ma[k][j];}
    return mr;}
//
// Moltiplica tra loro due matrici tradizionali.
//
$_1_["matmul"]=function(ma,mb){
    var j,h,k,n,mm,mr=[];
    n=Math.min(ma.length,ma.length);
    for(j=0;n>j;j++){mr[j]=[[]];
       for(h=0;n>h;h++){mm=0;
           for(k=0;n>k;k++)mm+=ma[j][k]*mb[k][h];
           mr[j][h]=mm;} }
    return mr;}
//
// Calcola l'inversa di una matrice di ordine
// non molto elevato perche' questo algoritmo
// e' semplice ma piuttosto costoso:
//
$_1_["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;}
//
// Fa la combinazione lineare di due matrici tradizionali.
//
$_1_["mcomb"]=function(ca,ma,cb,mb){
     var j,k,md=[];
     var nd=Math.min(ma.length,mb.length);
     for(j=0;nd>j;j++){md[j]=[];
        for(k=0;nd>k;k++)md[j][k]=
          ca*ma[j][k]+cb*mb[j][k];}
     return md;}
//
// Fa la combinazione lineare di due vettori tradizionali
// senza dunque distinzione tra vettori covarianti e
// vettori controvarianti.
//
$_1_["vcomb"]=function(ca,va,cb,vb){
     var j,nd,vc=[];
     nd=Math.min(va.length,vb.length);
     for(j=0;nd>j;j++){
        vc[j]=ca*va[j]+cb*vb[j];}
     return vc;}
//
// Fa il prodotti di matrice per vettore entrambi
// tradizionali ( a due indici la matrice e con uno
// solo il vettore ).
//
$_1_["matvet"]=function(ma,ve){
     var j,k,vr=[],n=ma.length;
     for(j=0;n>j;j++){
       vr[j]=0;
       for(k=0;n>k;k++){
          vr[j]+=ma[j][k]*ve[k];}}
     return vr;}
//
// Fa il prodotto scalare di due vettori.
// In campo tensoriale uno dovrebbe essere 
// covariante e l'altro controvariante
// ossia uno premoltiplicato per un tensore metrico
// ma qui sono trattati in modo tradizionale.
//
$_1_["vetvet"]=function(vea,veb){
     var j,sca=0,n;
     n=Math.min(vea.length,veb.length);
     for(j=0;n>j;j++)sca+=vea[j]*veb[j];
     return sca;}
//
// Moltiplica le componenti del vettore per lo 
// scalare sc entrambi tradizionali.
//
$_1_["vesca"]=function(sc,ve){
     var j,vr=[],n=ve.length;
     for(j=0;n>j;j++)vr[j]=sc*ve[j];      
     return vr;}
// 
// Fa a caso un vettore
//
$_1_["vrandom"]=function(nor){
    var j,vr=[],n=Math.max(3,Math.round(nor));
    for(j=0;n>j;j++){
       vr[j]=Math.round(2000*Math.random())-1000;}
    return vr;
    }
// 
// Fa a caso una matrice
//
$_1_["mrandom"]=function(nor){
    var j,k,mr=[],n=Math.max(3,Math.round(nor));
    for(k=0;n>k;k++){mr[k]=[];for(j=0;n>j;j++){
       mr[k][j]=Math.round(2000*Math.random())-1000;}}
    return mr;
    }
// 
// Fa la somma dei valori assoluti di una matrice degli
// elementi diagonali e di tutti gli altri
//
$_1_["mabs"]=function(mt){
    var j,k,mab=0,dab=0,n=mt.length;
    for(k=0;n>k;k++){for(j=0;n>j;j++){
       if(k==j){dab+=Math.abs(mt[k][j])}
       else{mab+=Math.abs(mt[k][j])} } }
    return [dab,mab];
    }
//
function $fammi(nord){
   var vc,mc,mic,mid,asso,nd;
   nd=Math.min(10,Math.round(nord));
   nd=Math.max(nd,3);
   with($_1_){
     // Fa la matrice di ordine nd a caso:
     mc=mrandom(nd);
     postMessage([$calcolo,"Ha creato la matrice di "+
       "ordine "+nd+" Ci mette tanto a fare l'inversa !"]);
     mic=fainv(mc);
     mid=matmul(mc,mic);
     asso=mabs(mid);}
   return [0,") Ordine",nd,") Sommatoria I diag. ",asso[0],
           ") Sommatoria I non diag. "+asso[1]];
   }
//
function ContaPassi() {
    var calcolo;
    if(1>$ricevuto){
       setTimeout("ContaPassi()",$attesa);}
    else{$attesa=4000;
    calcolo=$fammi($ricevuto);
    calcolo[0]=$calcolo;
    $calcolo++;
    postMessage(calcolo);
    setTimeout("ContaPassi()",$attesa);}}
//
ContaPassi(); 
//