Soluzione numerica di sistemi lineari sparsi

Soluzione numerica
di sistemi lineari sparsi
Una matrice sparsa è una matrice… “…that allows special techniques
to take advantage of the large number of zero elements” (Wilkinson)
Una matrice A ∈ R n è sparsa se il numero degli
elementi diversi da zero è di ordine O(n).
Una matrice sparsa si dice strutturata se gli
elementi non nulli sono disposti secondo uno
schema ben definito.
1
2
Esempi:
1. matrici sparse strutturate
2. matrici sparse non strutturate
• Matrici diagonali
Sia n=numero totale di pagine web
• Matrici tridiagonali
Si consideri la seguente matrice di dimensione n:
A(i,j)=numero dei link che vanno dalla pagina i
alla pagina j.
La matrice A è sparsa ma non ha nessuna struttura
particolare.
• Matrici a banda
(con banda “piccola”)
3
4
Collezioni standard di matrici sparse
Applicazioni:
Fisica (es. fluido-dinamica, meccanica quantistica),
Astrofisica, Chimica
Ingegneria civile, Ingegneria elettronica (es.
simulazione di circuiti), Ingegneria strutturale
Geografia
Economia
Psicologia
Statistica
….
Controllo del traffico aereo
Algoritmo del page rank di Google
Grafica 3D
5
…
Figure di matrici sparse provenienti da diverse
applicazioni (prese dalla Harwell-Boeing Sparse
Matrix Collection).
Modello per il controllo
del traffico aereo
ZENIOS
L’elevato numero di applicazioni ha portato alla nascita
di raccolte di matrici e sistemi test sparsi provenienti da
diverse discipline scientidiche.
• Harwell-Boeing Sparse Matrix Collection
http://math.nist.gov/MatrixMarket/data/Harwell-Boeing/
• Rutherford-Boeing Sparse Matrix Collection
Sarà a breve disponibile su MatrixMarket. Si veda il report:
ftp://ftp.numerical.rl.ac.uk/pub/reports/duglRAL97031.ps.gz
• UF Sparse Matrix Collection:
http://www.cise.ufl.edu/research/sparse/matrices/
Modelli economici
Ingegneria strutturale
ORANI678
LOCK2232
WM3
BCSSTM13
6
Modellizzazione di oceani
PLAT362
7
8
Problema: Soluzione di un sistema lineare
Ax = b, con A sparsa.
Problema: Soluzione di un sistema lineare
Ax = b, con A sparsa.
Metodi diretti o iterativi?
Metodi diretti o iterativi?
Metodi diretti
Metodi iterativi
Vantaggi:
• sono generalmente più applicabili (non c’è il
problema della convergenza)
• risentono di meno del malcondizionamento
Vantaggi: • non modificano la struttura della matrice: possono
sfruttarne a pieno la sparsità
Svantaggi • richiedono generalmente più memoria in quanto si
può verificare il “fill-in” (riempimento) e cioè la
comparsa, durante il processo di eliminazione, di
nuovi elementi diversi da zero
• richiedono particolari tecniche di riordinamento
9 (per
minimizzare il fill in)
Svantaggi: • sono applicabili solo se il metodo è convergente
• possono richiedere molte iterazioni (si usano
tecniche di accelerazione, precondizionatori...)
Recentemente stanno nascendo approcci di tipo ibrido che
10
combinano metodi diretti ed iterativi (metodi iterativi a blocchi).
Problema del fill-in: esempio
i 1
Metodi Diretti per la
soluzione numerica
di sistemi lineari sparsi
1
10
1
A= 10
1
10
1
k 10
1
10
1
10
1
10
1 y
10
1
0
0
0
0
1
0
0
0
0
1
0
0
0
0
primo passo del
metodo di eliminazione
di Gauss
11
1 {
ii 11 11 1
1111
111
11 y
yy
10
110010 11
0
1010
0
1110
0
100
11
00
1 1 99991 −−
1 −−− 1
011 −−−011
− 110
1010 110000
11
0
10000 110
10000 11
000
99991 −−00
1 1 − 010 1
11 −−011
1010 100 110000
110000 11000
91
9 −01
1
1 1 −0
010 −000
11
1010 100
100 100
100
1 1 −0
1
1
1
9
0
0
0
1
−00
0 −00
19 {{
kk1010 0
100
100
100 100{
12
Problema del fill-in: esempio
i 1
1
10
1
A= 10
1
10
1
k 10
1
10
1
10
1
10
1 y
10
1
0
0
0
0
1
0
0
0
0
1
0
0
0
0
Riordiniamo la matrice A scambiando la prima riga
con l’ultima e la prima colonna con l’ultima:
1 {
i 1
1
10
99
100
− 1
99
− 1
99
− 1
99
1
10
1
10
1
10
1
k 10
Fattorizzazione LU
1
10
− 1
100
98
99
− 1
98
− 1
98
1
10
− 1
100
− 1
99
97
98
− 1
97
1 y
10
− 1
100
− 1
99
− 1
98
96
97 {13
Per una matrice di dimensione 40, avente
la stessa struttura, si ottiene:
Matrice
0
5
5
10
10
15
15
20
1
0
0
0
2
20
0
10
nz = 58
20
0
0
0
5
5
10
10
15
15
20
10
nz = 400
10
nz = 58
20
20
1
0
0
0
0
1
0
0
k1
0
0
1
1
10
1
10
1
10
0
0
1
0
0
0
0
1
0
0
0
0
1
1
10
1
10
1
10
k1
0
1
0
0
3
0
0
1
0
6
0
0
0
1
9
1 y
10
1
10
1
10
1
10
− 3
100 {
1 y
10
1
10
1
10
1
10
1
10 {
14
2
2
2
2
12
1
2
0
20
(nz = numero di elementi non nulli nella matrice)
0
0
Fattorizzazione
LU
10
nz = 58
0
0
i2
0
0
i1
20
0
0
Pr APc =
Fattorizzazione LU
Non c’è fill-in!!
i1
E se “bisogna” utilizzare strategie di pivoting?
Fattorizzazione LU
0
1⎤
⎡0
⎢ 1
⎥
⎢
⎥
Pr = Pc = ⎢
1
⎥
⎢
⎥
1 ⎥
⎢
⎢⎣1
0⎥⎦
15
k
3
− 3
2
− 2
3
0
0
0
0
6
9
−3 − 9
2
−2
−3 − 2
− 1 − 3
2
0
12 y
−4
2
− 2
3
3
5
3
28
9 {
16
Pr APc = LU
I metodi diretti si basano sostanzialmente sull’eleminazione
di Gauss:
Eliminazione di Gauss per matrici dense:
Pr e Pc sono scelte in modo da mantenere la
fattorizzazione della matrice:
stabilità numerica
Pr APc = LU
Eliminazione di Gauss per matrici sparse:
soluzione dei sistemi triangolari:
Pr e Pc sono scelte in modo da mantenere la
stabilità numerica e preservare la sparsità
(minimizzare il fill-in nei fattori L ed U)
⎧ Ly = Pr b
Ax = b ⇔ ⎨
⎩Uz = y
17
x = Pc z
18
Sia Pr APc = LU . Allora:
⎧ Ly = Pr b
Ax = b ⇔ ⎨
⎩Uz = y
Ax = b
x = Pc z
A ∈ Rn
Se la matrice A è considerata densa la risoluzione del
sistema lineare richiede:
Dimostrazione.
Ax = b ⇔ Pr Ax = Pr b ⇔ Pr Ax = Pr b ⇔
⇔ Pr APc ( Pc x ) = Pr b
Ponendo z = Pc x e sostituendo Pr APc = LU , si ottiene
Ax = b ⇔ LUz = Pr b ⇔ ⎧ Ly = Pr b
⎨
⎩Uz = y
19
Complessità di tempo:
n3
+ O (n 2 )
3
Complessità di spazio:
O (n 2 )
Lo scopo degli algoritmi per sistemi sparsi è di ottenere
una complessità, sia di tempo che di spazio, di
O ( n ) + O (τ )
dove τ è il numero di elementi non nulli.
20
Struttura base di codici per la soluzione di
sistemi sparsi mediante metodi diretti:
Struttura base di codici per la soluzione di
sistemi sparsi mediante metodi diretti:
1. ANALISI
1. ANALISI:
Viene analizzata la struttura della matrice in modo da fornire:
a. un opportuno ordinamento (scelta di opportune Pr e Pc) in modo
da minimizzare il fill-in (la struttura di sparsità dei fattori L ed U
dipende dalla struttura di A, e può essere cambiata permutando
righe e/o colonne)
2. FATTORIZZAZIONE
3. RISOLUZIONE
b. opportune strutture dati che permettano di memorizzare soltanto
gli elementi non nulli e di gestire eventuali fill-in, al fine di
ottenere una fattorizzazione efficiente.
2. FATTORIZZAZIONE
3. RISOLUZIONE
21
Struttura base di codici per la soluzione di
sistemi sparsi mediante metodi diretti:
22
Struttura base di codici per la soluzione di
sistemi sparsi mediante metodi diretti:
1. ANALISI
1. ANALISI
2. FATTORIZZAZIONE:
Si costruisce numericamente la fattorizzazione della matrice
riordinata: si determinano L, U (Pr e Pc vengono generalmente
modificate in quanto vengono effettuati anche tests di stabilità).
2. FATTORIZZAZIONE
3. RISOLUZIONE:
Si risolvono i sistemi triangolari ottenuti mediante i metodi di
backward e forward substitution.
3. RISOLUZIONE
23
24
Le fasi 1. e 2. possono essere completamente separate quando si ha
a che fare ad esempio con matrici simmetriche definite positive.
Infatti in questo caso nella fase 1 viene determinato un
ordinamento “ottimale”, che non viene successivamente
modificato in fase di fattorizzazione (non è necessario pivoting).
Matrici a banda
Per problemi non simmetrici si ha generalmente un’unica fase
1.+2. di analisi-fattorizzazione in cui vengono effettuati anche tests
di stabilità per la determinazione dell’ordinamento ottimale.
25
26
q
p
Si dice che una matrice A ha:
• banda superiore q se
aij = 0 per j>i+q
• banda inferiore p se
aij = 0
Le matrici a banda con q<<n e p<<n rappresentano un
significativo esempio di matrice sparsa.
per i>j+p
Esse si ottengono quando le equazioni del sistema possono essere
ordinate in modo tale che ogni incognita xi appaia solo in poche
equazioni vicino alla i-sima (hanno interesse ad esempio nei
modelli di reti).
q
p
27
28
Sia A una matrice con banda superiore q e banda
inferiore p. Se A ammette una fattorizzazione del
tipo:
A=LU,
allora U ha banda superiore q e L ha banda
inferiore p(*).
Quando si applicano strategie di pivoting gli scambi
di righe o di colonne possono distruggere la struttura
a banda. Se si utilizza ad esempio il pivoting parziale:
• U può avere banda di ampiezza p+q
• L ha al più p+1 elementi non nulli per colonna
q
q
L’algoritmo di eliminazione di Gauss è pertanto
particolarmente interessante nel caso in cui non è
richiesta l’operazione di pivoting, come ad esempio
per matrici:
• simmetriche definite positive
• a diagonale dominante
30
p
p
A
U
L
non c’è fill-in al di fuori
delle bande
29
(*) si è supposto di non utilizzare tecniche di pivoting
1b. Memorizzazione:
Una matrice A con banda inferiore p e banda
superiore q può essere memorizzata in una matrice
Aband di dimensione (p+q+1)×n in modo tale che:
Problema: Soluzione di un sistema lineare
Ax = b, con A matrice a banda.
1. ANALISI
A(i, j) = Aband(i - j + q + 1, j)
1a. Non essendoci il problema del fill-in al di
fuori delle bande la fase di riordinamento non
viene effettuata.
1b. Memorizzazione
31
Esempio:
⎛6
⎜
⎜ -1
⎜ -3
⎜
0
A= ⎜⎜ 0
⎜
⎜0
⎜0
⎜
⎜0
⎜0
⎝
-1
6
-1
-1
0
0
0
0
0
-1
-1
6
0
-1
0
0
0
0
0
-2
0
6
-1
-3
0
0
0
p=q=2; n=9
0
0
-1
-1
6
-1
-1
0
0
0
0
0
-1
-1
6
0
-1
0
0
0
0
0
-1
0
6
-1
-1
0
0
0
0
0
-1
-1
6
-1
0⎞
0 ⎟⎟
0⎟
⎟
0⎟
→
0 ⎟ ⎯⎯
⎟
0⎟
-2 ⎟
⎟
-1 ⎟
6 ⎟⎠
Aband: 5×9
⎡0
⎢0
⎢
⎢6
⎢
⎢ -1
⎢⎣-3
0
-1
6
-1
-1
-1
-1
6
0
-1
-2
0
6
-1
-3
-1
-1
6
-1
-1
-1
-1
6
0
-1
-1
0
6
-1
-1
32
-1
-1
6
-1
0
-2⎤
-1⎥⎥
6⎥
⎥
0⎥
0 ⎥⎦
2. FATTORIZZAZIONE
2. FATTORIZZAZIONE
Fattorizzazione LU per una matrice a banda:
q
min(k+p,n)
for k = 1 : n-1
for i = k+1 : n
A(i,k)=A(i,k)/A(k,k)
for j = k+1 : n
A(i,j)=A(i,j)-A(i,k)*A(k,j)
end j
end i
end k
p
min(k+q,n)
metodo di Gauss
33
2. FATTORIZZAZIONE
34
2. FATTORIZZAZIONE
colonna k colonna k+q
colonna k colonna k+q
q
q
p
p
riga k
riga k
riga k+p
riga k+p
35
36
2. FATTORIZZAZIONE
3. RISOLUZIONE
Fattorizzazione LU per una matrice a banda:
for k = 1 : n-1
for i = k+1 : min(k+p,n)
A(i,k)=A(i,k)/A(k,k)
for j = k+1 : min(k+q,n)
A(i,j)=A(i,j)-A(i,k)*A(k,j)
end j
end i
end k
⎧Ly = b
(LU)x = b ⇔ ⎨
⎩Ux = y
p<<n, q<<n
Sostituzioni in avanti per matrici L a banda di lunghezza p:
O(npq) flops
for i=1:n
b(i) = b(i) −
end i
Oss: Nell’implementazione bisogna tenere conto di come è stata
memorizzata la matrice A (mediante la matrice Aband). La
stessa area di memoria è sufficiente per memorizzare anche la
37
fattorizzazione LU.
p<<n
i−1
∑
L(i, j)b(j)
j=max(1,i−p)
O(np) flops
• La soluzione y del sistema Ly=b è memorizzata in b.
• Tener presente che gli elementi di L sono memorizzati
38
nel triangolo inferiore di A
3. RISOLUZIONE
⎧Ly = b
(LU)x = b ⇔ ⎨
⎩Ux = y
Sostituzioni all’indietro per matrici U a banda di lunghezza q:
for i=n:-1:1
min(i+q,n)
⎛
⎞
b(i) = ⎜ b(i) − ∑ U(i, j)b(j) ⎟ / u(i,i)
j=i+1
⎝
⎠
end i
q<<n
Matrici tridiagonali
O(nq) flops
• La soluzione y del sistema Ux=b è memorizzata in b.
• Tener presente che gli elementi di U sono memorizzati
nel triangolo superiore di A
39
40
FATTORIZZAZIONE LU DI MATRICE
TRIDIAGONALE
⎛ a1
⎜b
⎜ 2
⎜0
A=⎜
⎜ M
⎜0
⎜
⎝
⎛1 0
⎜β
⎜ 2 1
⎜ 0 β3
L=⎜
⎜ M M
⎜0 0
⎜⎜
⎝0 0
c1
a2
b2
0
c2
a3
M
0
0
O O O
K K b n −1
K K 0
0
0
1
0
0
c3
0
0
0
K
K
K
0
0
0
0
0
0
M
a n −1
bn
K
K
K
M
1
O O O
K K βn−1
K K 0 βn
⎞
⎟
⎟
⎟
⎟
M ⎟
c n −1 ⎟
⎟
an ⎠
0
0
0
Algoritmo di Thomas
(Gauss senza pivoting se la
matrice è a diagonale
dominante)
La matrice tridiagonale è
memorizzata nei tre
vettori a, b, c
0⎞
⎛α 1 c 1
⎟
⎜0 α
0⎟
2
⎜
0⎟
⎜0 0
⎟ U= ⎜
M⎟
⎜M M
⎜0 0
0⎟
⎜⎜
⎟⎟
1⎠
⎝0 0
0
0
0
c2
0 0
α3 0 0
O O O
K K 0
K K 0
0 ⎞
K
0 ⎟⎟
K
0 ⎟
⎟
M
M ⎟
α n−1 c n−1 ⎟
⎟
41
0 α n ⎟⎠
K
Begin
% Calcolo la fattorizzazione
LU
alfa1 = a1
For k=2 to n
betak= bk/ alfa k-1
alfa k = ak - betak c k-1
end k
% Soluzione del sistema
Ux=y
xn = yn / alfa n
For i =n-1 to 1 (step -1)
xi = (yi - c i x i+1)/alfa i
end i
end
% Soluzione del sistema Ly=b
y1 = b1
For i =2 to n
yi = bi - beta i y i-1
end i
42
Matrici sparse non strutturate
In questo caso si lavora generalmente direttamente sui
numeri e l’ordinamento ottimale viene determinato
mediante
un’unica
fase
di
ANALISI
+
FATTORIZZAZIONE in cui vengono effettuati anche
tests di stabilità.
Matrici sparse non
strutturate
43
44
Rappresentazione mediante coordinate (CS):
1b. Memorizzazione:
La matrice A viene memorizzata mediante tre vettori:
Rappresentazione mediante coordinate
• Elm
contiene gli elementi non nulli di A
• Rnr
contiene gli indici di riga degli elementi di Elm;
• Cnr
contiene gli indici di colonna degli elementi di Elm
Schema orientato per righe (compressed row
storage = CSR)
Schema linked list (lista concatenata)
45
46
Rappresentazione mediante coordinate (CS):
Schema orientato per righe (compressed
row storage =CSR)
La matrice A viene memorizzata mediante quattro vettori:
Esempio:
47
• Elm
contiene gli elementi non nulli di A
• Cnr
contiene gli indici di colonna degli elementi di Elm;
• Rst
Rst(k) contiene la posizione in Cnr ed Elm del primo
elemento non nullo nella k-sima riga di A.
• Rlg
Rlg(k)-1 rappresenta il numero di elementi non nulli
della riga k-sima.
48
Schema orientato per righe (compressed
row storage =CSR)
Schema orientato per righe (compressed
row storage =CRS)
akj
j
Gli elementi della k-sima riga si
trovano nelle posizioni da Rst(k)
fino a Rst(k)+Rlg(k) del vettore
Elm
Il vettore Rlg è superfluo se le righe di A sono memorizzate in ordine
49
Il vettore Rlg è superfluo se le righe di A sono
memorizzate in ordine:
Schema linked list
Esempio
⎛
⎜
⎜
⎜
A = ⎜
⎜
⎜
⎜
⎜
⎝
9
4
0
6
− 2
0
0
0
−1
0
0
−1
0
0
0
− 2
3
0
0
0
2
0
0
0
4
0
0
0
− 3
0
0⎞
⎟
0⎟
5⎟
⎟
0⎟
0⎟
⎟
7 ⎟⎠
Elm = ( 9 −2 −1 4 6 3 5 −1 2 −2 4 −3 7 )
Cnr = (1
Rst =
(1
3
4
5
6
1
2 3 6
8
1 4
10 12 14 )
50
2
5
4 6)
51
La matrice A viene memorizzata mediante:
• Elm: contiene gli elementi non nulli di A.
• Cnr: contiene gli indici di colonna degli elementi di Elm;
• Rst: Rst(k) contiene la posizione in Cnr ed Elm del primo
elemento non nullo nella k-sima riga di A.
• Ptr : Ptr(p) rappresenta l’indice della posizione in Elm
dell’elemento successivo della riga a cui Elm(p) appartiene. Se
Elm(p) è l’ultimo elemento di una riga allora Ptr(p) assumerà il
valore di un indice non esistente: se Elm(p) è l’ultimo elemento
della i-sima riga, allora Ptr(p)=na+i.
• Vac: contiene l’indice della prima posizione vuota.
Elm e Cnr contengono in genere anche delle posizioni vuote (hanno dimensione na
strettamente maggiore del numero di elementi non nulli nz), al fine di gestire eventuali
52
fill-in (anche le posizioni vuote sono collegate tramite il puntatore Ptr)
Schema linked list
Schema linked list
Le posizioni libere vengono denotate con *. Utilizziamo na=17, vac=5.
…
nxt
akj …
2
…
j2 …
…
nxt1 …
53
54
Operazione base del metodo di Gauss
2. Fattorizzazione:
In corrispondenza di ciascuno schema di memorizzazione
si utilizzano opportune tecniche per:
Implementare l’operazione base del metodo di Gauss:
w=A(i,:)+m*A(k,:)
(sommare alla riga i-sima della matrice A, la riga k-sima
moltiplicata per uno scalare m).
Gestire il fill-in:
se il vettore w contiene più elementi non nulli rispetto alla
riga i-sima della matrice A, allora siamo in presenza di un
55
fill-in.
w=A(i,:)+m*A(k,:)
Rappresentazione mediante coordinate (CS):
for j=1,…,n
w(j)=0
Elm(p) appartiene alla riga i-sima
end j
Elm(p) appartiene alla riga k-sima
for p=1,…,nz
if Rnr(p)=i
w(Cnr(p))=w(Cnr(p))+Elm(p)
elseif Rnr(p)=k
w(Cnr(p))=w(Cnr(p))+m*Elm(p)
end if
56
end p
Operazione base del metodo di Gauss
Operazione base del metodo di Gauss
w=A(i,:)+m*A(k,:)
w=A(i,:)+m*A(k,:)
Schema linked list
Schema orientato per righe (CRS)
Indirizzamento indiretto:
si riempie l’elemento di w
di indice corrispondente
alla colonna a cui
appartiene Elm(p)
scorre la riga i-sima
for j=1,…,n
w(j)=0
end j
scorre la riga k-sima
for p=Rst(i),…,Rst(i)+Rlg(i)
w(Cnr(p))= Elm(p)
end p
for p=Rst(k),…,Rst(k)+Rlg(k)
w(Cnr(p))=w(Cnr(p))+m*Elm(p)
end p
57
Gestione del fill-in
for j=1,…,n
w(j)=0
individua il primo elemento della riga i-sima
end j
p=Rst(i)
while p<=na
w(Cnr(p))=Elm(p)
p=Ptr(p)
passa all’elemento successivo della riga i-sima
end p
p=Rst(k)
While p<=na
w(Cnr(p))=w(Cnr(p))+m*Elm(p)
p=Ptr(p)
58
end p
Gestione del fill-in
Schema orientato per righe (CRS)
Rappresentazione mediante coordinate (CS):
spazio libero
Basta aggiungere i nuovi elementi non nulli alla fine
di vettori Elm, Cnr e Rnr
59
elementi di L
elementi di A(i,k:n)
•Ust: Ust(i) indica il punto in cui nella i-sima riga di A iniziano
gli elementi della parte attiva di A.
1. Si copiano gli elementi di L nello spazio libero e si calcola
m=A(i,k)/A(k,k).
2. Si effettua l’operazione w=A(i,:)+m*A(k,:)
3. Si spostano gli elementi non nulli di w nello spazio libero
lasciando zeri in w
4. Le posizioni Rst(i)…Rst(i)+Rlg(i) sono denotate come vuote
e
60
vengono aggiurnati Rst(i), Ust(i) e Rlg(i)
METODO DI GAUSS
per matrici sparse non strutturate
Gestione del fill-in: Schema linked list
Supponiamo che ci sia un fill-in nella posizione (i,j)
e denotiamo con a l’elemento da inserire
Fattorizzazione:
w è un vettore temporaneo utilizzato per
effettuare l’operazione base del metodo
di Gauss (come descritto nelle slides
precedenti), ulilizzando la
memorizzazione della matrice in formato
compresso (es. CRS o linked list).
for k=1:n-1
Si memorizza l’elemento a nella posizione new
corrispondente alla prima posizione vuota vac
for i=k+1:n
Si aggiorna l’indice della
prima posizione vuota
m=-aik/akk
w=A(i,:)+m*A(k,:)
Se l’indice di colonna j di a è più
piccolo dell’indice di colonna Cnr(p)
del primo elemento non nullo della
riga i-sima allora la riga i.sima inizia
nella posizione new.
Nel momento in cui si arresta questo
ciclo si avrà Cnr(p0)<j<Cnr(p) per
cui la posizione new sarà tra p0 e p.
61
A(i,:)
w
bi=bi+m*bk
Il vettore w deve essere poi
memorizzato nella riga i-sima
della matrice A.
Trasformazione del vettore dei
termini noti
end
end
Una volta effettuata la fattorizzazione bisogna risolvere il sistema triangolare
superiore Ax=b utilizzando il metodo di sostituzione all’indietro e tenendo conto
62
della memorizzazione della matrice A in formato compresso.
Schema di Markowitz: ordinamento (per
minimizzare il fill-in ed assicurare stabilità )
Schema di Markowitz: ordinamento (per
minimizzare il fill-in ed assicurare stabilità )
- Minimizzare il fill-in
La strategia consiste, ad ogni passo dell’eliminazione di Gauss,
nello scegliere come elemento pivot l’elemento non nullo della
matrice ridotta per il quale risulti minimo il prodotto tra il numero
di elementi non nulli della riga a cui appartiene ed il numero di
elementi non nulli della colonna a cui appartiene.
Sono richiesti anche controlli per la stabilità numerica utilizzando
una strategia di pivoting parziale con un parametro di soglia u.
ri( k )
Numero di entrate nella riga i-sima della marice ridotta
c(jk )
Numero di entrate nella colonna j-sima della marice ridotta
Il criterio di Markowitz seleziona come elemento pivot l’elemento
a (k)
pq della matrice ridotta che soddisfa:
(rp( k) − 1) * (c(qk) − 1) = min ⎡⎣(ri( k) − 1) * (c(jk) − 1) ⎤⎦
i, j≥ k
63
64
Schema di Markowitz: ordinamento (per
minimizzare il fill-in ed assicurare stabilità )
- Assicurare la stabilità
Il criterio di Markowitz seleziona come elemento pivot l’elemento
a (k)
pq della matrice ridotta che soddisfa:
a (pqk) ≥ u * max a (iqk )
Matrici simmetriche
definite positive
i = k,...,n
0 ≤ u ≤ 1 parametro di soglia
(nella pratica spesso si utilizza u=0.1)
In Matlab:
[L,U,P,Q] = LU(X,u)
65
66
Ordinamenti che minimizzano il fill-in
Matrici simmetriche definite positive
In questo caso le fasi di fattorizzazione ed analisi possono
essere completamente separate.
Algoritmo di grado minimo
In Matlab:
s=symmmd(A)
p=symamd(A)
(Essendo la matrice definita positiva non si effettuano
strategie di pivoting).
B=A(s,s)
matrice riordinata
B=A(p,p)
I comandi symmmd e symamd implementano l’algoritmo di grado minimo in
maniera leggermente diversa (symamd è più recente di symmmd).
Algoritmo di Cutchill-Mckee (teoria dei grafi)
In Matlab:
67
r=symrcm(A)
B=A(r,r)
matrice riordinata
68
Cutchill-Mckee
(symrcm)
nessun riordinamento
A
grado minimo
(symmmd)
A(r,r)
0
0
20
20
40
40
60
0
A(s,s)
60
50
0
nz = 240
chol(A)
grado minimo
(symamd)
0
20
20
40
40
60
0
50
nz = 240
chol(A(r,r))
A(p,p)
0
60
50
0
nz = 240
chol(A(s,s))
0
0
0
0
20
20
20
20
40
40
40
40
60
60
0
50
nz = 1022
0
50
60
0
50
70
nz = 636
Matrici sparse in Matlab
A = bucky+4*speye(60);
s = symmmd(A);
50
nz = 660
nz = 978
I grafici riportati nelle due slides precedenti sono
stati ottenuti mediante il codice Matlab:
r = symrcm(A);
60
0
69
50
nz = 240
chol(A(p,p))
S = sparse(A) converte una matrice A dal formato pieno al formato
sparso
p = symamd(A);
A = full(S)
S = A(s,s);
P = A(p,p);
subplot(2,2,1), spy(S), title('A(s,s)')
subplot(2,2,2), spy(P), title('A(p,p)')
subplot(2,2,3), spy(chol(S)+(chol(S))'), title('chol(A(s,s))')
subplot(2,2,4), spy(chol(P)+(chol(P))'), title('chol(A(p,p))')
n = nnz(S)
spy(S)
figure(2)
R = A(r,r);
subplot(2,2,1), spy(A), title('A')
subplot(2,2,2), spy(R), title('A(r,r)')
subplot(2,2,3), spy(chol(A)+(chol(A))'), title('chol(A)')
subplot(2,2,4), spy(chol(R)+(chol(R))'), title('chol(A(r,r))')
71
converte una matrice S dal formato sparso al formato
pieno
numero di elementi non nulli della matrice S
Il comando spy(S) permette di visualizzare la sparsità di una
matrice generndo un grafico nel quale sono evidenziati con
un punto solo gli elementi di S che sono diversi da zero.
72