Salve a tutti,
mi è stato dato da scrivere in C un algoritmo di risoluzione per i sistemi lineari, e mi è stato dato da seguire il seguente flowchart:

Il codice che ho prodotto si suddivide come sempre in main.c, my_libreria.c che contiene le funzioni e my_libreria.h che contiene la struttura dati ed i prototipi.
Il codice è il seguete:
main.c
codice:
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#include <string.h>
#include "my_libreria.h"
int main()
{
matrix mat1,mat2;
resetta_matrice(&mat1);
resetta_matrice(&mat2);
inizializza_matrice(&mat1,3,3);
inizializza_matrice(&mat2,3,1);
scrivi_elem(&mat1,0,0,3);
scrivi_elem(&mat1,0,1,2);
scrivi_elem(&mat1,0,2,-3);
scrivi_elem(&mat1,1,0,4);
scrivi_elem(&mat1,1,1,-3);
scrivi_elem(&mat1,1,2,6);
scrivi_elem(&mat1,2,0,1);
scrivi_elem(&mat1,2,1,0);
scrivi_elem(&mat1,2,2,-1);
scrivi_elem(&mat2,0,0,5);
scrivi_elem(&mat2,1,0,1);
scrivi_elem(&mat2,2,0,3);
printf("\n1° vettore:\n");
stampa_matrice(&mat1);
printf("\n");
risoluzione_sistema(&mat1,&mat2);
printf("\n\nRISOLUZIONE\n");
stampa_matrice(&mat1);
system("pause");
}
my_libreria.c
codice:
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#include <string.h>
#include "my_libreria.h"
void risoluzione_sistema(matrix *M,matrix *N)
{
int n,m;
int i,j;
int k;
int flag;
int index;
float var_appo;
float appo;
int r;
M->num_colonna++;
n=numero_colonne_matrice(M);
m=numero_righe_matrice(M);
//aggiungo la matrice contenente i valori noti del sistema
for(j=0;j<m;j++)
{
scrivi_elem(M,j,n-1,leggi_elem(N,j,0));
}
stampa_matrice(M);
system("pause");
i=0;
j=0;
while(j<n)
{
k=i;
flag=0;
while(k<m && !flag)
{
if(leggi_elem(M,k,j) != 0)
flag=1;
else
k++;
}
if(flag==1)
{
if(k != i)
{
for(index=0;index<n;index++)
{
appo=leggi_elem(M,i,index);
scrivi_elem(M,i,index,leggi_elem(M,k,index));
scrivi_elem(M,k,index,appo);
}
}
for(index=0;index<n;index++)
{
var_appo=leggi_elem(M,i,index);
var_appo=var_appo/leggi_elem(M,i,j);
scrivi_elem(M,i,index,var_appo);
}
for(r=0;r<m;r++)
{
if(r!=i)
{
index=0;
for(;index<n;index++)
{
var_appo=leggi_elem(M,i,index);
var_appo=var_appo*((leggi_elem(M,r,j)*(-1)));
var_appo=var_appo+leggi_elem(M,r,index);
scrivi_elem(M,r,index,var_appo);
}
}
}
}
j++;
i++;
}
}
/*-----------------------------------------------------------------------------*/
float leggi_elem(matrix *mat1,int riga,int colonna)
{
float elem;
elem = mat1->matrice[riga][colonna];
return(elem);
}
/*-----------------------------------------------------------------------------*/
void scrivi_elem(matrix *mat1,int riga,int colonna,float elemento)
{
mat1->matrice[riga][colonna]= elemento;
}
/*-----------------------------------------------------------------------------*/
void resetta_matrice(matrix *mat)
{
mat = NULL;
}
/*-----------------------------------------------------------------------------*/
void inizializza_matrice(matrix* mat,int num_righe,int num_colonne)
{
int i;
mat->num_riga=num_righe;
mat->num_colonna=num_colonne;
mat->matrice=(float**)malloc(num_righe * sizeof(float));
for(i=0; i < num_righe; i++)
{
mat->matrice[i]=(float*)calloc(num_colonne,sizeof(float));
}
}
/*-----------------------------------------------------------------------------*/
int numero_righe_matrice(matrix *mat)
{
int val_ri;
val_ri=mat->num_riga;
return(val_ri);
}
/*-----------------------------------------------------------------------------*/
int numero_colonne_matrice(matrix *mat)
{
int val_co;
val_co=mat->num_colonna;
return(val_co);
}
/*-----------------------------------------------------------------------------*/
void stampa_matrice(matrix *mat1)
{
int num_col;
int num_ri;
int index1;
int index2;
num_col=numero_colonne_matrice(mat1);
num_ri=numero_righe_matrice(mat1);
//ciclo esterno per la scansione delle righe
for(index1=0 ; index1<num_ri ; index1++)
{
printf("\n");
//ciclo interno per la scansione delle colonne
for(index2=0 ; index2<num_col ; index2++)
{
//stampa a video dell'elemento
printf("%f\t",leggi_elem(mat1,index1,index2));
}
}
}
my_libreria.h
codice:
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#include <string.h>
#define cost_elem_max 100
//DEFINIZIONE STRUTTURE
typedef struct{
float **matrice;
int num_riga;
int num_colonna;
}matrix;
//DEFINIZIONE PROTOTIPI
float leggi_elem(matrix *mat1,int riga,int colonna);
/*------------------------------------------------------------------------------*/
void scrivi_elem(matrix *mat1,int riga,int colonna,float elemento);
/*------------------------------------------------------------------------------*/
void resetta_matrice(matrix *mat);
/*-----------------------------------------------------------------------------*/
void inizializza_matrice(matrix *mat,int num_righe,int num_colonne);
/*-----------------------------------------------------------------------------*/
int numero_righe_matrice(matrix *mat);
/*-----------------------------------------------------------------------------*/
int numero_colonne_matrice(matrix *mat);
/*-----------------------------------------------------------------------------*/
void stampa_matrice(matrix *mat1);
/*-----------------------------------------------------------------------------*/
void risoluzione_sistema(matrix *mat1,matrix *mat2);
Di regola il codice dovrebbe stamparmi i risultati delle varie incognite nella colonna più a destra della matrice aumentata, invece non lo fa e la lascia invariata.
Sapreste aiutarmi per capire dove sbaglio? anche perchè questo algoritmo mi è stato spiegato con quel "disegnino" e non saprei in realtà come risolvelo di mio, quindi vorrei capire se ho sbagliato a seguire quel flowchart oppure se proprio quel flowchart è sbagliato.
Vi ringrazio in anticipo,
Nepunte.