Newsgroup: it.comp.lang.c
Titolo: Matrice quadrata nxn

Qualcuno può aiutarmi a creare un programma che calcoli il valore di una
matrice quadrata?? Non ho nessuna idea su come impostarlo... Una volta
chiesto l'ordine della matrice (quindi n righe x n colonne) non so più come
moltiplicare la colonna presa x la matrice di ordine inferiore sion ad
arrivare a quella di ordine 3 . Grazie 1000


Se mi spiegi cosa diavolo vuoi dire con:
 > moltiplicare la colonna presa x la matrice di ordine inferiore sion ad
 > arrivare a quella di ordine 3
allora posso anche cercare di aiutarti.
Inoltre cosa intendi con "il valore di una matrice quadrata" ??
Cosa stai cercando di calcolare ?
g.

"Giovanni Resta" <g.r...@iit.cnr.it.nospam> ha scritto nel messaggio
news:3E637E42...@iit.cnr.it.nospam...

Scusa se non sono stato chiaro .  Il mio problema è quello di creare un
programma che chiede l'ordine di una matrice quadrata(da cui deriva il
numero di termini di indici da immettere a11 a12 a13 ...) chiede appunto
tutti gli indici e calcoli poi il determinante della matrice .

 tutti gli indici e calcoli poi il determinante della matrice .
Lo avevo immaginato....
Pero' mi sembra che tu volessi implementare una calcolo
del determinante ricorsivo
(espansione rispetto ad una riga, etc.etc.)
che e' assolutamente da evitare se la matrice e' grande,
perche' ha un tempo che per matrici piene e' dell'ordine di n!
cioe' e' esponenziale rispetto a n.
Ti conviene implementare il calcolo del determinante
mediante fattorizzazione LU (con pivot), per il quale
il numero di operazioni e' dell'ordine di n^3.
Questo si ottiene col metodo di Gauss, che non sto
qui a riportare perche' trovi con google migliaia
di link e non e' affatto complicato.
Se poi questo e' un esercizio di programmazione e non
un problema serio (e quindi magari tu devi proprio implementare
l'algoritmo ricorsivo per il determinante),
allora il problema e' comunque abbastanza facile.
Puoi fare cosi': (soluzione assolutamente non efficiente,
da migliorare)
la matrice puo' essere ad esempio un
double **M;
(e poi la allochi dinamicamente: in pratica e' un array di puntatori ad
array).
supponiamo che la dimensione massima della matricesia NMAX
se consideri un array di interi C[] di dimensione massima NMAX,
puoi assumere che essi specifichino una sottomatrice di M,
dove C[0],C[1],..., sono le colonne e le righe sono quelle dalla k-esima
in giu' dove k e' un numero specificato/
Allora il determinante lo otterrai invocando la funzione
double Det(M,C,k,n)
dove n e' la dimensione e k il passo ricorsivo dell'algoritmo.
(all'inizio lo metti a 0 perche' stai considerando tutte le righe)
come e' fatta Det ?
cosi'
double Det(double **M, int *C, int k, int n)
{
   int MyC[NMAX]; /* questa e' la copie di C che
                                passerai ricorsivamente */
   double segno=1.0; /* il segno da attribuire ai vari termini */
   qui metti un bell' if (n==2) o (n==3) e in quel
    caso ti vai a calcolare direttamente il determinante
e lo restituisci.
   Se cosi' non e' comincia la ricorsione:
   le righe sono tutte forche' la prima (quindi aumenti k)
   e le colonne le elimini una a turno.
   quindi:
acc=0.0; /* mantiene il valore calcolato */
    for (j=0; j<n-k; j++) /* cicla sulle colonne attuali che sono n-k */
   {
     qui copi i numeri da C[] a MyC[] che specificano le
     colonne, eliminando pero' la j-esima (non l'indice j, attenzione, ma
     il valore contenuto in C[j]. In questo modo ottieni un vettore
     MyC[] che contiene n-1 elementi.
     qui calcoli il determinante della sottomatrice, con il
segno opportuno e lo accumuli
     acc  +=  segno * Det(M,MyC,k+1,n-1);
    // k+1 perche' sto scendendo di una riga rispetto a M
    // n-1 perche' la chiamata ricorsiva lavora su una sottomatrice
     segno = -1 * segno; // inverti il segno
   }
alla fine un bel return acc;
e hai finito.
Questa piu' o meno e' l'idea, salvo errori dovuti alla fretta. Comunque
pensaci su, e se il tuo problema e' reale, cerca con google il metodo di 
Gauss.
ciao,
g.
costruiamo una

"Giovanni Resta" <g.r...@iit.cnr.it.nospam> ha scritto nel messaggio
news:3E638D41...@iit.cnr.it.nospam...

Grazie 1000 adesso ci studio un po' sopra nel caso ti  chiederò ancora un
po' di aiuto ciao

 poi il determinante della matrice .
Per calcolare il determinante il metodo più semplice è quello di Gauss:
effettui la riduzione della matrice in modo che tutti gli elementi, esclusi
quelli della diagonale principale, siano zero. Il determinante è dato dal
prodotto degli elementi della diagonale principale.
L'alternativa, con il metodo che suggerisci tu, è un po' più complicato e
lungo (da spiegare). Ti suggerisco soltanto di scambiare la riga, in cui si
trova l'elemento della colonna che devi moltiplicare per il rispettivo
minore, con la prima riga (così gli elementi del minore stanno sempre
raggruppati). Al termine del prodotto, ovviamente, scambi di nuovo le due
righe. La funzione che effettua il calcolo del determinante dovrà essere
ricorsiva.
Maurizio.

 cioe' e' esponenziale rispetto a n.
           ^^^^^^^^^^^^
Volevi dire "fattoriale", vero? ;-)
-- 
 Ciao, Bianco.                         Reply to luca.bianco (at) 
tiscali.it
|--------[Powered by Debian GNU/Linux Sarge - 2.4.19 - AMD K6-200]--------|
|------------[Linux Registered User #287769 - Machine #169192]------------|

 
No, volevo dire esattamente quello che ho detto.
L'ordine di grandezza di n fattoriale e' in informatica e' chiamato
spesso genericamente esponenziale (in contrapposizione a polinomiale),
perche' asintoticamente n! e' uguale ad una costante che moltiplica
e^(-n)*n^(n+1/2) (formula di Stirling)
Quindi, in un certo senso e' anche maggiore di qualunque
esponenziale del tipo c^n dove c e' una costante.
Ma visto il contesto non mi sembrava il caso di sottilizzare.
ciao
g.