Matrici

Matrici

Algoritmi in Maple e Mathcad
Matrici in Pascal

Algoritmi in Maple

Sia dato un sistema di equazioni lineari espresso mediante la matrice dei coefficienti A(quadrata) di dimensioni mxm e il vettore dei termini noti B(vettore colonna) di dimensioni mx1.
Calcoliamo rango, determinante, trasposta e inversa della matrice A.
Siamo inoltre interessati ai valori degli Autovalori e degli Autovettori della matrice A, quindi operiamo su questa la decomposizione spettrale: troviamo una matrice diagonale D i cui elementi sulla diagonale siano gli autovalori di A e una matrice ortonormale U le cui colonne siano gli autovettori di A, tale che:

A= UDU’.

Inoltre vogliamo essere in grado di risolvere il sistema (non singolare) nella forma Ax=B.
Il modo piu’ semplice consiste nel triangolarizzare la matrice A (mediante eliminazione gaussiana) e calcolare le x_i per sostituzioni successive.
La fattorizzazione LU della matrice A consiste nel trovare 2 matrici, L e U tali che L sia una matrice triangolare bassa e unitaria, e U sia triangolare alta, e in modo che:

A=LU.

Ottenute queste 2 matrici, per calcolare il sistema di partenza si puo’ risolvere Ly=B, quindi trovare i valori di x risolvendo:

Ux=y.

In questo metodo c’e’ pero’ un problema: se nel corso della triangolarizzazione uno degli elementi ‘pivot’ fosse nullo, il procedimento si arresta. Questo inconveniente puo’ essere risolto scambiando le righe della matrice A ( lo scambio di 2 equazioni nel sistema Ax=B porta a un sistema equivalente al precedente). Quindi abbiamo una nuova fattorizzazione:

PA=LU

dove P e’ un’opportuna matrice di permutazione.

1ï¿½Algoritmo

E’ dato il sistema: x₁+2x₂ +3x₃ + x₄= 1

4x₁ +5x₂ +6x₃= 3

7x₁ +8x₂ + x₄= 5

x₁ + x₂ + x₄= 0

clear;

a=[ 1 2 3 1

     4 5 6 0

     7 8 0 1

     1 1 0 1 ];

b=[ 1

     3

     5

     0 ];

disp('a= ');disp(a);
rango=rank(a);
disp('rango= '); disp(rango);
determinante=det(a);
disp('determinante= '); disp(determinante);
trasposta=a';
disp('trasposta= '); disp(trasposta);
inversa=inv(a);
disp('inversa= '); disp(inversa);

%decomposizione spettrale
[u,lambda]=eig(a);
disp('u(matrice ortonormale con valori degli autovettori sulle colonne)');
disp(u);
disp('lambda(matrice diagonale con autovalori di a sulla diagonale)=');
disp(lambda);

%eliminazione gaussiana
[L1,V1]=lu(a);
%disp(l1);
%disp(b1);
y1=L1\b;
x1=V1\y1;
[L2,V2,P2]=lu(a);
y2=(P2'*L2)\b;
x2=V2\y2;
disp('soluzioni sistema= ');disp(x1);disp(x2);

L’output sara’:

" matr

a=[ 1 2 3 1

     4 5 6 0

     7 8 0 1

     1 1 0 1 ]

rango = 4

determinante = 30

trasposta=[ 1 4 7 1

                   2 5 8 1

                   3 6 0 0

                   1 0 1 1 ]

inversa=[ -1.4000 0.7000 -0.3000 1.7000

                1.2000 -0.6000 0.4000 -1.6000

                -0.0667 0.2000 -0.1333 0.2000

                0.2000 -0.1000 -0.1000 0.9000 ]

u (matrice ortonormale con valori degli autovettori sulle colonne) =[ 0.3039 -0.2917 -0.7491 -0.4119

                            0.7002 -0.3797 0.6525 0.4551

                            0.6398 0.8722 -0.0938 -0.0330

                            0.0895 0.1001 0.0664 -0.7888 ]

lambda (matrice diagonale con autovalori di a sulla diagonale) =[ 12.2190 0 0 0

                       0 -5.7093 0 0

                       0 0 -0.4550 0

                       0 0 0 0.9452 ]

soluzioni sistema =[ -0.8000

                                  1.4000

                                  -0.1333

                                  -0.6000 ]

2ï¿½ Algoritmo

E’ dato il sistema :              x₁ +2x₂ +3x₃ +x₄+2x₅= 1

                                              4x₁ +5x₂ +6x₃ = 3

                                              7x₁ +8x₂ + x₄= 5

                                              x₁ + x₂ + x₄+ x₅= 0

                                             2x₁+5x₂ + x₃ + x₄+2x₅=0

clear;

a = [ 1 2 3 1 2

         4 5 6 0 0

         7 8 0 1 0

         1 1 0 1 1

         2 5 1 1 2 ];

b = [ 1

        3

        5

        0

        0 ];

disp('a= ');disp(a);
rango=rank(a);
disp('rango= '); disp(rango);
determinante=det(a);
disp('determinante= '); disp(determinante);
trasposta=a';
disp('trasposta= '); disp(trasposta);
inversa=inv(a);
disp('inversa= '); disp(inversa);

%decomposizione spettrale
[u,lambda]=eig(a);
disp('u(matrice ortonormale con valori degli autovettori sulle colonne)');
disp(u);
disp('lambda(matrice diagonale con autovalori di a sulla diagonale)=');
disp(lambda);

%eliminazione gaussiana
[L1,V1]=lu(a);
%disp(l1);
%disp(b1);
y1=L1\b;
x1=V1\y1;
[L2,V2,P2]=lu(a);
y2=(P2'*L2)\b;
x2=V2\y2;
disp('soluzioni sistema= ');disp(x1);disp(x2);

" matr5

a =[ 1 2 3 1 2

       4 5 6 0 0

       7 8 0 1 0

       1 1 0 1 1

       2 5 1 1 2 ]

rango = 5

determinante = -35

trasposta =[ 1 4 7 1 2

                     2 5 8 1 5

                     3 6 0 0 1

                     1 0 1 1 1

                     2 0 0 1 2

inversa =[ 1.7429 -0.7143 0.8000 -1.6000 -0.9429

                  -1.0857 0.4286 -0.4000 0.8000 0.6857

                  -0.2571 0.2857 -0.2000 0.4000 0.0571

                  -3.5143 1.5714 -1.4000 4.8000 1.1143

                  2.8571 -1.2857 1.0000 -3.0000 -0.8571 ]

Esercizio

Matrici in Pascal

   Lo studio durante il corso di Fondamenti di informatica del linguaggio Pascal potrebbe risultare utile per cercare alcune caratteristiche delle nostre matrici. Andremo dunque a scrivere alcuni semplici algoritmi in pascal cercando di dimostrare una minima capacita` applicativa degli studi effettuati nei corsi precedenti.
   Il primo algoritmo introdotto permette semplicemente la costruzione di una matrice a partire da una sequenza di numeri,nel nostro caso,reali.
   Inoltre le altre sequenze di comandi permettono la ricerca del punto di sella di una matrice,del rango di una matrice,del massimo.
   Sempre attraverso l`aiuto del linguaggio Pascal possiamo eseguire le operazioni tra matrici come la somma di due matrici,il prodotto righe per colonne di due matrici,la ricerca del determinante.
   Molto interessante e` anche il processo di Merge e cioe` di ordinamento e fusione di due matrici.
   Il nostro interesse in questa tesina mostrera` soltanto 4 algoritmi in Pascal e questo per diversi motivi.Prima di tutto poiche` il nostro fine non e` quello di programmare in Pascal,ma soltanto di dimostrare la facilita` di programmazione in tale linguaggio.
   Inoltre essendo il Pascal basato su pochi comandi "leader" ci e` sembrato inutile riportare troppi algoritmi visto che si basano su un comune indirizzo programmativo ed applicativo.
   In ultimo e` doveroso ricordare che seppure didatticamente assai utile,il linguaggio Pascal e` ormai superato da altre opzioni di programmazioni come il "c" oppure il "c++".
   Il primo algoritmo ha la caratteristica di riprodurre la reale pagina di programmazione in Pascal,una scelta per cercare di entrare piu` nel vivo del programma:

File Edit Run Compile Options Debug Break/watch

i------------------------------------ Edit ------------------------------------ï¿½

Line 34 Col 59 Insert Indent Tab Fill Unindent * C:MATRMAX.PAS

(Ricerca del massimo di una matrice mediante
la scansione di ogni riga e di ogni colonna
memorizzando in una variabile il massimo
provvisorio fino a giungere al massimo definitivo
della matrice)

program maxmat(input,maxmat);
const rig =5;col=6;
var mat:array (1..rig,1..col) of real;
i,j,rigmax,colmax:integer;

begin
for 1 :=to rig
do for j:=1 to col
do read (mat (i,j));
rigmax:=1;colmax:=1;
for:=1 to rig
do for j:=1 to col
do if mat(i,j) > mat(rigmax,colmax)
then begin
        rigmax:=i; colmax:=j
        end;
write ('posizione del massimo:');
writeln ('riga=',rigmax,'colonna=',colmax);
writeln('valore del massimo:',mat(rigmax,colmax))
end.

+----------------------------------- Watch ------------------------------------

+------------------------------------------------------------------------------+

F1-Help F5-Zoom F6-Switch F7-Trace F8-Step F9-Make F10-Menu

Program Somma_Matrice (input,output);
var matrice:array (.1..6,1..8.) of integer;
I,J,R,C :integer;

begin
for I:=1 to 6 do
for J:=1 to 8 do
begin
write ('Elemento ',I:2,J:2);
read (Matrice(.I,J.));writeln;
end;
for I:=1 to
end.

Program Ordinamento (input,output);
type punta=^lista;
lista=record
      elem:integer;
      next:punta;
      end;
var lis,testa,coda:punta;

function dividi (l:punta):punta;
var Seconda:punta;
begin
if (l <> nil) then
if (l^.next <> nil) then
begin
seconda:=l^.next;
l^.next:=seconda^.next;
seconda^.next:=dividi(seconda^.next);
dividi:=seconda;
end
end;

function fondi (l,m:punta) : punta;
begin
if (l=nil) then fondi:=m;
if (m=nil) then fondi:=l else
if (l^.elem<m^.elem) then
begin
l^.next:=fondi(l^.next,m);
fondi:=l;
end;
else if (m^.elem<l^.elem) then
begin
m^.next:=fondi(m^.next,l);
fondi:=m;
end
end;

procedure merge (var lis:punta);
var seconda:punta;
begin
if (lis<>nil) then
if (lis^.next <> nil) then
begin
seconda:=dividi(lis);
merge (lis);
merge (seconda);
lis := fondi (lis,seconda);
end
end;

begin
new(lis);
testa:=lis;
lis^.elem:=4;
lis:=lis^.next;
lis^.elem:=2;
lis:=lis^.next;
lis^.elem:=8;
lis:=lis^.next;
lis^.elem:=5;
lis:=lis^.next;
lis^.elem:=1;
lis:=lis^.next;
lis^.elem:=3;
lis:=lis^.next;
lis^.elem:=7;
lis:=lis^.next;
lis^.elem:=6;
lis:=lis^.next;
lis^.elem:=9;
coda:=lis;
coda^.next:=nil;
lis:=testa;
merge (lis);
while lis<>nil do
begin
write (lis.elem);
lis:=lis^.next;
end
end.

Program Addizione (input,output)
var Primo,Secondo,Somma : real;

begin
write ('Primo Numero ='); read (Primo);
writeln;
write ('Secondo Numero =');read (Secondo);
writeln;
Somma : = Primo + Secondo;
writeln ('Somma = ',Somma:6)
end;