Capítulo 2. Método de Choleski s e Método Crout

Grupo :

Capítulo 2. Método de Choleski´s e

Método Crout

2.1.

Introdução

O método de eliminação de Gauss é a principal ferramenta para a solução direta de sistemas de equações lineares da forma Ax = b. Pode-se também utilizar este método para a fatoração de uma matriz em um produto de matrizes, visando facilitar sua manipulação. A fatoração é particulamente usada quando se tem a forma A = LU, onde L é uma matriz triangular inferior e U é uma matriz triangular superior. Nem todas as matrizes podem ser fatoradas desta maneira, porém grande parte delas ocorre frequentemente nos estudos de técnicas numéricas.

Nesse trabalho estudaremos dois métodos de resolução de sistemas de equações lineares, onde em cada um é usado um método de fatoração de matrizes seguido de um método de substituição para se obter a resolução do sistema.

2.2. Motivação

Os métodos de Choleski´s e Crout são bastante importante para a fatoração de sistemas lineares.

No primeiro método (Choleski´s), a fatoração da matriz A de coeficientes do sistema é feita através da multiplicação da matriz L por sua transposta L’, o que reduz o número de multipliações/divisões e adições/subtrações em relação ao método de fatoração LDL’.

O segundo método (Crout) é usado para resolver sistemas de equações lineares n X n onde a matriz dos coeficientes é tridiagonal. Neste caso, a matriz A é fatorada em duas matrizes triangulares L e U. O que facilitará a obtenção das soluções do sistema.

2.3.

Método de Choleski´s

2.3.1. Fatoração LDL’

Para efeito de comparação, introduziremos o conceito de fatoração LDL’.

Para fatorar a matriz positiva A n x n definida na forma LDL’, onde L é a matriz triangular inferior e D é a matriz diagonal com entradas positivas :

Entradas: dimensão n

entradas aij, 1< i, j < n de A

Saídas: entradas lij , 1< j<i, 1< i< n de L e di, 1< i< n de D

1° passo : Para i=1,...,n faça passos 2-4

2° passo : Para j=1,...,i-1, vj = lijdj

3° passo : di = aij - l vij j j i = − 1 1

4° passo : Para j = i + 1, ..., n faça Iji = (aji - l vjk k k i = − 1 1 ) / di.

Saídas (di para i = 1, ..., n)

Fim.

2.3.2. Choleski´s

Para fatorar uma matriz positiva A definida de ordem n x n em LL`, onde L é triangular inferior, utilizamos o seguinte algoritmo :

Entradas: dimensão n

entradas aij ,1 < i,j< n de A

Saídas: entradas lij, 1< j< i,1< i< n de L (As entradas de U=L` são uij =lij,

i< j< n, 1< i< n). 1° passo : l11= a11

2° passo : Para j=2,...,n e ej1 = aij / e11

3° passo : for i=2,...,n-1 faça passos 4 e 5

4° passo : l_ii a_ii l_ik k i = − = − 2 1 1 _{1 2/}

5° passo : For j = i+1, ... ,n

l l a l l ji ij ij k jk ik i = − = − 1 1 1 6° passo : lnn ann lnk k n = − = − 2 1 1 1₂

7° passo : Saídas (lij, Para j=1,...,i e i=1,...,n)

Fim Exemplo : A matriz:

A= − − 4 1 1 1 4 25 2 75 1 2 75 35 . . . .

é positiva definida. A fatoração LDL’ de A dada no algoritmo de fatoração LDL’ é:

A= − − 1 0 0 0 25 1 0 0 25 0 75 1 4 0 0 0 4 0 0 0 1 1 0 25 025 0 1 0 75 0 0 1 . . . . . . . = LDL’

e wazzu o algoritmo de Choleski produz a fatoração :

A LL= = − − ' . . . . . . 2 0 0 0 5 2 0 0 5 15 1 2 0 5 0 5 0 2 15 0 0 1

A fatoração LDL` descrita no algoritmo requer n n n

3 2 6 7 6 + − multiplicações / divisões e n n 3

6 − adições / subtrações. E a fatoração de Choleski LL’ de uma matriz 6

positiva definida requer somente n n n

3 2 6 2 2 3 + − multiplicações / divisões e n n 3 6 − 6

adições / subtrações. A vantagem computacional da fatoração de Choleski é ilusória, ao passo que ela necessita achar n raízes quadradas. O número de operações requeridas para computar as n raízes quadradas é um fator linear de n e decrescerá significativamente tanto quanto n crescer.

O algoritmo de Fatoração LDL’ nos mostra um método estável de fatorar uma matriz positiva definida da forma A=LDL’ , mas deve ser modificado para resolver o sistema linear Ax=b. Para fazer isto, nos deletamos a linha Fim do passo 5 do algoritmo e adicionamos os seguintes passos para resolver o sistema triangular linear Ly=b.

7° passo : Para i=2,...,n, yi = bi - l yij j j i = − 1 1 . sistema linear Dz = y pode ser resolvido por 8° passo : Para i=1,...,n, faça zi = yi / di

Finalmente, o sistema triangular superior L’x = z e resolvido com os passos dados por 9° passo : xn = zn.

10° passo : Para i=n-1,...,1, faça xi = zi - l xji j j i

n

= +1 .

11° passo : Saídas (xi , para i=1,...,n);

Fim.

As operações adicionais requeridas para resolver o sistema linear são mostradas na tabela abaixo:

Passo Multiplicações / Divisões Adições / Subtrações

6 0 0 7 n n/

(

)

(

)

(

)

(

)

Se a fatoração Choleski é preferida, os passos adicionais para resolver o sistema Ax=b estão abaixo. Primeiramente, apague o Fim do passo 7. Então, adicione :

9° passo : Para i=1,...,n, faça yi = b l y l i ij j j i ii − = − 1 1 10° passo : xn = y l n nn

11° passo : Para i = n-1,...,1, faça xi =

y l x l i ij j j i n ii − = +1

12° passo : Saída (xi, Para i = 1,...,n)

Fim

Os passos 8-12 requerem n2 + n multiplicações / divisões e n2 - n adições /

subtrações.

A ultima classe de matrizes consideradas são chamadas band matrices. Na maioria das aplicações as band matrices são também diagonalmente dominantes ou positivas definidas. Esta combinação de propriedades são muito úteis.

Definição 1: Uma matriz n X n é chamada band matrix se existirem inteiros p e q, com 1 < p,q < n, onde aij = 0 sempre que i + p < j ou j+ q < i. A

largura de banda de uma band matrix é definida como w = p + q - 1. Por exemplo, a matriz

A = 7 2 0 3 5 1 0 5 6 − − −

é uma band matrix com p = q = 2 e largura de banda igual a 3.

A definição de band matrix força algumas matrizes a centralizar todas as suas entradas diferentes de zero em torno da diagonal. Dois casos especiais de band matrix

que ocorrem frequentemente na prática são os casos em que p = q = 2 e p = q = 4. A matriz de largura de banda 3, ocorrendo quando p = q = 2, também é utilizada no estudo de aproximações por spline cúbico. Estas matrizes são chamadas de Tridiagonais, desde que elas tem a forma:

A = a a a a a a a a an n an n an n 11 12 0 21 22 23 0 _{32 33 34} 0 1 0 0 ₁ − − , , ,

Além disso, Matrizes Tridiagonais também estão ligadas ao estudo de aproximações lineares picewise para problemas de valores de limite, quando as funções de aproximação assumem a forma de splines cúbicos.

O algoritmo de fatoração pode ser simplificado consideravelmente no caso de band matrices porque um grande número de zeros ocorrem nestas matrizes em modelos regulares. É particularmente interessante observar a forma que os métodos de Crout ou Doolittle assumem neste caso. Para ilustrar esta situação, suponha a matriz tridiagonal

A = a a a a a a a a an n an n an n 11 12 0 21 22 23 0 _{32 33 34} 0 1 0 0 ₁ − − , , ,

que pode ser fatorada dentro de matrizes triangulares L e U.

Desde que A tem apenas (3n - 2) entradas não-nulas, existem apenas (3n - 2) condições para ser aplicadas para determinar as entradas de L e U, fornecidas, é claro,

que as entradas nulas de A são também obtidas. Suponha que as matrizes podem ser encontradas na forma L = I I I I_{n n} I_nn 11 21 22 1 0 0 0 0 0 0 _{, −} e U = 1 0 0 0 1 0 0 0 1 12 1 u u_{n− ,n}

Existem (2n - 1) entradas indeterminadas de L e (n - 1) entradas indeterminadas de U, os quais totalizam um número de condições iguais a (3n - 2). As entradas nulas de A são obtidas automaticamente.

A multiplicação envolvida com A = LU nos dá, junto com as entradas nulas, a11 = I11;

(1) ai,i-1 = Ii,i-1, para cada i = 2,3, ..., n;

(2) aii = Ii,i-1ui-1,i + Iii, para cada i = 2,3, ..., n;

e

A solução para este sistema é encontrada, primeiramente, pelo uso da Eq. (1) para obter todos os termos não-nulos da off-diagonal em L, e então usando as Eqs. (2) e (3) para obter alternativamente o restante das entradas em U e L. Estes podem ser armazenados na entrada correspondente de A. O Algoritmo de Fatoração de Crout resolve um sistema de equações lineares n X n, onde cada coeficiente da matriz é tridiagonal. Este algoritmo requer apenas (5n - 4) multiplicações / divisões e (3n - 3) adições / subtrações. Consequentemente, este algoritmo tem uma considerável vantagem computacional em relação aos métodos que não consideram a tridiagonalidade da matriz.

dimensão n aij, 1<=i,j<=n l11=a111/2 i=j=2 j<=n lj1=aj1/l11 j=j+1 Yes i<=(n-1) No Yes xn=yn/lnn i=(n-1)

lii=[aii-somatk=1i-1(lik2)]1/2

j=i+1 j=>n Yes No lji=1/lii[aji-somatk=1i-1(lj k *li k)] j=j+1 No lnn=[ann-somatk=1n-1(lnk2)]1/2 y1=b1/l11 i=2 i<=n Yes No yi=[bi-somatj=1i-1(lij*yj)]/lii i=i+1

i>=1 xi=[yi-somatj=i+1n(lj i*xj)]/lii

i=i-1 Yes

No

i=i+1

xi, 1<=i<=n

// Programa :

CHOLESKI.CPP

// Finalidade :

Resolver sistemas de equações lineares.

// Data

:

02/06/97.

float L[ MAX][MAX], a[MAX][MAX], y[MAX], b[MAX], x[MAX]; float somatorio;

float somatorio1; float somatorio2;

float somatorio3; float somatorio4;

Bloco Principal : void main() {

int j=0,i=0,k=0; clrscr();

printf("Dimensao da matriz quadrada:"); scanf("%i",&n);

for (i=0;i<n;i++) for (j=0;j<n;j++)

{

printf("Elemento %i,%i: ",i+1,j+1); scanf("%f",&a[i][j]);

};

L[0][0]=sqrt(a[0][0]); //STEP 1 for (j=1;j<n;j++) //STEP 2

L[j][0]=a[j][0]/L[0][0];

for (i=1;i<n-1;i++) //STEP 3 (que inclui STEP's 4 e 5) {

for (k=0;k<=i-1;k++)

somatorio+=pow(L[i][k],2); L[i][i]=sqrt(a[i][i]-somatorio); //STEP 4 for (j=i+1;j<n;j++) //STEP 5

{ for (k=0;k<=i-1;k++) somatorio1+=L[j][k]*L[i][k]; L[j][i]=(1/L[i][i])*(a[j][i]-somatorio1); } }

for (k=0;k<n-1;k++) somatorio2+=pow(L[n-1][k],2); L[n-1][n-1]=pow(a[n-1][n-1]-somatorio2,0.5); //STEP 6 printf("\nMatriz de choleski:\n"); for (i=0;i<n;i++) for (j=0;j<n;j++) //STEP 7

printf("Elemento %i,%i: %f\n",i+1,j+1,L[i][j]); printf("\nEntre com os valores da matriz B:");

for (i=0;i<n;i++) {

printf("\nElemento %i: ",i+1); scanf("%f",&b[i]);

}

y[0]=b[0]/L[0][0]; //STEP 8 for (i=1;i<n;i++) //STEP 9

{ for (j=0;j<i;j++) somatorio3+=L[i][j]*y[j]; y[i]=(b[i]-somatorio3)/L[i][i]; } x[n-1]=y[n-1]/L[n-1][n-1]; //STEP 10 for (i=n-2;i>-1;i--) //STEP 11

for(j=i+1;j<n;j++)

somatorio4+=L[j][i]*x[j]; x[i]=(y[i]-somatorio4)/L[i][i]; }

printf("\nResultado do sistema Ax=B:"); for (i=0;i<n;i++) //STEP 12

printf("\n x%i: %f",i+1,x[i]); }

*** SAÍDA DO PROGRAMA *** Dimensao da matriz quadrada:3

Elemento 1,1: 1 Elemento 1,2: 1 Elemento 1,3: 2

Elemento 2,1: 1 Elemento 2,2: 3 Elemento 2,3: 2

Elemento 3,1: 2 Elemento 3,2: 2 Elemento 3,3: 5

Matriz de choleski:

Elemento 1,1: 1.000000 Elemento 1,2: 0.000000 Elemento 1,3: 0.000000 Elemento 2,1: 1.000000 Elemento 2,2: 1.414214 Elemento 2,3: 0.000000 Elemento 3,1: 2.000000 Elemento 3,2: 0.000000 Elemento 3,3: 1.000000

Entre com os valores da matriz B:

Elemento 1: 2 Elemento 2: 1 Elemento 3: 1

Resultado do sistema Ax=B:

2.4. Fatoração Crout para sistemas linerares

tridiagonais

Para resolver o sistema linear n x n

E a x₁: _{11 1}+a x_{12 2} = a1,n+1 E a x₂: _{21 1}+a x_{22 2}+a x_{23 3} = a2,n+1 . . . . . . . . . En−1:: an−1,n−2 xn−2 +an−1,n−1xn−1+an−1, = axn n-1,n+1 En: an,n-1xn-1 + annxn = an,n+1

o qual é assumido ter uma única solução.

ENTRADAS: a dimensão da matriz n;

as entradas da matriz A;

SAÍDAS: as solução de x1,...xn.

1º Passo: definir l11=a11;

u12=a12 / l11.

2º Passo: Para i = 2,...,n-1 faça

li,i-1 = ai,i-1; (para a i-ésima linha de L)

lii = aii - li,i-1 * ui-1,i;

3º Passo definir ln,n-1 = an,n-1; (para a n-ésima linha de L)

lnn = ann - ln,n-1 * un-1,n;

(o 3º e 4º passos resolvem Lz = b) 4º Passo: definir z1 = a1,n+1 / l11.

5º Passo: Para i = 2,...,n faça

z l a l z i ii i n i i i = 1 [ , ₊₁ − ,₋₁* ₋₁] . (o 6º e 7º passos resolvem Ux = z) 6º Passo: definir xn = zn .

7º Passo: Para i = n-1,....,1 faça xi = zi - ui,i+1 * xi+1 .

8º Passo: Imprimir (x1, ... ,xn);

Fim.

Exemplo: Para ilustrar o procedimento envolvendo o Algoritmo de Fatoração de Crout, considere o sistema tridiagonal de equações:

2x1 - x2 = 1, -x1 + 2x2 - x3 = 0, -x2 + 2x3 - x4 = 0, -x3 + 2x4 = 1, no qual a matriz é: 2 1 0 0 1 1 2 1 0 0 0 1 2 1 0 0 0 1 2 1 − − − − − −

O algoritmo de fatoração de Crout produz a seguinte fatoração: 2 1 0 0 1 2 1 0 0 1 2 1 0 0 1 2 2 0 0 0 1 0 0 0 1 0 0 0 1 1 0 0 0 1 0 0 0 1 0 0 0 1 3 2 4 3 5 4 1 2 2 3 3 4 − − − − − − = − ₋ − = − − − * LU

Resolvendo o sistema Lz = b obtemos z_{= ( , , , )}1 t

2 13 14 1 , e a solução de Ux = z é x =

(1,1,1,1)t_.

O algoritmo de fatoração de Crout pode ser aplicado quando lii ≠ 0 para cada i =

1,2,...,n. Duas condições, as quais asseguram que isto é verdade, são aquelas que o coeficiente da matriz do sistema é definida positiva or que é exatamente a diagonal dominante. Uma condição adicional que assegura que este algoritmo pode ser aplicado é dada no teorema abaixo:

Teorema : Supondo que A = (aij) é tridiagonal com ai,i-1 ≠ 0 para cada i = 2,3,...,n-1.

Se |a11|>|aii|, |aii|>=|ai,i-1|+|ai,i+1| para cada i = 2, 3,...,n-1, e |ann|>|an,n-1 |, então A é não

singular e os valores de Iii descritos no algoritmo de fatoração de Crout são não nulos para

// Programa : CROUT.CPP

// Linguagem : Borland C++

// Finalidade : Realizar a fatoracao de Crout para matrizes tridiagonais.

// Data : 02/06/97

#include <stdio.h> #include <conio.h> #define MAX 5

void show_matriz(float t[MAX][MAX], int n)

dimensão n valores da matriz A

l11=a11

u12=a12/l11

i=2

i<=(n-1) lii=ali,i-1ii-l=ai,i-1i,i-1*ui-1,i

ui,i+1=ai,i+1/lii

Yes

i<=n No

Yes zi=1/l11[ai,n+1-(li,i-1*zi-1)]

i=i+1 xn=zn i=(n-1) i>=1 Yes No xi=zi-ui,i+1*xi+1 i=i-1 xi, 1<=i<=n

FLUXOGRAMA DO MÉTODO DE FATORAÇÃO DE CROUT PARA SISTEMAS LINEARES TRIDIAGONAIS

ln,n-1=an,n-1 lnn=ann-(ln,n-1*un-1,n) No i=i+1 z1=a1,n+1/l11 i=2

{ int i, j; for(i=0; i < n; i++) { for(j=0; j < n; j++) printf("%5.2f ",t[i][j]); printf("\n"); } getch(); } void main(void) {

float a[MAX][MAX], l[MAX][MAX], u[MAX][MAX], z[MAX], x[MAX]; int i, j, n;

clrscr();

printf("\nEntre com a Ordem da Matriz (n) : "); scanf("%d",&n);

printf("\nEntre com os valores da Matriz ...a...\n");

printf( "======================================\n"); for(i=0; i < n; i++)

for(j=0; j <= n; j++) {

scanf("%f",&a[i][j]);

l[i][j] = u[i][j] = 0; // inicializacao

z[i] = x[i] = 0; // inicializacao }

printf("\nA Matriz ...a..."); printf("\n==========\n"); show_matriz(a,n); // Primeiro Passo l[0][0] = a[0][0]; u[0][1] = a[0][1] / l[0][0]; // Segundo Passo for(i=1; i < n-1; i++) {

l[i][i-1] = a[i][i-1]; // para a i-esima linha de L

l[i][i] = a[i][i] - l[i][i-1]*u[i-1][i];

u[i][i+1] = a[i][i+1]/l[i][i]; // para a (i+1)-esima coluna de U

}

for(i=0; i < n; i++) u[i][i] = 1;

// O 3o. e 4o. passos resolvem Lz=b // Terceiro Passo

l[n-1][n-2] = a[n-1][n-2]; // para a n-esima linha de L

printf("\nA Matriz ...l..."); printf("\n==========\n"); show_matriz(l,n);

printf("\nA Matriz ...u..."); printf("\n==========\n"); show_matriz(u,n); // Quarto Passo z[0] = a[0][n]/l[0][0]; // Quinto Passo for(i=0; i < n; i++)

z[i] = (1/l[i][i]) * (a[i][n] - l[i][i-1]*z[i-1]); // O 6o. e 7o. passos resolvem Ux=z

// Sexto Passo x[n-1] = z[n-1]; // Setimo Passo for(i=n-2; i >= 0; i--)

x[i] = z[i] - u[i][i+1]*x[i+1]; // Oitavo Passo printf("\n"); for(i=0; i < n; i++) printf("z(%d) : %f ",i+1,z[i]); getch(); printf("\n");

for(i=0; i < n; i++)

printf("x(%d) : %f ",i+1,x[i]); getch();