Meno male che funziona

Beh per n==1, se non erro il determinante coincide con l'unico elemento della matrice (non ho controllato perō).
codice:
if (size==1) printf("Determinante: %d", ma[0][0]);
mentre per 2<=n<=3 parte la funzione Sarrus (dall'omonimo Matematico)
e implementa nel caso di n=2 la differenza dei prodotti tra gli elementi delle 2 diagonali Aij = {a11, a12, a21, a22}
quindi det = (a11*a22)-(a12*a21).
codice:
for (int i=0; i<(ter==2 ? 1 : ter); i++){
//(ter==2 ? 1 : ter) controlla se la dimensione della matrice
//č uguale a 2. In quel caso basta ciclare una sola volta 
//(cioé non ciclare affatto)  
		for (int j=0; j<ter; j++)
			{
                         // questo printf me lo sono dimenticato, toglilo
			//printf("%d %d\n", j, j+i<ter ? j+i : j+i-ter);
			diaBack *= s[j][j+i<ter ? j+i : j+i-ter];
			diaForward *= s[j][ter-j-1-i>=0 ? ter-j-1-i : 2*ter-j-i-1];
		}
		det+=diaBack-diaForward;
		diaForward = diaBack = 1;
}
per n==3
diaBack calcola la somma dei prodotti delle diagonali con la cima indietro (tipo backslash) mentre diaForward calcola la somma dei prodotti delle diagonali in avanti (tipo forwardslash).
la differenza di diaBack e diaForward da il determinante per matrici 3x3

n>3

In questo caso si utilizza il metodo di laplace. Do per scontato che tu lo sappia (metto un link sotto cmq).


la funzione prende 2 parametri, ord č la dimensione della matrice v, e v č la matrice che passiamo a laplace(). Siccome il metodo di laplace prevede di escludere dalla matrice originale una riga (la prima nel nostro caso) la funzione costruisce ogni volta una sotto matrice di un ordine inferiore rispetto alla precedente, fino ad arrivare a una matrice 3x3. Quindi avendo una matrice 4x4 la funzione esclude la prima riga e costruisce 4 sotto matrici una per ogni elemento della prima riga. Le sotomatrici sono costruite escludendo la colonna a cui appartiene l'elemento della prima riga (dal link si capisce meglio: Link - determinante) Quindi si va a calcolare il determinante delle sottomatrici se queste hanno dimensione 3, mentre si ripete il procedimento precedente se hanno dimensione maggiore di 3. Una volta arrivati a dimensione 3 Sarrus() calcola il determinante per ogni sottomatrice e lo restituisce a laplace (metodo ricorsivo). il determinante viene moltiplicato con il valore dell'elemento che appartiene alla prima riga (quella esclusa) e ogni prodotto viene sommato. La somma da il determinante della matrice.


quindi il primo ciclo (quello con "z") scandisce le colonne da escludere mentre gli altri 2 cicli nidificati (con "i" e "j") leggono la matrice passata alla funzione e prendono i valori da immettere nella nuova sottomatrice z-esima

codice:
int laplace(int ord, int **v)//ord == dimensione di v
	{
			int i, j, z, k=0;
			int det=0;
			int **p; // dichiaro un puntatore ad un array bidimensionale

			int dim_p;

			// dimensione delle sottomatrici
			dim_p = ord-1;
 

	p = (int **)malloc(dim_p*sizeof(int)); // alloco la memoria 
	for (i=0; i<dim_p; i++)
	*(p+i) = (int *)malloc(dim_p*sizeof(int));



for (z=0; z<=dim_p; z++)
	{
	/**********************/
	//creo le sottomatrici
	for (i=1; i<=dim_p; i++)
	{
		for (j=0; j<=dim_p; j++)
		{
		if (j==z) k=1;
		else p[i-1][j-k] = v[i][j];
		}
	k=0;
	}
	/********************************/
	
	// richiamo ricorsivamente la funzione laplace() e per ultima Sarrus()
	if (dim_p>3)
		det+=(int)pow(-1, z+2)*v[0][z]*laplace(dim_p, p);
	else det+=(int)pow(-1, z+2)*v[0][z]*Sarrus(p,3); 
}
	return det;
}
Dimmi se c'č altro che non ti č chiaro, il che puō essere dato che non mi sono spiegato proprio bene