[C] Risoluzione sistemi lineari

[_mr_]

Ciao a tutti,
settimana scorsa la nostra prof. di matematica ci ha lanciato una "sfida" per vedere se qualcuno fosse stato in grado di scrivere un programma per la risoluzione dei sistemi lineari...ovviamente ai miei compagni di classe non gliene frega niente, ma a me sì, e quindi ho deciso di provare a farlo in C (è la prima volta che programmo in C, ma non sono nuovo alla programmazione)...
Ok, andando oltre la premessa, oggi ho terminato il programma e sono passato alla compilazione, e, ahimè (ma me lo aspettavo), gcc mi ha trovato un bel po' di errori...purtroppo però, essendo nuovo al C, non riesco a correggerli tutti da solo
Per cui, se vi posto qui il codice e gli errori che mi da, mi dareste una mano a risolverne qualcuno??
Grazie mille
Ciao
Matteo

[_mr_]

Beh dai, intanto posto qua tutto

Codice (evidenzio le righe dove mi da errore):

#include <stdio.h>

int orlato(int mA[][], int mB[][], int a);
int determinante(int m[][], int a);
int triangolare(int m[][], int a, int b);
int soluzione(int m[][], int a, int b);

int main (void)
{
	printf("Inserisci il numero delle variabili"); 
	int n;
	scanf("%d \n", &n); //leggo il numero delle equazioni e delle variabili
	printf("Inserisci i %d coefficienti delle variabili in ordine \n", n*n);
	int matriceA[n][n];
	int i;
	int k;
	for(i=0;i=(n-1);i++) //ciclo per le righe
	{
		for(k=0;k=(n-1);k++) //ciclo per le colonne
		{
			scanf("%d", &matriceA[i][k]); //memorizzo i coefficienti delle variabili
			printf("%dx(%d) \t", &matriceA[i][k], &k); //stampo la matrice
		}
	printf("\t <-linea %d \n", i);
	}
	printf("Inserisci i %d termini noti \n", n);
	int matriceB[n][1];
	for(i=0;i=n-1;i++) //ciclo per le righe, la colonna è 1 quindi non mi serve un secondo ciclo
	{
		scanf("%d", &matriceB[i][1]); //memorizzo i termini noti
		printf("%d \n", &matriceB[i][1]); //stampo la matrice
	}
	int mAB[n][n+1] = orlato(matriceA[][], matriceB[][], n); //genero la matrice completa 
	int matr_triang = triangolare(mAB[][], n, n+1); //genero la matrice triangolare
	int DETA = determinante(matriceA[][], n); //calcolo il determinante
	if(DETA == 0) //se il determinante è uguale a 0 il sistema è indeterminato
	{
		printf("\nSistema indeterminato o impossibile \n");
	} else { //altrimenti è determinato
		printf("\nSistema determinato \n");
		int sol[1][n] = soluzione(matr_triang[][], n, n+1); //calcoli per soluzione
		for(k=0;k=(n-1);k++)
		{
			printf("x(%d)=%d \n", &k, &sol[1][k]); //stampo la soluzione
		}
	}
}

int orlato(int mA[][], int mB[][], int a) //funzione per generare la matrice orlata
{
	int temp[a][a+1]; //inizializzo la matrice temporanea
	int i; //inizializzo il contatore
	int k; //inizializzo un altro contatore
	for(i=0;i=(a-1);i++) //ciclo per le righe della matrice
	{
		for(k=0;k=(a-1);k++) //ciclo per le colonne della matrice
		{
			temp[i][k]=mA[i][k]; //copio la matrice A nella matrice temp
		}
	}
	for(i=0;i=(a-1);i++) //ciclo per le righe, la colonna è una sola
	{
		temp[i][a]=mB[i][1]; //aggiungo come ultima colonna quella della matrice B
	}
	return (temp[][]); //ritorno la nuova matrice
}


int determinante(int m[][], int a) //funzione per calcolare il determinante
{
	int i; //contatore per il ciclo
	int DET=1; //inizializzo la variabile DET uguale a 1, altrimenti mi restituirebbe sempre 0
	for(i=0;i=(a-1);i++) //ciclo
	{
		DET=DET*m[i][i]; //il determinante di una matrice triangolare è uguale al prodotto degli elementi sulla diagonale principale
	}
	return(DET);

}


int triangolare(int m[][], int a, int b) //funzione per generare la matrice triangolare
{
	int temp[a][b]; //variabile temporanea per la nuova matrice
	int k; //contatore per le colonne
	int i; //contatore per le righe
	int j; //contatore che indica qual è la riga principale per cui vanno moltiplicate le altre
	for(j=0;j=(a-2);j++) //la riga principale varia dalla prima all'ultima
	{
		for(i=(j+1);i=(a-1);i++) //le righe variano da quella sotto la principale all'ultima
		{
			for(k=j;k=(b-1);k++) //le colonne variano dal contatore corrispondente alla riga principale, fino all'ultima colonna
			{
				temp[1][k]=m[1][k];
				temp[i][k]=m[i][k]*m[j][j]-m[j][k]*m[i][j]; //moltiplico il coefficiente che sto considerando per il primo coefficiente della riga principale e sottraggo il valore corrispondente nella riga principale moltiplicato per il primo coefficiente della riga che sto considerando
			}
		}
	}
	return (temp[][]); //ritorno la matrice triangolare
}

int soluzione(int m[][], int a, int b)
{
	int i; //dichiaro contatore
	int k; //dichiaro contatore
	int temp[a+1][1]; //dichiaro matrice soluzioni, mi serve una riga in più perchè l'ultima resterà vuota
	for(i=2;i=a;i++) //ciclo per individuare l'elemento, parto dall'ultima riga
	{
		k=2; //k è il contatore che mi serve per fare sottrarre dall'equazione le incognite che ho già calcolato
		temp[a-i][1] = m[a-i][a-1]; //inizio col porre l'incognita uguale al termine noto
		while(k<i)
		{
			temp[a-i][1] = temp[a-i][1] - temp[a-k][1]; //ad ogni ciclo sottraggo una delle restanti incognite già calcolate
			k++; //e aumento di 1 il valore di k
		}
		temp[a-i][1] = temp[a-i][1]/m[a-i][a-i-1]; //alla fine divido per il coefficiente dell'incognita che sto calcolando
	}
	return(temp[][]);
}

errori (in pratica ne ho uno ogni volta che dichiaro o uso una mia funzione):

sistemi_lineari.c:3: error: array type has incomplete element type
sistemi_lineari.c:3: error: array type has incomplete element type
sistemi_lineari.c:4: error: array type has incomplete element type
sistemi_lineari.c:5: error: array type has incomplete element type
sistemi_lineari.c:6: error: array type has incomplete element type
sistemi_lineari.c: In function ‘main’:
sistemi_lineari.c:33: error: variable-sized object may not be initialized
sistemi_lineari.c:33: error: syntax error before ‘]’ token
sistemi_lineari.c:34: error: syntax error before ‘]’ token
sistemi_lineari.c:35: error: syntax error before ‘]’ token
sistemi_lineari.c:41: error: variable-sized object may not be initialized
sistemi_lineari.c:41: error: syntax error before ‘]’ token
sistemi_lineari.c: At top level:
sistemi_lineari.c:49: error: array type has incomplete element type
sistemi_lineari.c:49: error: array type has incomplete element type
sistemi_lineari.c: In function ‘orlato’:
sistemi_lineari.c:65: error: syntax error before ‘]’ token
sistemi_lineari.c: At top level:
sistemi_lineari.c:69: error: array type has incomplete element type
sistemi_lineari.c: In function ‘determinante’:
sistemi_lineari.c: At top level:
sistemi_lineari.c:82: error: array type has incomplete element type
sistemi_lineari.c: In function ‘triangolare’:
sistemi_lineari.c:99: error: syntax error before ‘]’ token
sistemi_lineari.c: At top level:
sistemi_lineari.c:102: error: array type has incomplete element type
sistemi_lineari.c: In function ‘soluzione’:
sistemi_lineari.c:118: error: syntax error before ‘]’ token

e poi mi da anche dei warning tipo questo ogni vota che c'è un for:

sistemi_lineari.c:17: warning: suggest parentheses around assignment used as truth value

Questo quando faccio un printf:

sistemi_lineari.c:22: warning: format ‘%d’ expects type ‘int’, but argument 2 has type ‘int *’

Oppure questo alla fine di ogni funzione:

sistemi_lineari.c:47: warning: control reaches end of non-void function

[DanieleC88]

sistemi_lineari.c:3: error: array type has incomplete element type

Non puoi definire matrici bidimensionali se non rendi nota al compilatore la "larghezza"... se non sai da subito quanto dovrà essere grande una "tabella" simile, usa dei puntatori e alloca la memoria dinamicamente. Ci vuole un po' più di sbattimento, ma è l'unico modo versatile.

Correggi quello, gli errori dovrebbero ridursi drasticamente.

[dierre]

Ha detto tutto DanieleC88. Una volta corretta la dichiarazione delle matrici riposta gli errori che ti escono così ti aiutiamo anche con quelli.

[_mr_]

Originariamente inviato da dierre

Ha detto tutto DanieleC88. Una volta corretta la dichiarazione delle matrici riposta gli errori che ti escono così ti aiutiamo anche con quelli.

ok, il problema è che...non ho capito proprio benebenebene quale possa essere la soluzione...xkè il fatto è che, quanto sarà grande la matrice lo so solo dopo che l'utente me lo dice...cmq ora vado a spulciarmi un po' di guide per capire meglio come faccio ad allocare la memoria dinamicamente...

Grazie mille
Ciao
Matteo

[DanieleC88]

Originariamente inviato da _mr_

xkè il fatto è che, quanto sarà grande la matrice lo so solo dopo che l'utente me lo dice...

Esatto, usa funzioni come malloc() (o calloc(), se ti risulta più comoda) per allocare la memoria, seguite ovviamente da opportuni free() finali per liberarla, una volta che questa non è più necessaria.

Se usi Linux, consulta il manuale (dai un "man 3 malloc") e troverai tutte le spiegazioni del caso.

[_mr_]

Originariamente inviato da DanieleC88

Esatto, usa funzioni come malloc() (o calloc(), se ti risulta più comoda) per allocare la memoria, seguite ovviamente da opportuni free() finali per liberarla, una volta che questa non è più necessaria.

Se usi Linux, consulta il manuale (dai un "man 3 malloc") e troverai tutte le spiegazioni del caso.

uso mac (magari c'è lo stesso, essendo unix...)...cmq sto dando un'occhiata alla guida proposta da html.it, che è fatta abbastanza bene, però su questa parte non è che chiarisca molto le idee...ora vedo se trovo qualcos'altro con cui riuscire a capire meglio

Grazie
Ciao
Matteo

[DanieleC88]

Originariamente inviato da _mr_

però su questa parte non è che chiarisca molto le idee...ora vedo se trovo qualcos'altro con cui riuscire a capire meglio

Non c'è molto da capire in effetti, devi solo sapere a grandi linee come funzionano la memoria e quelle strutture dati che ti interessano. Nel tuo caso, devi avere una matrice bidimensionale di interi: pensala come una tabella, hai un certo numero di colonne e di righe. Ora, ogni casella che ti interessa deve essere in grado di conservare un intero, quindi ogni cella riservata per i singoli interi deve avere una grandezza di sizeof(int) byte. Il procedimento per creare una tabella di questo tipo con r righe e c colonne è una cosa di questo tipo:

int **matrice;
int x;

matrice = (int **) malloc(c * sizeof(int *));
for (x = 0; x < r; x++)
  matrice[x] = (int *) malloc(r * sizeof(int));

In questo modo riservi abbastanza memoria per un vettore di puntatori, ognuno dei quali punterà alla prima delle r locazioni contigue di memoria che conterranno gli interi di una riga.
Lo so che così come l'ho detto non si capisce un granché, ma mi ci vorrebbe un disegnino, e poi vado un po' di fretta.

[DanieleC88]

Ah già, ricorda: alla fine di tutto dovrai pulire ogni zona di memoria precedentemente allocata con malloc() usando free(), quindi farai più o meno l'inverso:

while (r-- > 0)
  free(matrice[r]);
free(matrice);

ciao

[_mr_]

Originariamente inviato da DanieleC88

Non c'è molto da capire in effetti, devi solo sapere a grandi linee come funzionano la memoria e quelle strutture dati che ti interessano. Nel tuo caso, devi avere una matrice bidimensionale di interi: pensala come una tabella, hai un certo numero di colonne e di righe. Ora, ogni casella che ti interessa deve essere in grado di conservare un intero, quindi ogni cella riservata per i singoli interi deve avere una grandezza di sizeof(int) byte. Il procedimento per creare una tabella di questo tipo con r righe e c colonne è una cosa di questo tipo:

int **matrice;
int x;

matrice = (int **) malloc(c * sizeof(int *));
for (x = 0; x < r; x++)
  matrice[x] = (int *) malloc(r * sizeof(int));

In questo modo riservi abbastanza memoria per un vettore di puntatori, ognuno dei quali punterà alla prima delle r locazioni contigue di memoria che conterranno gli interi di una riga.
Lo so che così come l'ho detto non si capisce un granché, ma mi ci vorrebbe un disegnino, e poi vado un po' di fretta.

si, pian piano ci sto arrivando....magari domani che avrò la mente un po' più fresca sarà più facile....intanto ti chiedo già una cosa (non preoccuparti che non ho fretta, tanto adesso vado a dormire):
l'errore lui me lo da sulle dichiarazioni dei prototipi delle funzioni, però, se ho capito bene, io l'allocazione dinamica della memoria dovrei farla all'interno della funzione, per poi liberarla dopo che la funzione mi ha ritornato quello che mi serve...è giusto il ragionamento??

Ciao
Grazie

[DanieleC88]

Originariamente inviato da _mr_

io l'allocazione dinamica della memoria dovrei farla all'interno della funzione, per poi liberarla dopo che la funzione mi ha ritornato quello che mi serve...è giusto il ragionamento??

Non proprio, se sono dati che devi usare durante tutto il programma (questo mi sembra il caso) li allochi e deallochi solo una volta, nel main, rispettivamente, prima e dopo aver fatto il lavoro sporco. Per le funzioni invece, puoi dare per assunto che al momento della chiamata tali dati siano già disponibili in memoria, allocati e pronti per l'uso, quindi basta che tu sostituisca gli int[][] con degli int** (hanno sostanzialmente lo stesso utilizzo, al tuo programma interessa solo avere l'indirizzo al quale inizia quella matrice). Nel corpo delle funzioni poi potrai usarle come fossero delle qualsiasi matrici, badando però ad usare gli indici giusti (ovviamente se hai una riga con cinque elementi e provi a leggerne l'ottavo ti esplode tutto).

[DanieleC88]

Originariamente inviato da _mr_

(non preoccuparti che non ho fretta, tanto adesso vado a dormire)

Peccato, hai perso la tua occasione, starò via due o tre giorni e non so se potrò connettermi.

ciao

[dierre]

Ho trovato una spiegazione che ti potrebbe aiutare. Daniele ha già detto tutto però ho trovato proprio un listato. P.S.: non far caso ai nomi delle funzioni built-in che usa, sono specifiche per VS.

http://support.microsoft.com/?scid=k...4639&x=10&y=12

[DanieleC88]

Originariamente inviato da dierre

Ho trovato una spiegazione che ti potrebbe aiutare. Daniele ha già detto tutto però ho trovato proprio un listato. P.S.: non far caso ai nomi delle funzioni built-in che usa, sono specifiche per VS.

http://support.microsoft.com/?scid=k...4639&x=10&y=12

Qui ci leggo anche:

array = (char (*)[columns]) malloc(sizeof(char) * rows * columns);

Fai attenzione però, non è detto che questo vada senza problemi con GCC, che mi sembra non consensta un cast ad un'array, cosa che da quel che vedo il compilatore Microsoft consente.
Se non altro c'è il disegnino che intendevo fare io!

[dierre]

sì ma la dichiarazione è giusta la tua, però c'era lo schemino più come si usa. Era da integrare al tuo

[mjordan]

Mi stava venendo in mente una finezza assurda ma poi ho pensato che sarebbe stata inutile oltre che una sboronata... usare il metodo di Fourier-Motzkin ...

[DanieleC88]

Originariamente inviato da mjordan

Mi stava venendo in mente una finezza assurda ma poi ho pensato che sarebbe stata inutile oltre che una sboronata... usare il metodo di Fourier-Motzkin ...

Ovverosia? Ora sono curioso!

[_mr_]

Originariamente inviato da DanieleC88

Peccato, hai perso la tua occasione, starò via due o tre giorni e non so se potrò connettermi.

ciao

doh ...e va beh, io intanto ci provo...adesso con la mente più fresca sono più in grado di ragionare...mal che vada mi faccio dare una mano da mia madre che ne sa più di me...

Ciao
Grazie
Matteo

[DanieleC88]

Ho scoperto che, sì, posso connettermi.

Ovviamente, però, se ti sforzi per risolvere da solo il problema poi probabilmente lo capirai meglio. Se hai difficoltà ti aiutiamo.

[71104]

<OT, scusate>

Originariamente inviato da DanieleC88

Ho scoperto che, sì, posso connettermi.

Ovviamente, però, se ti sforzi per risolvere da solo il problema poi probabilmente lo capirai meglio. Se hai difficoltà ti aiutiamo.

Danièèèèèè
e insomma ti puoi connettere

PS: quella firma è mia se non erro