[C] Risoluzione sistemi lineari

[guylmaster]

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

#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

#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

#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,
guylmaster.