Java soluzione di un sistema omogeneo do n equazioni in n incognite

Esercizio 6

Scrivere un programma per risolvere un sistema lineare non omogeneo di n equazioni in n incognite con n≤m=9.

Consideriamo per brevità un sistema lineare di 4 equazioni in 4 incognite.

In cui ogni equazione è scritta con le 4 incognite x,y,z,w e col termine noto a destra.
Formiamo ora:

il determinante dei coefficienti delle incognite

ottenuti sostituendo le colonne dei coefficienti delle incognite interessate con la colonna dei termini noti.

1] Se D≠0 il sistema ha un'unica soluzione:

2] Se D=0 e almeno uno dei N_x,N_y,N_z, e N_w ≠0 il sistema non ha soluzione: il sistema è impossibile perche ad esempio, se D=0 e N_x≠0, la D·x=N_x porta ad una contraddizione.

3] Se D=0 e almeno uno dei N_x,=N_y=N_z=N_w=0 il sistema può avere e può non avere soluzione. Un sistema che ha un numero infinito di soluzioni è chiamato indeterminato..

Ovviamente per risolvere questo problema possiamo avvalerci dell'algoritmo precedentemente creato; quello per il calcolo del determinante, faremo, inoltre uso di una ulteriore funzione che chiamiamo sistema che si occuperà di gestire i tre casi precedenti.

iimport java.io.*;
class soluzioneSistema {
static final int m=9;// ordine della matrice
public static void main (String args []) throws IOException {
InputStreamReader input=new InputStreamReader(System.in);
BufferedReader h= new BufferedReader(input);
//M matrice dei coefficienti K vettore colonna dei termini noti
//S vettore delle soluzioni
double M[][]= new double[m][m];
double K[]= new double[m];
double S[]= new double[m+1];
int no,r,c;//r=righe c=colonne
do{
    System.out.print("ordine:");
    no=Integer.parseInt(h.readLine().trim());
}while(no > 9 || no < 1);

for(r=0;r < no;r++){//caricamento
     for(c=0;c < no;c++){
          System.out.print("riga:"+(r+1)+" col:"+(c+1)+"=");
          M[r][c]=Double.parseDouble(h.readLine().trim());
     }//fine for c
System.out.print("termine noto riga:"+(r+1)+"=");
K[r]=Double.parseDouble(h.readLine().trim());
}//fine for r
//iniz.S (vettore delle soluzioni)
for(c=0;c < m+1;c++)S[c]=0;
sistema(no,M,K,S);
if(S[m]==3)System.out.println("indeterminato");
else if(S[m]==2)System.out.println("impossibile");
else {
     System.out.println("soluzioni:");
     for(c=0;c < no;c++)System.out.print(S[c]+" ");
}//fine if-else-if
}//fine main _____________________

static void sistema(int num,double T[][], double V[],double S[]){
int c,i,j,sol=0;
double N[][]= new double[m][m];//Nx,Ny,....
double detN[]= new double[num];//cont. i determinanti Nx,Ny,....
double D=det(num,T);

for(c=0;c < num;c++){
     for(i=0;i < num;i++)
          for(j=0;j < num;j++)N[i][j]=T[i][j];
     for(i=0;i < num;i++)N[i][c]=V[i];
     detN[c]=det(num,N);
     if(D!=0){
          S[c]=(double)detN[c]/D;
          if(S[c]!=0)sol=1;
     }
}//fine for c
if(D==0 && sol==0)S[m]=3;// indeterminato
else if(D==0 && sol!=0)S[m]=2;//impossibile
else S[m]=1;//possibile
}//fine sistema__

static double det(int n, double T[][]){
int i,j,ic,jc,c=0;
double determinante=0;
double t[][]= new double[m][m];

if(n==1) return T[0][0];
if(n==2) return (T[0][0]*T[1][1] - T[0][1]*T[1][0]);
for(c=0; c < n; c++){//matrice dei minori
     ic=0;
     for(i=1; i < n; i++){
          jc=0;
          for(j=0; j < n; j++){
               if(j == c) continue;
               t[ic][jc] = T[i][j];
               jc++;
          }//fine for j
          ic++;
     }//fine for i
     determinante+= Math.pow(-1, c) * T[0][c] * det(n-1,t);
}//fine for c
return determinante;
}//fine det
}// fine classe

L'input di questo programma è gestito dalla classe BufferedReader invece che con la classe Scanner, ma cambia poco.