Newsgroup: it.comp.lang.c
Titolo: Matrix

Salve ragazzi!
Inutile dire che sono alle prime armi...
Sto scrivendo un programma che mi calcoli il determinante di una matrice
di un numero di righe=colonne arbitrario che va da 1 a 80 elementi.
Lo sto facendo con il metodo di Laplace!
Per fare questo ho dichiarato un array bidimensionale e sono arrivato ad un
punto in cui passo l'array ad una funzione:
laplace(int *p, int i)
{
int d, g;
if(i > 2){
int cp[i-1][i-1];
   for(d = 0; d < i - 1; d++)
      for(g = 0; g < i - 1; g++){
             cp[d][g] = *p++;
}
          lapla2(cp);
}
Vorrei copiare gli elementi della matrice passata come parametro nel nuovo
array!
Mi chiedevo se si potesse fare una cosa simile dato che l'array è
bidimensionale!
Quando incremento *p che punta all'indirizzo del primo elemento dell'array,
viene incrementato nell'ordine che desidero?
Cioè, incrementa la 1° riga è poi tutte le colonne, la 2° riga e tutte le
colonne...e così via?
O devo usare qualche scrittura particolare!
Grazie dell'aiuto! 

 Lo sto facendo con il metodo di Laplace!
Solo per farti presente che esistono metodi per il calcolo del 
determinante enormemente piu' efficienti rispetto alla regola di Laplace.
Questi metodi oltre che piu' efficienti sono molto piu' semplici da 
implementare e non sono neanche ricorsivi , come e' la regola di Laplace.
Un possibile algoritmo si basa sulla diagonalizzazione di Gauss-Jordan e 
  sul successivo prodotto dei termini sulla diagonale principale.
per un primo riferimento c'e' questo 'libro' :
"Numerical Recipes in C"
http://www.library.cornell.edu/nr/cbookcpdf.html


ciao, tempo fa avevo fatto una funzione simile, però con una 
matrice "flat" (array nxn). ecco il codice: lavora con 
matrici di interi ed è inefficiente, ma magari ti può aiutare:
-------------------------
#define DEPTH 2
#define M(N,r,c) ( m[N*r+c] )
int laplace_det(int *m, int rows) {
    int det=0;
    int i,j;
    int *submatrix;
    if (rows==2) {
       return ( M(2,0,0)*M(2,1,1) - M(2,0,1)*M(2,1,0) );
    }
#if DEPTH==3
    else if (rows==3) {
       return ( M(3,0,0)*M(3,1,1)*M(3,2,2) -
                M(3,0,0)*M(3,1,2)*M(3,2,1) -
                M(3,0,1)*M(3,1,0)*M(3,2,2) +
                M(3,0,1)*M(3,1,2)*M(3,2,0) +
                M(3,0,2)*M(3,1,0)*M(3,2,1) -
                M(3,0,2)*M(3,1,1)*M(3,2,0)
              );
    }
#endif
    else {
       //il numero di sottomatrici è pari al numero di righe 
(o colonne)
       for(i=0;i<rows;i++) {
          //alloca la sottomatrice di dimensioni 
(rows-1)*(rows-1)
          submatrix=(int*)malloc((rows-1)*(rows-1)*sizeof(int));
          //imposta i valori della sottomatrice
          for(j=0;j<rows-1;j++) {
             if (j>=i)
                memmove( submatrix+(rows-1)*j, 
m+(rows*(j+1))+1, (rows-1)*sizeof(int) );
             else
                memmove( submatrix+(rows-1)*j, m+(rows*j)+1, 
(rows-1)*sizeof(int) );
          }
          //passo della formula di Laplace
          det += (M(rows,i,0) * pow(-1,i) * 
(laplace_det(submatrix,rows-1)));
          //dealloca la sottomatrice
          free(submatrix);
       }
    }
    return det;
}
-------------------------
ciao.

> Lo sto facendo con il metodo di Laplace!
E' un metodo applicabile solo a matrici molto piccole.
Tieni conto che il numero di operazioni e' grosso modo proporzioale
a n! (n fattoriale).
Quindi per calcolare il determinante di una matrice oggettivamente
piccola, tipo 50x50 ci puoi mettere tranquillamente un tempo
comparabile con l'eta' dell'universo... visto che
50! = 30414093201713378043612608166064768844377641568960512000000000000
cercati con google o su un libro il metodo di eliminazione di
gauss con pivot. Lo trovi sicuramente gia' implementato in tutte
le salse (non che ci voglia molto...)
ciao,
v.

mmm wrote:

Oh!
Grazie mille!
Mi servirą sicuramente per l'esame di geometria!

 Mi servirà sicuramente per l'esame di geometria!
Se ti posso consigliare cerca il libro "Elemetary linear algebra" di
Howard Anton. Oltre a parlare di algebra lineare e geometria parla
anche di algoritmi per l'algebra lineare. E' molto ben fatto.

 anche di algoritmi per l'algebra lineare. E' molto ben fatto.
Si grazie!