[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]; //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
}
}
}
[B] 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_]

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]

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_]

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]

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. :D

[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_]

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. :D

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]

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]

(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. :Prrr:

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=kb%3Ben-us%3B104639&x=10&y=12

[DanieleC88]

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=kb%3Ben-us%3B104639&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! :D

[dierre]

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

[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 ... :doh:

[DanieleC88]

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 ... :doh:
Ovverosia? Ora sono curioso! :D

[_mr_]

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

ciao ;)

doh :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. :D

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

[71104]

<OT, scusate>



Ho scoperto che, sì, posso connettermi. :D

Ovviamente, però, se ti sforzi per risolvere da solo il problema poi probabilmente lo capirai meglio. Se hai difficoltà ti aiutiamo. :)
Danièèèèèè :D :D
e insomma ti puoi connettere :D :D

PS: quella firma è mia se non erro :asd:

[DanieleC88]

Danièèèèèè :D :D
e insomma ti puoi connettere :D :D
Weeee! :D
Sì, più o meno. :D
PS: quella firma è mia se non erro :asd:
No, l'avevo coniata io e poi l'avevi adottata pure tu. :D

ciao ;)

[_mr_]

ehilà, allora, ho provato a fare tutto per mezzo dei puntatori, per cui, ho dichiarato dei puntatori globali prima del main, ho poi ho fatto in modo che le funzioni lavorassero direttamente su quelli, senza dover ritornare niente...quindi ora il programma è diventato così

#include <stdio.h>

orlato(int **mA, int **mB, int a);
int determinante(int **m, int a);
triangolare(int **m, int a, int b);
soluzione(int **m, int a, int b);
int **mAB;
int **matr_triang;
int **sol;

int main ()
{
printf("Inserisci il numero delle variabili\n");
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);
n = (int)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("x(%d) +\t", k+1); //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][0]); //memorizzo i termini noti
printf("%d \n", matriceB[i][0]); //stampo la matrice
}
orlato(&matriceA, &matriceB, n); //genero la matrice completa
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");
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
}
}
return 0;
}

orlato(int **mA, int **mB, int a) //funzione per generare la matrice orlata
{
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
{
mAB[i][k]=mA[i][k]; //copio la matrice A nella matrice mAB
}
}
for(i=0;i=(a-1);i++) //ciclo per le righe, la colonna è una sola
{
mAB[i][a]=mB[i][0]; //aggiungo come ultima colonna quella della matrice B
}
}


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);

}


triangolare(int **m, int a, int b) //funzione per generare la matrice triangolare
{
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
{
matr_triang[0][k]=m[0][k];
matr_triang[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
}
}
}
}

soluzione(int **m, int a, int b)
{
int i; //dichiaro contatore
int k; //dichiaro contatore
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
sol[a-i][0] = m[a-i][a-1]; //inizio col porre l'incognita uguale al termine noto
while(k<i)
{
sol[a-i][0] -= sol[a-k][0]; //ad ogni ciclo sottraggo una delle restanti incognite già calcolate
k++; //e aumento di 1 il valore di k
}
sol[a-i][0] /= m[a-i][a-i-1]; //alla fine divido per il coefficiente dell'incognita che sto calcolando
}
}

sono pure riuscito a compilarlo, anche se ancora ho dei warning che non mi sono molto chiari...però va beh
sistemi_lineari.c:3: warning: type defaults to ‘int’ in declaration of ‘orlato’
sistemi_lineari.c:3: warning: data definition has no type or storage class
sistemi_lineari.c:5: warning: type defaults to ‘int’ in declaration of ‘triangolare’
sistemi_lineari.c:5: warning: data definition has no type or storage class
sistemi_lineari.c:6: warning: type defaults to ‘int’ in declaration of ‘soluzione’
sistemi_lineari.c:6: warning: data definition has no type or storage class
sistemi_lineari.c: In function ‘main’:
sistemi_lineari.c:21: warning: suggest parentheses around assignment used as truth value
sistemi_lineari.c:23: warning: suggest parentheses around assignment used as truth value
sistemi_lineari.c:32: warning: suggest parentheses around assignment used as truth value
sistemi_lineari.c:37: warning: passing argument 1 of ‘orlato’ from incompatible pointer type
sistemi_lineari.c:37: warning: passing argument 2 of ‘orlato’ from incompatible pointer type
sistemi_lineari.c:38: warning: passing argument 1 of ‘triangolare’ from incompatible pointer type
sistemi_lineari.c:39: warning: passing argument 1 of ‘determinante’ from incompatible pointer type
sistemi_lineari.c:45: warning: passing argument 1 of ‘soluzione’ from incompatible pointer type
sistemi_lineari.c:46: warning: suggest parentheses around assignment used as truth value
sistemi_lineari.c: At top level:
sistemi_lineari.c:55: warning: return type defaults to ‘int’
sistemi_lineari.c: In function ‘orlato’:
sistemi_lineari.c:58: warning: suggest parentheses around assignment used as truth value
sistemi_lineari.c:60: warning: suggest parentheses around assignment used as truth value
sistemi_lineari.c:65: warning: suggest parentheses around assignment used as truth value
sistemi_lineari.c:69: warning: control reaches end of non-void function
sistemi_lineari.c: In function ‘determinante’:
sistemi_lineari.c:76: warning: suggest parentheses around assignment used as truth value
sistemi_lineari.c: At top level:
sistemi_lineari.c:86: warning: return type defaults to ‘int’
sistemi_lineari.c: In function ‘triangolare’:
sistemi_lineari.c:90: warning: suggest parentheses around assignment used as truth value
sistemi_lineari.c:92: warning: suggest parentheses around assignment used as truth value
sistemi_lineari.c:94: warning: suggest parentheses around assignment used as truth value
sistemi_lineari.c:101: warning: control reaches end of non-void function
sistemi_lineari.c: At top level:
sistemi_lineari.c:104: warning: return type defaults to ‘int’
sistemi_lineari.c: In function ‘soluzione’:
sistemi_lineari.c:107: warning: suggest parentheses around assignment used as truth value
sistemi_lineari.c:118: warning: control reaches end of non-void function


ora mi piacerebbe tanto anche riuscire a provare se funziona, il fatto è che siccome sono una pippa (è il primo programma in C) già all'inizio mi si blocca e non va più avanti...in pratica, inizio, mi chiede di inserire il numero delle variabili (n) printf("Inserisci il numero delle variabili\n");

inserisco il numero, dò invio, non succede niente...dò un altro invio e continua a non succedere niente, allora inserisco un'altra volta un numero, dò invio, e a questo punto mi fa tutto sto pezzo e prende già come valore della prima variabile il secondo numero che ho inserito, e poi potrei andare avanti all'infinito a inserire valori (che oltretutto non mi stampa a video come voglio io, ma li stampa tutti uno sotto l'altro) 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);
n = (int)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("x(%d) +\t", k+1); //stampo la matrice


}

Ecco un esempio dell'output che ho
Inserisci il numero delle variabili
5
5
Inserisci i 25 coefficienti delle variabili in ordine
x(5) + 6
x(5) + 3
x(5) + 2
x(5) + 5
x(5) + 7
x(5) + 8
x(5) + 7
x(5) + 6
x(5) + 5
x(5) + ...

Mentre io vorrei una cosa così
Inserisci il numero delle variabili
5
Inserisci i 25 coefficienti delle variabili in ordine
5x(1) + 6x(2) + 3x(3) + 2x(4) + 5x(5) <-linea1
...

[DanieleC88]

Ci sono parecchi problemi:
n = (int)n;
int matriceA[n][n];
Orroreeee! :D
Usa malloc se puoi... ;)
Comunque, finché te lo compila... vabbe'. :D

for(i=0;i=(n-1);i++) //ciclo per le righe
In quel modo assegni (n-1) ad i, il confronto si fa con ==... Però fai prima a controllare che sia i<(n-1).

orlato(int **mA, int **mB, int a);
Questi e i seguenti prototipi non hanno un tipo specificato per il valore di ritorno, GCC te li imposta ad int da solo, ma se non hai bisogno di valori di ritorno puoi anche renderli void.

printf("x(%d)=%d \n", k, sol[1][k]); //stampo la soluzione
Così vai a capo ogni volta che stampi, se non vuoi andare a capo, da come dici, togli il "\n" finale, metti una printf("\n") apposita alla fine del ciclo.

Non so se c'è altro, intanto correggi questi, sto uscendo, quindi non posso leggermi tutto il codice. :D

ciao ;)

[_mr_]

Ci sono parecchi problemi:
n = (int)n;
int matriceA[n][n];
Orroreeee! :D
Usa malloc se puoi... ;)
Comunque, finché te lo compila... vabbe'. :D
Quando riuscirò a capirne bene il funzionamento lo farò...:D :D

for(i=0;i=(n-1);i++) //ciclo per le righe
In quel modo assegni (n-1) ad i, il confronto si fa con ==... Però fai prima a controllare che sia i<(n-1).
ok...errore grossolano...chiedo scusa :D :D

orlato(int **mA, int **mB, int a);[code]
Questi e i seguenti prototipi non hanno un tipo specificato per il valore di ritorno, GCC te li imposta ad int da solo, ma se non hai bisogno di valori di ritorno puoi anche renderli void. Ok, fatto :)

[code]printf("x(%d)=%d \n", k, sol[1][k]); //stampo la soluzione
Così vai a capo ogni volta che stampi, se non vuoi andare a capo, da come dici, togli il "\n" finale, metti una printf("\n") apposita alla fine del ciclo.
no questa parte è giusta, lì deve andarmi a capo ogni volta...è all'inizio il problema...

Non so se c'è altro, intanto correggi questi, sto uscendo, quindi non posso leggermi tutto il codice. :D

ciao ;)

ok grazie, ora il numero di errori si è ridotto drasticamente

sistemi_lineari.c: In function ‘main’:
sistemi_lineari.c:37: warning: passing argument 1 of ‘orlato’ from incompatible pointer type
sistemi_lineari.c:37: warning: passing argument 2 of ‘orlato’ from incompatible pointer type
sistemi_lineari.c:38: warning: passing argument 1 of ‘triangolare’ from incompatible pointer type
sistemi_lineari.c:39: warning: passing argument 1 of ‘determinante’ from incompatible pointer type
sistemi_lineari.c:45: warning: passing argument 1 of ‘soluzione’ from incompatible pointer type


Dall'altra parte però c'è il fatto che il programma non funziona per niente...vi metto qui un output e sotto il codice...

Inserisci il numero delle variabili
4
6
Inserisci i 16 coefficienti delle variabili in ordine
Inserisci i 4 termini noti

Sistema determinato
logout

[Processo completato]


#include <stdio.h>

void orlato(int **mA, int **mB, int a);
int determinante(int **m, int a);
void triangolare(int **m, int a, int b);
void soluzione(int **m, int a, int b);
int **mAB;
int **matr_triang;
int **sol;

int main ()
{
printf("Inserisci il numero delle variabili\n");
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);
n = (int)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("x(%d) +\t", k+1); //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][0]); //memorizzo i termini noti
printf("%d \n", matriceB[i][0]); //stampo la matrice
}
orlato(&matriceA, &matriceB, n); //genero la matrice completa
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");
soluzione(&matr_triang, n, n+1); //calcoli per soluzione
for(k=0;k==(n-1);k++)
{
printf("x(%d)=%d \n", k+1, sol[k][0]); //stampo la soluzione
}
}
return 0;
}

void orlato(int **mA, int **mB, int a) //funzione per generare la matrice orlata
{
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
{
mAB[i][k]=mA[i][k]; //copio la matrice A nella matrice mAB
}
}
for(i=0;i==(a-1);i++) //ciclo per le righe, la colonna è una sola
{
mAB[i][a]=mB[i][0]; //aggiungo come ultima colonna quella della matrice B
}
}


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);

}


void triangolare(int **m, int a, int b) //funzione per generare la matrice triangolare
{
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
{
matr_triang[0][k]=m[0][k];
matr_triang[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
}
}
}
}

void soluzione(int **m, int a, int b)
{
int i; //dichiaro contatore
int k; //dichiaro contatore
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
sol[a-i][0] = m[a-i][a-1]; //inizio col porre l'incognita uguale al termine noto
while(k<i)
{
sol[a-i][0] -= sol[a-k][0]; //ad ogni ciclo sottraggo una delle restanti incognite già calcolate
k++; //e aumento di 1 il valore di k
}
sol[a-i][0] /= m[a-i][a-i-1]; //alla fine divido per il coefficiente dell'incognita che sto calcolando
}
}

[_mr_]

Nuovo Codice (ho modificato tutte le condizioni dei for da "==" a "<=" e ho messo un paio di print per controllare l'esecuzione:
#include <stdio.h>

void orlato(int **mA, int **mB, int a);
int determinante(int **m, int a);
void triangolare(int **m, int a, int b);
void soluzione(int **m, int a, int b);
int **mAB;
int **matr_triang;
int **sol;

int main ()
{
printf("Inserisci il numero delle variabili\n");
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);
n = (int)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("x(%d) +\t", k+1); //stampo la matrice
}
printf("\t <-linea %d \n", i+1);
}
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][0]); //memorizzo i termini noti
printf("%d \n", matriceB[i][0]); //stampo la matrice
}
orlato(&matriceA, &matriceB, n); //genero la matrice completa
for (i=0;i<=n-1;i++)
{
for (k=0;k<=n;k++)
{
printf("%d \t", mAB[i][k]);
}
printf("\n");
}
triangolare(&mAB, n, n+1); //genero la matrice triangolare
for (i=0;i<=n-1;i++)
{
for (k=0;k<=n;k++)
{
printf("%d \t", matr_triang[i][k]);
}
printf("\n");
}

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");
soluzione(&matr_triang, n, n+1); //calcoli per soluzione
for(k=0;k<=(n-1);k++)
{
printf("x(%d)=%d \n", k+1, sol[k][0]); //stampo la soluzione
}
}
return 0;
}

void orlato(int **mA, int **mB, int a) //funzione per generare la matrice orlata
{
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
{
mAB[i][k]=mA[i][k]; //copio la matrice A nella matrice mAB
}
}
for(i=0;i<=(a-1);i++) //ciclo per le righe, la colonna è una sola
{
mAB[i][a]=mB[i][0]; //aggiungo come ultima colonna quella della matrice B
}
}


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);

}


void triangolare(int **m, int a, int b) //funzione per generare la matrice triangolare
{
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
{
matr_triang[0][k]=m[0][k];
matr_triang[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
}
}
}
}

void soluzione(int **m, int a, int b)
{
int i; //dichiaro contatore
int k; //dichiaro contatore
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
sol[a-i][0] = m[a-i][a-1]; //inizio col porre l'incognita uguale al termine noto
while(k<i)
{
sol[a-i][0] -= sol[a-k][0]; //ad ogni ciclo sottraggo una delle restanti incognite già calcolate
k++; //e aumento di 1 il valore di k
}
sol[a-i][0] /= m[a-i][a-i-1]; //alla fine divido per il coefficiente dell'incognita che sto calcolando
}
}





Nuovo output:
Inserisci il numero delle variabili
5
5
Inserisci i 25 coefficienti delle variabili in ordine
x(1) + 1
x(2) + 2
x(3) + 3
x(4) + 4
x(5) + <-linea 1
5
x(1) + 6
x(2) + 7
x(3) + 89
x(4) + 0
x(5) + <-linea 2
6
x(1) + 4
x(2) + 3
x(3) + 2
x(4) + 4
x(5) + <-linea 3
5
x(1) + 6
x(2) + 7
x(3) + 8
x(4) +
9
x(5) + <-linea 4
7
x(1) + 6
x(2) + 5
x(3) + 4
x(4) + 3
x(5) + <-linea 5
Inserisci i 5 termini noti
0
0
0
0
0
0
0
0
0
0
Bus error
logout

[Processo completato]

[_mr_]

HOCAPITOHOCAPITO...finalmente ho capito come usare malloc...ora lo faccio e poi vi dico :D :D :D

GRAZIEMILLISSIME :D :D
Ciao

EDIT: Ho gioito troppo presto....ora il programma è così...ma l'output è sempre quello di prima (con un terrificante "bus error" che chiude l'esecuzione)

#include <stdlib.h>
#include <stdio.h>

void orlato(int **mA, int **mB, int a);
int determinante(int **m, int a);
void triangolare(int **m, int a, int b);
void soluzione(int **m, int a, int b);
int **mAB;
int **matr_triang;
int **sol;

int main ()
{
printf("Inserisci il numero delle variabili\n");
int n; //Dichiaro n, il numero delle equazioni e delle incognite
scanf("%d \n", &n); //leggo il numero delle equazioni e delle incognite
n = (int)n; //Cast di n in int


int i; //Dichiaro i contatori che mi
int k; //serviranno per i cicli
int **matriceA; //Dichiaro il puntatore per la matrice matriceA
matriceA = (int **) malloc(n * sizeof(int)); //Alloco la memoria per la matrice matriceA
for(i=0;i<=n;i++)
matriceA[i] = (int *) malloc(n * sizeof(int));


//Inizio la memorizzazione dei coefficienti nella matrice matriceA
printf("Inserisci i %d coefficienti delle variabili in ordine \n", n*n);
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("x(%d) +\t", k+1); //stampo la matrice
}
printf("\t <-linea %d \n", i+1);
}


//Inizio la memorizzazione dei termini noti nella matrice matriceB
printf("Inserisci i %d termini noti \n", n);
int *matriceB; //Dichiaro il puntatore per la matrice matriceB
matriceB = (int *) malloc(n * sizeof(int)); //Alloco la memoria per la matrice matriceB
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]); //memorizzo i termini noti
}


//Ora cominciano i calcoli:
//Generazione matrice completa
mAB = (int **) malloc(n * sizeof(int)); //Alloco la memoria per la matrice mAB
for(i=0;i<=n;i++)
mAB[i] = (int *) malloc((n+1) * sizeof(int));
orlato(&matriceA, &matriceB, n); //genero la matrice completa
for (i=0;i<=n-1;i++)
{
for (k=0;k<=n;k++)
{
printf("%d \t", mAB[i][k]);
}
printf("\n");
}


//Generazione matrice triangolare
matr_triang = (int **) malloc(n * sizeof(int)); //Alloco la memoria per la matrice matr_triang
for(i=0;i<=n;i++)
matr_triang[i] = (int *) malloc((n+1) * sizeof(int));
triangolare(&mAB, n, n+1); //genero la matrice triangolare
for (i=0;i<=n-1;i++)
{
for (k=0;k<=n;k++)
{
printf("%d \t", matr_triang[i][k]);
}
printf("\n");
}


//Calcolo del determinante
int DETA = determinante(&matriceA, n); //calcolo il determinante


//Soluzione del sistema
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");
sol = (int **) malloc(n * sizeof(int)); //Alloco la memoria per la matrice sol
soluzione(&matr_triang, n, n+1); //calcoli per soluzione
for(k=0;k<=(n-1);k++)
{
printf("x(%d)=%d \n", k+1, sol[k]); //stampo la soluzione
}
}
return 0;
}


//Qui sotto procedure e funzioni
void orlato(int **mA, int **mB, int a) //funzione per generare la matrice orlata
{
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
{
mAB[i][k]=mA[i][k]; //copio la matrice A nella matrice mAB
}
}
for(i=0;i<=(a-1);i++) //ciclo per le righe, la colonna è una sola
{
mAB[i][a]=mB[i][0]; //aggiungo come ultima colonna quella della matrice B
}
}


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);

}


void triangolare(int **m, int a, int b) //funzione per generare la matrice triangolare
{
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
{
matr_triang[0][k]=m[0][k];
matr_triang[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
}
}
}
}

void soluzione(int **m, int a, int b)
{
int i; //dichiaro contatore
int k; //dichiaro contatore
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
sol[a-i][0] = m[a-i][a-1]; //inizio col porre l'incognita uguale al termine noto
while(k<i)
{
sol[a-i][0] -= sol[a-k][0]; //ad ogni ciclo sottraggo una delle restanti incognite già calcolate
k++; //e aumento di 1 il valore di k
}
sol[a-i][0] /= m[a-i][a-i-1]; //alla fine divido per il coefficiente dell'incognita che sto calcolando
}
}

[DanieleC88]

LOL, Bus error? :D
Complimenti, non ero mai riuscito a leggere una cosa del genere con un mio programmino! :D

Be' guarda così non mi risulta comodo leggere il tutto, e oggi sono di nuovo in partenza, magari domani pomeriggio me lo guardo meglio, ok? :)

ciao ;)

[mjordan]

Un bus error implica qualcosa di piu' profondo che dei semplici errori logici sul programma. Gentilmente, mi indichi:

1) Versione esatta del compilatore in uso.
2) Versione esatta della libreria C in uso.
3) Se sei sotto Linux, versione del kernel in uso (e compilatore con cui è stato compilato, utilizzando il comando uname -a)
4) Versione delle binutils in uso o comunque del linker e dell'assemblatore.

Grazie mille.

[_mr_]

LOL, Bus error? :D
Complimenti, non ero mai riuscito a leggere una cosa del genere con un mio programmino! :D

Be' guarda così non mi risulta comodo leggere il tutto, e oggi sono di nuovo in partenza, magari domani pomeriggio me lo guardo meglio, ok? :)

ciao ;)

ok dai, io non ho fretta...

grazie mille

Un bus error implica qualcosa di piu' profondo che dei semplici errori logici sul programma. Gentilmente, mi indichi:

1) Versione esatta del compilatore in uso.
2) Versione esatta della libreria C in uso.
3) Se sei sotto Linux, versione del kernel in uso (e compilatore con cui è stato compilato, utilizzando il comando uname -a)
4) Versione delle binutils in uso.

Grazie mille.

oddio, tu mi inquieti però eh...

beh, se mi dici dove trovo queste info te le posto...
cmq, quando uso gcc mi esce questo i686-apple-darwin9-gcc-4.0.1 per cui immagino che la versione sia 4.0.1

(cmq propendo più per gli errori logici)

[mjordan]

Non ti voglio inquietare ma i bus error possono essere dei bug nel compilatore o nell'assemblatore :D
Sono 10 anni e oltre che programmo in C e massimo che ho ottenuto con delle malloc maldestre sono degli errori di segmentazione :sofico:

Questa ovviamente è solo una delle possibili cause. ;)

Nulla che a che fare con il tuo problema, quindi non ti inquietare, continua pure. Era semplice interesse personale. Cazzarola però, usi Mac :muro:
In ogni caso la versione 4.0.x è noto che sia completamente "rotta", piena di bug critici anche dal punto di vista della generazione del codice. Probabile che abbia ragione, ma considerando quanto è vecchia la 4.0.x non è nemmeno nulla che valga la pena essere investigato...

[_mr_]

Non ti voglio inquietare ma i bus error possono essere dei bug nel compilatore o nell'assemblatore :D
Sono 10 anni e oltre che programmo in C e massimo che ho ottenuto con delle malloc maldestre sono degli errori di segmentazione :sofico:

Questa ovviamente è solo una delle possibili cause. ;)

Nulla che a che fare con il tuo problema, quindi non ti inquietare, continua pure. Era semplice interesse personale. Cazzarola però, usi Mac :muro:
In ogni caso la versione 4.0.x è noto che sia completamente "rotta", piena di bug critici anche dal punto di vista della generazione del codice. Probabile che abbia ragione, ma considerando quanto è vecchia la 4.0.x non è nemmeno nulla che valga la pena essere investigato...

quindi mi consigli magari di installare una versione più aggiornata di gcc?? come dovrei fare in caso? xkè installando xCode mi ha installato anche i developer tools che includono gcc

[mjordan]

quindi mi consigli magari di installare una versione più aggiornata di gcc?? come dovrei fare in caso? xkè installando xCode mi ha installato anche i developer tools che includono gcc

No lascia perdere. :D
Se non ci pensa Apple a ste cose...
In genere i bus error sono errori di alignment sulle variabili ... Però io non so nel caso del mac se sia un'operazione consigliata o meno, se possa portare dei problemi e soprattutto non conosco minimamente XCode. Se non sei capace di farlo in modo ottimale, potresti distruggere il sistema, visto che dalla 4.0.x all'attuale 4.3.x ci sono stati cambiamenti all'ABI della libstdc++ abbastanza importanti... :p
Io in genere GCC me lo ricompilo / installo da solo dai sorgenti (sotto Linux) ma sotto Mac non saprei proprio dirti qual'è il modo ottimale.
Inoltre nuove versioni di GCC potrebbero darti problemi con XCode, questo non lo so nemmeno ma è probabile, considerato che di default ti ha installato quella versione.

Lascia perdere :p
Fai finta che non ti ho detto niente :sofico:

EDIT: Magari prova a togliere quell'assegnamento n = (int)n; e prova invece a fare il casting direttamente al primo uso della variabile per vedere se si risolve: secondo me il problema sta proprio li :p

[_mr_]

No lascia perdere. :D
Se non ci pensa Apple a ste cose...

ah ok...allora proverò a vedere di trovare l'errore nel programma (in ogni caso il problema dovrebbe essere legato alle allocazioni della memoria??)....
grazie
ciao

[mjordan]

ah ok...allora proverò a vedere di trovare l'errore nel programma (in ogni caso il problema dovrebbe essere legato alle allocazioni della memoria??)....
grazie
ciao

Si, anche se l'errore non è propriamente tuo ma del compilatore. Però modificando qualche cosina, potresti eliminare il fatto che il compilatore sbagli a generare il codice.

[_mr_]

Si, anche se l'errore non è propriamente tuo ma del compilatore. Però modificando qualche cosina, potresti eliminare il fatto che il compilatore sbagli a generare il codice.

ah ok....mi viene più facile cercare di aggiornare gcc allora :D :D

[mjordan]

ah ok....mi viene più facile cercare di aggiornare gcc allora :D :D

Modificando il tuo programma non rischi danni al sistema però ;)

[_mr_]

Modificando il tuo programma non rischi danni al sistema però ;)

eh si...il fatto è che non so proprio da dove cominciare a cercare il problema

[mjordan]

eh si...il fatto è che non so proprio da dove cominciare a cercare il problema

Ti ho detto, prova a togliere quel n = (int)n;
:sofico:

Il codice che hai scritto non segue proprio lo standard, comunque....

[_mr_]

Ti ho detto, prova a togliere quel n = (int)n;
:sofico:

Il codice che hai scritto non segue proprio lo standard, comunque....

l'ho tolto, ma non è cambiato niente...e, è il primo programma in C, purtroppo non lo conosco ancora bene, se hai da darmi qualche consiglio ne farò tesoro :D

Grazie mille
ciao

[_mr_]

ciao a tutti, rieccomi
ok, allora, il programma adesso funziona (o almeno credo :confused: :confused: ) solo che alla fine mi da come output questa roba

Inserisci il numero delle variabili
3
Inserisci i 9 coefficienti delle variabili in ordine
X(1) -> 1
X(2) -> 1
X(3) -> -1
linea 1
X(1) -> 1
X(2) -> 2
X(3) -> -2
linea 2
X(1) -> 2
X(2) -> -3
X(3) -> 1
linea 3
Inserisci i 3 termini noti
7
2
3
1.000000X(1) + 1.000000X(2) + -1.000000X(3) =7.000000
1.000000X(1) + 2.000000X(2) + -2.000000X(3) =2.000000
2.000000X(1) + -3.000000X(2) + 1.000000X(3) =3.000000


Matrice Completa:
1.000000X(1) + 1.000000X(2) + -1.000000X(3) =7.000000
1.000000X(1) + 2.000000X(2) + -2.000000X(3) =2.000000
2.000000X(1) + -3.000000X(2) + 1.000000X(3) =3.000000

Matrice Triangolare:
1.000000X(1) + 1.000000X(2) + -1.000000X(3) =7.000000
0.000000X(1) + 1.000000X(2) + -1.000000X(3) =-5.000000
0.000000X(1) + 0.000000X(2) + -4.000000X(3) =12.000000

Determinante = -4.000000


Sistema determinato
X(1)=nan
X(2)=-inf
X(3)=inf


ma che vogliono dire nan e inf??? :confused: :confused:


Il codice è questo:
#include <stdlib.h>
#include <stdio.h>

void orlato(double **mA, double *mB, int a);
double determinante(double **m, int a);
void triangolare(double **m, int a, int b);
void soluzione(double **m, int a);
double **mAB;
double **matr_triang;
double *sol;

int main ()
{
printf("Inserisci il numero delle variabili\n");
int n; //Dichiaro n, il numero delle equazioni e delle incognite
scanf("%d", &n); //leggo il numero delle equazioni e delle incognite


int i; //Dichiaro i contatori che mi
int k; //serviranno per i cicli
double **matriceA; //Dichiaro il puntatore per la matrice matriceA
matriceA = (double **) malloc(n * sizeof(double)); //Alloco la memoria per la matrice matriceA
for(i=0;i<n;i++)
matriceA[i] = (double *) malloc(n * sizeof(double));


//Inizio la memorizzazione dei coefficienti nella matrice matriceA
printf("Inserisci i %d coefficienti delle variabili in ordine \n", n*n);
for(i=0;i<=(n-1);i++) //ciclo per le righe
{
for(k=0;k<=(n-1);k++) //ciclo per le colonne
{
printf("X(%d) -> \t", k+1); //Dico all'utente quale variabile sta memorizzando
scanf("%lf", &matriceA[i][k]); //memorizzo i coefficienti delle variabili
}
printf("linea %d \n", i+1); //Fine linea
}


//Inizio la memorizzazione dei termini noti nella matrice matriceB
printf("Inserisci i %d termini noti \n", n);
double *matriceB; //Dichiaro il puntatore per la matrice matriceB
matriceB = (double *) malloc(n * sizeof(double)); //Alloco la memoria per la matrice matriceB
for(i=0;i<=n-1;i++) //ciclo per le righe, la colonna è 1 quindi non mi serve un secondo ciclo
{
scanf("%lf", &matriceB[i]); //memorizzo i termini noti
}


//Stampo la matrice
for(i=0;i<=(n-1);i++) //ciclo per le righe
{
for(k=0;k<=(n-1);k++) //ciclo per le colonne
{
printf("%fX(%d)", matriceA[i][k], k+1); //Stampo le incognite e i coefficienti
if (k<(n-1))
{
printf(" +\t");
}
}
printf(" =%f \n", matriceB[i]); //Stampo il termine noto
}




//Ora cominciano i calcoli:
//Generazione matrice completa
mAB = (double **) malloc((n) * sizeof(double)); //Alloco la memoria per la matrice mAB
for(i=0;i<=n;i++)
mAB[i] = (double *) malloc((n+1) * sizeof(double));
orlato(matriceA, matriceB, n); //genero la matrice completa

//Stampo la matrice completa
printf("\n\n\n\n\n\nMatrice Completa:\n"); //Qualche riga di spazio
for(i=0;i<=(n-1);i++) //ciclo per le righe
{
for(k=0;k<=(n-1);k++) //ciclo per le colonne
{
printf("%fX(%d)", mAB[i][k], k+1); //Stampo le incognite e i coefficienti
if (k<(n-1))
{
printf(" +\t");
}
}
printf(" =%f \n", mAB[i][n]); //Stampo il termine noto
}




//Generazione matrice triangolare
matr_triang = (double **) malloc(n * sizeof(double)); //Alloco la memoria per la matrice matr_triang
for(i=0;i<=n;i++)
matr_triang[i] = (double *) malloc((n+1) * sizeof(double));
triangolare(mAB, n, n+1); //genero la matrice triangolare

//Stampo la matrice triangolare
printf("\n\n\n\n\n\nMatrice Triangolare:\n"); //Qualche riga di spazio
for(i=0;i<=(n-1);i++) //ciclo per le righe
{
for(k=0;k<=(n-1);k++) //ciclo per le colonne
{
printf("%fX(%d)", matr_triang[i][k], k+1); //Stampo le incognite e i coefficienti
if (k<(n-1))
{
printf(" +\t");
}
}
printf(" =%f \n", matr_triang[i][n]); //Stampo il termine noto
}




//Calcolo del determinante
double DETA = determinante(matr_triang, n); //calcolo il determinante

//Stampo il determinante
printf("\n\n\n\nDeterminante = %f\n\n", DETA);




//Soluzione del sistema
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");
sol = (double *) malloc(n * sizeof(double)); //Alloco la memoria per la matrice sol
soluzione(matr_triang, n); //calcoli per soluzione
for(k=0;k<=(n-1);k++)
{
printf("X(%d)=%f \n", k+1, sol[k]); //stampo la soluzione
}
}
free(matriceA);
free(matriceB);
free(mAB);
free(matr_triang);
free(sol);
system("PAUSE");
return 0;
}


//Qui sotto procedure e funzioni
void orlato(double **mA, double *mB, int a) //funzione per generare la matrice orlata
{
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
{
mAB[i][k]=mA[i][k]; //copio la matrice A nella matrice mAB
}
mAB[i][a]=mB[i]; //aggiungo come ultima colonna quella della matrice B
}
}


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

}


void triangolare(double **m, int a, int b) //funzione per generare la matrice triangolare
{
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
{
matr_triang[0][k]=m[0][k];
matr_triang[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
}
}
}
}

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

[||ElChE||88]

ma che vogliono dire nan e inf??? :confused: :confused:
Not a Number ed Infinity...c'è qualche problema. :fagiano:

[_mr_]

Not a Number ed Infinity...c'è qualche problema. :fagiano:

ups....grazie, controllerò cosa può essere

grazie mille
ciao

[||ElChE||88]

ups....grazie, controllerò cosa può essere

grazie mille
ciao

sol[a-i] /= m[a-i][a-i-1];


m[a-i][a-i-1] = 0 tutte e tre le volte.... il problema è la.

[_mr_]

sol[a-i] /= m[a-i][a-i-1];


m[a-i][a-i-1] = 0 tutte e tre le volte.... il problema è la.

è vero, grazie mille, errore di distrazione...non mi ero accorto che a è il numero delle righe, mentre le colonne sono a+1, per cui ho corretto in m[a-i][a-i]

Grazie mille :D :D
Ora funziona tutto, grazie infinite veramente, e scusate se vi ho rotto un po' le scatole

Ciao
Matteo