Esercizio matrici inverse

matrix_inverse.cpp

#include <iostream.h>
#include <conio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>

#define _MAX 5
#include "c:\tc\servizio.h"
#include "c:\tc\inversa.h"
//-------------------------------------------------FUNZIONI PRINCIPALI
//sfrutto le funzioni della libreria inversa.h per calcolare la matrice inversa
void matrice_inversa(/*float matriceD[][_MAX],*/ int nequ)
{
    //calcolo la matrice dei minore complementare
        copia_matrice(vett,matriceD,nequ);
        int det=determinante(nequ,vett);
    mat_complementi(nequ,vett,matc);
    //vis_matrice(matc,ordine); getch();    clrscr();
    trasposta(matc,nequ);
    //cout<<"Matrice dei minori complementari TRASPOSTA:\n";    vis_matrice(matc,ordine);   getch();    clrscr();
    divisione(matc,nequ,det,matriceD);
}
//---------------------------------------------------------------------------
int predominanza_diag(float matrice[][_MAX], int nequ)
{
    int i,j,q;
    float somma;
		float supporto[_MAX][_MAX],temp;
		int flag=1;

		//nella matrice di supporto tengo in memoria i coefficienti
		for(i=0;i<nequ;i++)
			for(j=0;j<nequ+1;j++)
				supporto[i][j]=matrice[i][j];

		for(i=0;i<nequ;i++)   //i righe
				{
				somma=0;
				for(j=0;j<nequ;j++)
						if(j!=i)
								somma+= matrice[i][j]<0 ? -matrice[i][j] : matrice[i][j] ;
				if(!( abs(matrice[i][i]) >= somma ))
						{
						for(j=0;j<nequ+1;j++)    //j colonne
								{
								temp=0;
								for(q=0;q<nequ;q++)    //q righe
									temp+=supporto[q][j]*supporto[q][i];
								matrice[i][j]=temp;
								}
						flag=0;
            }
        }
    return flag;
}

float *mario_iacobi(float matrice[][_MAX], int nequ)
{
    int i;
    float C[_MAX][_MAX];
    float termininoti[_MAX],h[_MAX],temp[_MAX],xn[_MAX],xn2[_MAX];
    float *inc=NULL;
    clrscr();
    cout<<"Metodo di Jacobi:\n";
    cout<<"dopo aver controllato che gli elementi a(i,i) siano diversi da 0 e, nel caso il\n";
    cout<<" sistema non rispetti al regola della predominanza della matrice, adattandola a\n";
    cout<<" questa condizione, si puo' passare alla risoluzione del sistema.";
    cout<<"A x X/ = b/\n";
    cout<<"Iacobi distingue la matrice A cosi' composta:\n";
    cout<<"A = D + E + F\n";
    cout<<"dove:\n";
    cout<<"D e' la matrice diagonale con gli elementi della matrice A di partenza\n";
    cout<<"E e' la matrice triangolare bassa\n";
    cout<<"F e' la matrice triangolare alta.\n\n";
    cout<<"Il sistema si puo' quindi risolvere in questo modo:\n";
    cout<<" Xn+1/ = D^-1 x b/  -  D^-1 * ( E + F ) x Xn/\n";
    cout<<"che equivale a: X/ = h + C * x0/\n";
    cout<<"dove:\n";
    cout<<"X/ e' il vettore delle incognite";
		cout<<"D^-1 e' la matrice inversa della matrice D";
		cout<<"x0 me lo ricavo ogni volta partendo dal vettore seguente vettore:\n";
		//vettore di innesco
		for(i=0;i<nequ;i++)
				xn[i]=matrice[i][nequ]/matrice[i][i];
		cout<<"x0 = [b1/a11;b2/a22;b3/a33]\n";
		cout<<"x0 = [ ";
		for(i=0;i<nequ;i++)
			{
			cout<<inc[i];
			if(i!=nequ-1)
				cout<<" ; ";
			}
		cout<<" ]\n";
		scrivi_avviso("premere un tasto per procedere alla risoluzione");

		//creo le sottomatrici di A
		for(i=0;i<nequ;i++)
				{
				termininoti[i]=matrice[i][nequ];
				for(int j=0;j<nequ;j++)
						{
						if(i==j)
								{
								matriceD[i][j]=matrice[i][j];
								matriceEF[i][j]=0;
								}
						else
								{
								matriceD[i][j]=0;
								matriceEF[i][j]=matrice[i][j];
								}
						}
				}
		//creo la matrice inversa in matriceD
		cout<<"matrice D:\n";
		visualizza_sistema(matriceD,nequ);
		matrice_inversa(nequ);
		clrscr();
		cout<<"matrice D^-1:\n";
		visualizza_sistema(matriceD,nequ);
		clrscr();
		matrice_prodotto(matriceD,termininoti,h,nequ);
		matrice_prodotto(matriceD,matriceEF,C,nequ,nequ);
		//sostituzione successiva del vettore nell'equazione Xn+1/ = D^-1 x b/  -  D^-1 * ( E + F ) x Xn/
    //per nequ volte
    for(i=0;i<nequ;i++)
        {
        matrice_prodotto(C,xn,xn2,nequ);
        matrice_differenza(h,xn2,xn,nequ);
        }
    inc=new float[nequ];
    for(i=0;i<nequ;i++)
        inc[i]=xn[i];
    return inc;
}
//---------------------------------------------------------------------------
void main()
{
    float *inc=NULL;
    textmode(C4350);
    int scelta=-1,nequ,flag=-1;
    float matrice[_MAX][_MAX];
    do{
        do{
            clrscr();
            cout<<"Programma di matematica by cigliano&valenti";
            if(scelta==-1)	scrivi_avviso("Copyright by US");
            cout<<"\n1- inserisci la matrice\n";
            cout<<"2- visualizza la matrice\n";
            cout<<"3- calcola le soluzioni con Iacobi\n";
            cout<<"0- per uscire\n";
            cout<<"\n\tscelta: ";
            cin>>scelta;
        }while(scelta<0||scelta>3);
        clrscr();
        switch(scelta)
            {
                case 1:	//inserisci la matrice
                             do{
                                 clrscr();
                                 cout<<"Inserire il numero di equazioni(2-"<<_MAX<<")  ";
                                 cin>>nequ;
                             }while(nequ<2||nequ>_MAX);
                             inc=new float[nequ];
                             cout<<"N.B. Per poter utilizzare il metodo, il numero di incognite deve essere uguale al numero di equazioni.\n";
                             inserisci_sistema(matrice,nequ);
                             flag=1;
                             break;
                case 2:	//visualizza la matrice
                             if(flag>0)
                                 {
                                 visualizza_sistema(matrice,nequ);
                                 if(flag==2)	scrivi_avviso("soluzioni gia' calcolate");
                                 }
                             else
                                 scrivi_avviso("devi inserire la matrice!!!");
                             break;
                case 3:	//calcola le soluzioni con Iacobi
                             if(flag>0&&flag<2)
                                 {
                                 //esegui operazioni e visualizza risultato
                                 if(!predominanza_diag(matrice,nequ))
                                     scrivi_avviso("criterio della predominanza della diagonale: sistema adattato");
                                 visualizza_sistema(matrice,nequ);
                                 //calcolo le incognite
                                 inc=mario_iacobi(matrice,nequ);

                                                                 visualizza_incognite(inc,nequ,matrice);

                                 flag=2;
                                 }
                             else     //incognite gia calcolate, visualizzo i risultati
                                 {
                                 if(flag==2)
                                     {
                                     scrivi_avviso("soluzioni gia' calcolate");
                                     visualizza_sistema(matrice,nequ);
                                                                         visualizza_incognite(inc,nequ,matrice);
                                     }
                                 else
                                     scrivi_avviso("devi inserire la matrice!!!");
                                 }
            }
    }while(scelta!=0);
    scrivi_avviso("sei uscito");
}