Aggiunto gauss naif e implementato alcuni script come funzioni.

complete_liner_equation_system_resolver.m

@@ -1,61 +0,0 @@
-% completa risoluzione di un sistema lineare usando la riduzione
-% in matrice triangolare superiore con gauss pivoting parziale
-% e algoritmo di bottom up con sostituzione
-
-U=[0,20,30;0,5,3;0,56,34]; % matrice di input
-b=[1;2;17]; %termini noti
-
-
-
-
-n= length(b); 
-U= [U,b]; 
-U
-
-
-for i=1:1:n-1
-    x_max = max ( abs(U(i:n,i)) );
-    if x_max == 0
-        disp('errore matrice di input, det 0')
-        break
-    else
-        [x,y]= ind2sub(size(U),  find (abs(U(i:n,i)) == x_max) );
-        x= x + i -1;
-        y = i;
-        
-       if x~= i
-            U([i x],:) = U([x i],:);
-            
-            
-       end
-        
-       for j=i+1:1:n
-
-            U(j,:) =  U(j,:) + ( U(i,:) * (- U(j,i) / U(i,i) ) ) ; 
-
-       end
-    end
-end
-
-if x_max ~= 0
-
-    b=U(:,n+1);
-    U=U(1:n,1:n);
-
-
-    x=[];
-    n= length(b);
-    x(n) = b(n)/U(n,n);
-
-    for i=n-1:-1:1
-        somma = 0;
-        for k=i+1:n
-            somma=somma+U(i,k) * x(k);
-        end
-
-        x(i) = (b(i) - somma)/ U(i,i);
-    end
-    disp ('La soluzione <EFBFBD> ')
-    x
-end
-

convert_matrix_to_triangular_matrix.m

@@ -1,44 +0,0 @@
-
-% questo algoritmo converte una matrice quadrata generica in
-% triangolare superiore mediante metodo di gauss con pivot parziale
-
-U=[10,20,30;1,5,3;4,56,34]; % matrice di input
-b=[1;2;17]; %termini noti
-n= length(b); % lunghezza del vettore dei termini noti o numero equazioni
-
-
-U= [U,b]; % uniamo la matrice con la colonna dei termini noti
-
-U %stampiamo la matrice
-det(U(:,1:n)) % stampiamo il determinante della matrice
-
-
-% convertiamo la matrice in una triangolare superiore
-for i=1:1:n-1
-    x_max = max ( abs(U(i:n,i)) );
-    if x_max == 0
-        disp('errore')
-    else
-        [x,y]= ind2sub(size(U),  find (abs(U(i:n,i)) == x_max) );
-        x= x + i -1;
-        y = i;
-        
-       if x~= i
-            U([i x],:) = U([x i],:);
-            
-            
-       end
-        
-       for j=i+1:1:n
-
-            U(j,:) =  U(j,:) + ( U(i,:) * (- U(j,i) / U(i,i) ) ) ; 
-
-       end
-    end
-end
-U % stampiamo la nuova matrice convertita
-
-det  ( U(:,[1 : n]) ) % stampiamo il nuovo determinante
-                      % non considerando i termini noti
-                      % e verichiamo che <EFBFBD> uguale al vecchio
-                      % determinante

functions/convert_matrix_to_triangular_matrix_gauss_naif.m

@@ -0,0 +1,44 @@
+
+% questo algoritmo converte una matrice quadrata generica in
+% triangolare superiore mediante metodo di gauss
+% i moltiplicatori sono salvati nella matrice inferiore
+
+%U=[10,20,30;1,5,3;4,56,34];  matrice di input
+%b=[1;2;17]; termini noti
+
+function [U,b] = convert_matrix_to_triangular_matrix_gauss_naif (U,b)
+
+
+    n= length(b); % lunghezza del vettore dei termini noti o numero equazioni
+    U= [U,b]; % uniamo la matrice con la colonna dei termini noti
+
+    
+    ok=1;
+    %check 0 sulla diagonale
+    for i=1:n
+        if U(i,i) == 0
+            ok=0;
+            break
+        end
+    end
+    
+    if ok == 0
+        disp('impossibile convertire')
+        b=[];
+        U=[];
+    else
+           % convertiamo la matrice in una triangolare superiore
+            for i=1:1:n-1
+                   for j=i+1:1:n
+                        m= U(j,i) / U(i,i);
+                        U(j,:) =  U(j,:) + ( U(i,:) * (- m ) ) ; 
+                        U(j,i)=m;
+                   end
+                
+            end
+
+            b=U(:,n+1);
+            U=U(:,1:n);
+    end
+    
+end

functions/convert_matrix_to_triangular_matrix_gauss_pivoting.m

@@ -0,0 +1,51 @@
+
+% questo algoritmo converte una matrice quadrata generica in
+% triangolare superiore mediante metodo di gauss con pivot parziale
+% i moltiplicatori sono salvati nella matrice inferiore
+
+%U=[10,20,30;1,5,3;4,56,34];  matrice di input
+%b=[1;2;17]; termini noti
+
+function [U,b] = convert_matrix_to_triangular_matrix_gauss_pivoting (U,b)
+
+
+    n= length(b); % lunghezza del vettore dei termini noti o numero equazioni
+    U= [U,b]; % uniamo la matrice con la colonna dei termini noti
+
+    % convertiamo la matrice in una triangolare superiore
+    for i=1:1:n-1
+        x_max = max ( abs(U(i:n,i)) );
+        if x_max == 0
+            break
+        else
+            [x,y]= ind2sub(size(U),  find (abs(U(i:n,i)) == x_max) );
+            x= x + i -1;
+            y = i;
+
+           if x~= i
+                U([i x],:) = U([x i],:);
+
+
+           end
+
+           for j=i+1:1:n
+
+                        m= U(j,i) / U(i,i);
+                        U(j,:) =  U(j,:) + ( U(i,:) * (- m ) ) ; 
+                        U(j,i)=m;
+
+           end
+        end
+    end
+    
+    if x_max == 0 || U(n,n) == 0
+        disp('errore')
+        b=[];
+        U=[];
+    else
+        b=U(:,n+1);
+        U=U(:,1:n);
+    end
+   
+    
+end

functions/linear_system_resolver_triangular_matrix.m

@@ -0,0 +1,23 @@
+%risoluzione matrice triangolare superiore con algoritmo
+% di sostituzione botton up (all'indietro)
+
+%example input
+% U=[2,2,4;0,-7,-11;0,0,2];
+% b=[5;-8;-2];
+
+
+function[x] = linear_system_resolver_triangular_matrix(U,b)
+
+    x=[];
+    n= length(b);
+    x(n) = b(n)/U(n,n);
+
+    for i=n-1:-1:1
+        somma = 0;
+        for k=i+1:n
+            somma=somma+U(i,k) * x(k);
+        end
+
+        x(i) = (b(i) - somma)/ U(i,i);
+    end
+end

liner_system_resolver_triangular_matrix.m

@@ -1,20 +0,0 @@
-%risoluzione matrice triangolare superiore con algoritmo
-% di sostituzione botton up (all'indietro)
-
-U=[2,2,4;0,-7,-11;0,0,2];
-b=[5;-8;-2];
-
-x=[];
-n= length(b);
-x(n) = b(n)/U(n,n);
-
-for i=n-1:-1:1
-    somma = 0;
-    for k=i+1:n
-        somma=somma+U(i,k) * x(k);
-    end
-    
-    x(i) = (b(i) - somma)/ U(i,i);
-end
-disp ('La soluzione <EFBFBD> ')
-x

samples/sample_complete_liner_equation_system_resolve.m

@@ -0,0 +1,11 @@
+% completa risoluzione di un sistema lineare usando la riduzione
+% in matrice triangolare superiore con gauss pivoting parziale
+% e algoritmo di bottom up con sostituzione
+
+U=[4,8,12,16;2,9,6,8;0,1,1,4;6,2,2,4]; % matrice di input
+b=[1;-1;2;1]; %termini noti
+
+[x,y] = convert_matrix_to_triangular_matrix_gauss_pivoting(U,b);
+[x1] = linear_system_resolver_triangular_matrix(x,y);
+x1
+

samples/triangolo_superiore_inferiore_matrice.m

@@ -0,0 +1,4 @@
+U=[4,8,12,16;2,9,6,8;0,1,1,4;6,2,2,4];
+
+triu(U)%superiore
+tril(U)%inferiore