Mtodos Computacionais Numricos e

Algbricos com Maple

Mtodos Diretos para Sistemas de Equaes Lineares
Fernando Deeke Sasse
CCT - UDESC

fernandodeeke@gmail.com

Eliminao de Gauss Simples

Consideremos o sistema linear de equaes algbricas.
xCyCz = 3
3 xC2 yC3 z = 2
2 x C 4 y C 5 z =K1
Um modo de resolver este sistema fazer simplificaes sucessivas at que ele possa ser resolvido por
retrosubstituio. Qualquer sistema linear pode sofrer as seguintes operaes, sem que sua soluo
seja alterada:
1. Multiplicao de qualquer equao por um nmero diferente de zero;
2. Soma de equaes;
3. Troca da ordem das equaes;
4. Troca da ordem das variveis.
Estas operaes, chamadas de operaes elementares, podem ser mais sistematicamente implementadas
atravs da representao matricial. O sistema pode ser reescrito como A X = B, onde
1 1 1
3
x
A=

3 K2 2 , B =
2

4 5

2 , X=
K1

y ,
z

ou seja,
1

1 1

3 K2 2

y =

2 4 5
z
K1
Para evitar ter que escrever a matriz de variveis X a cada passo, definimos a matriz aumentada:
1 1 1 3
Au = A B =

3 K2 2
2

2 .

4 5 K1

O mtodo de eliminao de Gauss consiste em usar as operaes elementares sobre linhas para reduzir
a matriz aumentada a uma forma triangular superior. Ou seja, comeamos eliminando os elementos
abaixo do primeiro elemento da linha 1. O primeiro elemento de cada linha chamado de pivot. Uma
vez realizado este passo, o procedimento se repete, agora zerando os elementos abaixo do pivot da
segunda linha, e assim por diante, at a forma escalonada ser alcanada. Usemos este procedimento no
nosso exemplo:
1. A linha 2 somada linha 1 vezes (-3):
1 1 1 3
Au1 =

0 K5 K1 K7
2

5 K1

2. A linha 3 somada linha 1 vezes (-2):

1 1 1 3
Au2 =

0 K5 K1 K7
0

3 K7

3. A linha linha 2 somada linha 1 vezes (2/5):

1 1
1
3
Au3 =

0 K5 K1

K7

13
49
K
5
5
O sistema agora pode ser resolvido por retrosubstituio. A ltima linha implica:
13
49
49
z =K
, ou seja, z =K
.
5
5
13
Da segunda linha,
1
1
49
28
K5 y K 1 z =K7, y =
7Kz =
7C
=
.
5
5
13
13
Da primeira linha temos:
28
49
60
x C y C z = 3, x = 3 K y K z = 3 K
C
=
13
13
13
60
28
49
Portanto, a soluo do sistema de equaes x =
,y=
, z =K
.
13
13
13
0

Repetiremos os passos acima utilizando comandos do Maple, utilizando o comando RowOperation

da biblioteca LinearAlgebra. A sintaxe do comando evidente:
O restart:
O with(LinearAlgebra):with(ArrayTools):
O A:=Matrix([[1,1,1],[3,-2,2],[2,4,5]]);
1 1 1
A :=

3 K2 2
2

4 5

(1.1)

O B:=Vector([3,2,-1]);
3
2

B :=

(1.2)

K1
O Au:=Concatenate(2,A,B);
1
Au :=

1 1

3 K2 2

(1.3)

4 5 K1

O Au1:=RowOperation(Au,[2,1],-3);
1 1

0 K5 K1 K7

Au1 :=

5 K1

O Au2:=RowOperation(Au1,[3,1],-2);
1 1 1

0 K5 K1 K7

Au2 :=

0 K5 K1

K7

13
5

49
K
5

(1.5)

3 K7

O Au3:=RowOperation(Au2,[3,2],2/5);
1 1
1
Au3 :=

(1.4)

(1.6)

Podemos agora usar um comando de retrosubstituio:

O X:=BackwardSubstitute(Au3);
60
13
28
13

X :=

(1.7)

49
13

K
O X1:=evalf(%);

4.615384615
X1 :=

2.153846154

(1.8)

K3.769230769
A matriz reduzida forma que a diagonal da matriz de coeficientes toda forma de 1 chamada forma
echelon:
O Au4:=RowOperation(Au3,3,5/13);

(1.9)

0 K5 K1

Au4 :=

K7

O Au5:=RowOperation(Au4,2,-1/5);
1 1 1

0 1

1
5

7
5

0 0

Au5 :=

(1.9)

49
K
13

(1.10)

49
13

O evalf(%);
1. 1.

1.

3.

0. 1. 0.2000000000
0. 0.

1.

1.400000000

(1.11)

K3.769230769

O procedimento abaixo far a tarefa de triangularizar uma matriz aumentada qualquer automaticamente:
O ngausst:=proc(A)
local j,i,k,n,m;
n:=RowDimension(A);
for k to n-1 do #Loop sobre colunas
for i from k+1 to n do # Loop sobre linhas
m:=evalf(-A[i,k]/A[k,k]);# Multiplicadores da coluna k
for j from k+1 to n+1 do
# Atualiza os elementos da
linha i
A[i,j]:=evalf(A[i,j]+m*A[k,j]);
od;
A[i,k]:=0:
od;
od;
A;
end:

ngausst:=proc(A)

Testemos o procedimento
O Ats:=ngausst(Au);
1
Ats :=

0 K5.
0

K1.

K7.

(1.12)

2.600000000 K9.800000000

O passo seguinte consiste em construir um procedimento que realize a retrosubstituio:

O retro:=proc(A) #entrada deve ser uma matriz triangular superior
local n,x,s,j,i;

O
n:=RowDimension(A);
x:=Vector(n);
x[n]:=evalf(A[n,n+1]/A[n,n]);
for i from n-1 to 1 by -1 do
s:=A[i,n+1];
for j from i+1 to n do
s:=evalf(s-A[i,j]*x[j]);
od;
x[i]:=evalf(s/A[i,i]);
od;
x;
end:

retro:=proc(A)
Testemos este procedimento na matriz triangular superior calculada anteriormente:
O X2:=retro(Ats);
4.615384615
X2 :=

2.153846154

(1.13)

K3.769230769
O seguinte procedimento concatena a matriz de coeficientes com a matriz da parte no-homognea:
O gauss1:=proc(A,B)
local Au,Auf;
Au:=<A|B>;
retro(ngausst(Au));
end:

gauss1:=proc(A,B)
Por exemplo,
O X3:=gauss1(A,B);
4.615384615
X3 :=

2.153846154

(1.14)

K3.769230769
Testemos este procedimento numa matriz grande aleatria:
O n:=100:N:=34.1:
O A:=RandomMatrix(n, n, generator = 0 .. N):
O B:=RandomMatrix(n, 1, generator = 0 .. N):
Aproveitamos para medir o tempo de CPU na execuo do comando:
O tempoCPUi:=time():
O X1:=gauss1(A,B);

(1.15)

1 .. 100 Vectorcolumn
X1 :=

Data Type: anything

Storage: rectangular

(1.15)

Order: Fortran_order
O tempoCPU:=(time()-tempoCPUi)*seconds;
tempoCPU := 0.964 seconds
Para mostrar o resultado na tela teramos que aumentar o rtablesize: interface(rtablesize=200):

(1.16)

Atravs de comandos automticos do Maple podemos resolver este sistema do seguinte modo
O tempoCPUi:=time():
O At:=GaussianElimination(<A|B>);
100 x 101 Matrix
At :=

Data Type: float8

Storage: triangularupper

(1.17)

Order: Fortran_order
O X2:=BackwardSubstitute(At);
1 .. 100 Vectorcolumn
X2 :=

Data Type: float8

Storage: rectangular

(1.18)

Order: Fortran_order
O tempoCPU:=(time()-tempoCPUi)*seconds;
tempoCPU := 0.023 seconds
A soluo pode tambm ser gerada pelo comando LinearSolve:
O tempoCPUi:=time():
O X3:=LinearSolve(A,B);
100 x 1 Matrix
X3 :=

Data Type: float8

Storage: rectangular

(1.19)

(1.20)

Order: Fortran_order
O tempoCPU:=(time()-tempoCPUi)*seconds;
tempoCPU := 0.003 seconds
(1.21)
Os clculos acima foram feitos com preciso de 19 dgitos decimais, embora somente 10 sejam
apresentados.

Exerccios
1. Resolva passo a passo, utilizando eliminao de Gauss, o sistema AX = B onde

2
A=

7 9

K1 21 8 K4
7

8 1

1
eB=

5
1

K4 7 9 1
0
Compare com o resultado fornecido pelo comando do Maple LinearSolve.
2. Construa uma variante dos procedimentos gauss1 (e consequentemente ngausst e retro) de modo que
o resultado seja racional.Aplique o resultado ao sistema AX = B onde
O A:=Matrix([[1/3,451/234,43/65],[3/7,13/5,56/3],[3/65,-8/47,
5/31]]);
1
451 43
3
234 65
3
7

A :=

13
5

3
65

56
3

8
47

(1.22)

5
31

O B:=Vector([1/3,5/7,-4/5]);
1
3
B :=

5
7

(1.23)

4
5

e compare com resultado computado em floats, tanto em tempo de execuo, quanto em acurcia.
3. Considere o sistema
1.545 1.543 1.432 1.542
A=

1.453 1.476 1.512 1.432

1.453 1.433 1.491 1.545
1.454 1.534 1.435 1.511

1.464
eB=

1.462
1.463

1.460

Resolva este sistema das seguintes formas:

(i) Passo a passo, usando eliminao de Gauss, com 4 dgitos significativos.
(ii) Usando os algoritmos construdos nesta seo, com 4 dgitos significativos e com 18 dgitos
significativos.
(iii) Racionalize a matriz (por exemplo, 1.545 = 1545/100, etc.) e resolva exatamente (em forma
racional), usandos os comandos GaussianElimination e BackwardSubstitute. Converta o resultado para
float, usando 4 dgitos significativos e compare com (ii).
4. Considere um sistema linear da forma HX = B onde H uma matriz de Hilbert definida por
O n:=10:

O H:=Matrix(n,n,(i,j) ->1/(i+j)):
eB
O B:=Vector(n,i->1/i):
Matrizes de Hilbert implicam em sistemas lineares mal-condicionados, ou seja, sistemas onde pequenas
alteraes nos coeficientes geram grandes mudanas nas solues.
(a) Obtenha a resposta exata (racional) do problema, usando o procedimento construdo no Problema
1.
(b) Resolva o problema com aritmtica de ponto flutuando do Maple, usando 10 e 20 dgitos de
preciso.
(c) Compare os resultados obtidos em (a) e (b) calculando a norma (infinita) do resduo e da diferena
entre as solues.

Pivotao Parcial
Vamos agora mostrar algumas limitaes da eliminao da Gauss simples, vista na seo anterior.
1. Pivot nulo
Exemplo 1. Consideremos o sistema linear AX = B onde
O with(LinearAlgebra):
O A:=Matrix([[0,3,5,5,7],[3,1,2,4,6],[0,0,6,8,2],[2,0,6,7,1],[3,
6,0,0,3]]);
0 3 5 5 7
3 1 2 4 6
A :=

0 0 6 8 2

(2.1)

2 0 6 7 1
3 6 0 0 3
O B:=Vector([1,2,3,4,5]):
A aplicao do procedimento a este sistema resulta em
O ngausst(<A|B>);
Error, (in ngausst) numeric exception: division by zero
Isso esperado, pois o primeiro elemento zero, de modo que o multiplicador tem um divisor por zero.
Tal problema pode ser corrigido se fizermos uma troca de linhas:
O A1:=RowOperation(A,[1,5]);
3 6 0 0 3
3 1 2 4 6
A1 :=

0 0 6 8 2

(2.2)

2 0 6 7 1
0 3 5 5 7
O R1:=ngausst(<A1|B>);

(2.3)

3
R1 :=

0 K5. 2.

4.

3.

1.

6.

8.

2.

3.

0 K2.066666666 K4.866666667 0.333333333

8.774193544

(2.3)

2.360215055

A soluo ento dada por

O X2:=BackwardSubstitute(R1);
0.237132352828441
K0.0863970589048764
1.46997549115367

X2 :=

(2.4)

K0.794730392943914
0.268995098314645
Outro problema que pode surgir no algoritmo de eliminao de Gauss simples est relacionado com
erros associados a somas de nmeros com magnitudes muito diferentes.
Exemplo.
Consideremos o sistema AX = Y com
O restart:
O with(LinearAlgebra):

ngausst:=proc(A)

retro:=proc(A)

gauss1:=proc(A,B)

O Digits:=18:
O A:=Matrix([[3.4521*10^(-17),342.4233,54.3333],[34.425,411.7829,
4.7829],[345.5243,432.6253,6.3425]]);
3.45210000000000000 10-17 342.4233 54.3333
A :=

34.425

411.7829 4.7829

345.5243

432.6253 6.3425

(2.5)

O B:=Vector([23.4363,56.7833,2.5439]);
(2.6)

23.4363
B :=

56.7833

(2.6)

2.5439
O Au:=<A|B>;
3.45210000000000000 10-17 342.4233 54.3333 23.4363
Au :=

34.425

411.7829 4.7829 56.7833

345.5243

432.6253 6.3425

(2.7)

2.5439

Usando o procedimento de Gauss simples obtemos:

O Au1:=ngausst(<A|B>);
Au1 := 3.45210000000000000 10-17 , 342.4233, 54.3333, 23.4363 ,

(2.8)

0, K3.41471049578517424 1020 , K5.41822036586425654 1019 ,

K2.33711256191883201 1019 ,
0, 0, 3000., 1000.
A soluo ento
O retro(Au1);
0.
0.0155515118276121981

(2.9)

0.333333333333333333
A reduo de Gauss obtida usando o comando do Maple
O Au2:=GaussianElimination(<A|B>);
Au2 :=
345.5243
0.
0.

432.6253

6.3425

368.679923009669653 4.15098912571416830
0.

(2.10)
2.5439
56.5298481950184112

50.4779357504694381 K29.0676091074388485

A diferena entre as duas matrizes eliminadas , em parte devido a um fatores de escala multiplicativos
(que no afetam a soluo). Mas fora isso h outras diferenas, que se manifestam na soluo:
O BackwardSubstitute(Au2);
K0.182167602216316871
0.159813926780637181

(2.11)

K0.575847816977510290
Note que usamos o procedimento ngausst1 com preciso de 19 dgitos decimais, para que a
comparao com a clculo com em sistema de ponto flutuante de hardware, com presiso estendida
(mantissa de 64 bits 18, 19 dgitos decimais) fosse justa.
Vejamos o que ocorre com nosso resultado se trocarmos a primeira pela segunda linha em nossa matriz
original:
O Au3:=RowOperation(Au,[1,2]);
(2.12)

34.425
Au3 :=

411.7829 4.7829 56.7833

3.45210000000000000 10-17 342.4233 54.3333 23.4363

345.5243

432.6253 6.3425

2.5439

O Au4:=ngausst(Au3);
Au4 :=
34.425
0

(2.13)

411.7829

4.7829

342.423300000000000 54.3333000000000000

(2.12)

56.7833
23.4362999999999999

545.497058645616859 K314.123290388731375

O retro(Au4);
K0.182167602216316884
0.159813926780637182

(2.14)

K0.575847816977510291
Ou seja, atravs de uma troca de linhas obtivemos o resultado correto com grande aproximao. Para
entender o que aconteceu, voltemos ao caso original, com
3.452100000000000000 10-17 342.4233 54.3333
A :=

34.425

411.7829 4.7829

345.5243

432.6253 6.3425

Notemos que os multiplicadores que iro anular os elementos da primeira coluna, a partir da segunda
linha, so de magnitude muito grande:
:
O m12:=-Au[2,1]/Au[1,1];
m12 := K9.97219084035804293 1017
(2.15)
O Au1:=RowOperation(Au,[2,1],m12);
Au1 := 3.45210000000000000 10-17 , 342.4233, 54.3333, 23.4363 ,
(2.16)
0., K3.41471049578517424 1020 , K5.41822036586425654 1019 ,
K2.33711256191883201 1019 ,
345.5243, 432.6253, 6.3425, 2.5439
O m13:=-Au[3,1]/Au[1,1];
m13 := K1.00091046029952782 1019
O Au2:=RowOperation(Au1,[3,1],m13):Au2[3,1]:=0:Au2;
3.45210000000000000 10-17 , 342.4233, 54.3333, 23.4363 ,
0., K3.41471049578517424 1020 , K5.41822036586425654 1019 ,
K2.33711256191883201 1019 ,
0, K3.42735062820283305 1021 , K5.43827683125923349 1020 ,
K2.34576378207178238 1020

(2.17)
(2.18)

Por exemplo, consideremos o clculo do elemento Au2[2,2]:

m12$ Au1 2, 2 =K9.972190840358042930 1017 C 34.425
O -9.972190840358042930E17+34.425;
K9.97219084035804259 1017
Este clculo foi realizado da seguinte forma
-9.972 190 840 358 042 930 E17 + 0.000 000 000 000 000 0 34425E17
Como a preciso de casas decimais de 18 dgitos, o ltimos trs dgitos so perdidos e 34.425
a ser aproximado por 34. De fato, todas as seguintes somas do mesmo resultado:
O -9.972190840358042930E17 + 0.00000000000000034425E17;
K9.97219084035804259 1017
O -9.972190840358042930E17 + 0.00000000000000034E17;
K9.97219084035804259 1017
O -9.972190840358042930E17 + 34.425;
K9.97219084035804259 1017
O -9.972190840358042930E17 + 34.4;
K9.97219084035804259 1017
O -9.972190840358042930E17 + 34;
K9.97219084035804259 1017

(2.19)

passa

(2.20)
(2.21)
(2.22)
(2.23)
(2.24)

As consideraes anteriores sugerem que para evitar divises por zero ou a gerao de multiplicadores
execessivamente grandes, devemos tentar trocar linhas de modo a obter os menores multiplicadores
em cada estgio. Este processo denominado pivotao
O algoritmo de pivotao mais geral procura pelo maior elemento em valor absoluto entre as
componentes direita e abaixo da posio do pivot e ento as trocas apropriadas de linhas e colunas
so efetuadas de modo a trazer este elemento posio de pivot. Na prtica, a pivotao parcial
utilizando trocas de linhas normalmente usada.
Devemos modificar o procedimento gauss1 de modo que ele procure pelo maior elemento em valor
absoluto, sobre ou abaixo da posio do pivot.
Inicialmente vamos escrever um procedimento que faz somente a pivotao parcial de colunas, sem a
reduo de linhas. Em seguida, tal procedimento ser incorporado a outro de eliminao de Gauss.
O piv:=proc(Aa)
local n, k, p, i, temp, m, j, x;
n := RowDimension(Aa);
x := Vector(n);
for k from 1 to n-1 do
#loop sobre colunas
p:=k;
for i from k+1 to n do #percorre os elementos da coluna k
if (abs(Aa[i,k]) > abs(Aa[p,k])) then p:=i; fi; #o
maior elemento da coluna tem sue ndice de linha armazenado em
p
od;
if Aa[p,k]=0 then ERROR(`Matriz singular`); fi;

if (p<>k) then # troca linhas k e p

for j from 1 to n+1 do
temp:=Aa[k,j];
Aa[k,j] := Aa[p,j];
Aa[p,j] := temp;
od;
fi;
od;
Aa;
end:
piv:=proc(Aa)
local n, k, p, i, temp, m, j, x;
n := RowDimension(Aa);
x := Vector(n);
for k from 1 to n-1 do
#loop sobre colunas
p:=k;
for i from k+1 to n do #percorre os elementos da coluna k
if (abs(Aa[i,k]) > abs(Aa[p,k])) then p:=i; fi; #o maior
elemento da coluna tem sue indice de linha armazenado em p
od;
if Aa[p,k]=0 then ERROR(`Matriz singular`); fi;
if (p<>k) then # troca linhas k e p
for j from 1 to n+1 do
temp:=Aa[k,j];
Aa[k,j] := Aa[p,j];
Aa[p,j] := temp;
Exemplo. Consideremos o sistema:
O A:=Matrix([[1,-1,2,-1, -1],[1,-2,3,-1/2,-1],[8,2,1,0,1],[1,3,1,
3,6],[2,4,-2,1,2]]):
O B:=Vector([-8,-20,-2,4,2]):
O Au:=<A|B>;
1 K1 2 K1 K1 K8

Au :=

1
2

1 K2

K1 K20

K2

K2

(2.25)

O piv(Au);
8

K2

K2

1
2

1 K2

K1

1 K1

K1 K20
6

K1 K8

(2.26)

Note que a pivotao feita somente at a coluna n K 1 e sempre com elementos abaixo da diagonal
para baixo, ou seja cada nova pivotao incapaz de arruinar a anterior.
Vamos agora inserir o cdigo anterior para que ele faa a pivotao para cada loop sobre colunas.
Obviamente ele tem que ser inserido dentro do loop inicial sobre colunas. O procedimento de
retrosubstituio j est includo.
O gauss2:=proc(A,Y)
local n, k, p, i, temp, m, j, x, s,Aa;
Aa:=<A|B>;
n := RowDimension(Aa);
x := Vector(n);
for k from 1 to n-1 do
p:=k;
for i from k+1 to n do
if (abs(Aa[i,k]) > abs(Aa[p,k])) then p:=i;
od;
if Aa[p,k]=0 then
ERROR(`Matriz singular`);
fi;
if (p<>k) then # troca linhas k e p
for j from 1 to n+1 do
temp:=Aa[k,j];
Aa[k,j] := Aa[p,j];
Aa[p,j] := temp;
od;
fi;
for i from k+1 to n do
m := Aa[i,k]/Aa[k,k];
for j from 1 to n+1 do
Aa[i,j] := Aa[i,j] - m*Aa[k,j];
od;
od;
od;
x[n] := Aa[n,n+1] / Aa[n,n];
for i from n-1 to 1 by -1 do
s := Aa[i,n+1];
for j from i+1 to n do
s := s - Aa[i,j]*x[j];
od;
x[i] := s/Aa[i,i];
od;
x;
end:

gauss2:=proc(A,Y)

Exemplo. Consideremos um problema envolvendo pivot pequeno:

O Digits:=10:

fi;

O A:=Matrix([[0.0000034521,342.4233,54.3333],[34332.425,
4311.7829,4.7829],[342125.5243,432.6253,6.3425]]);
0.0000034521
342.4233 54.3333
34332.425

A :=

4311.7829 4.7829

3.421255243 105 432.6253

(2.27)

6.3425

O B:=Vector([1,2,3]);
1
2

B :=

(2.28)

3
O gauss1(A,B);
0.
0.0006536062232

(2.29)

0.01428571429
O gauss2(A,B);
0.000007988526909
0.0003824949561

(2.30)

0.01599433156
O LinearSolve(A,B);
0.00000798852690861963
0.000382494956004152

(2.31)

0.0159943315591751
A diferena dos resultados, com ou sem pivotao, com preciso de 10 dgitos, considervel.
Exemplo. Vejamos perfomance do nosso cdigo com um sistema grande.
O nn:=90:N:=34.1:
O A:=RandomMatrix(nn, nn, generator = 0 .. N):
O B:=RandomMatrix(nn, 1, generator = 0 .. N):
O tempoCPUi:=time():
O gauss2(A,B);
1 .. 90 Vectorcolumn
Data Type: anything
Storage: rectangular

(2.32)

Order: Fortran_order
O tempoCPU:=(time()-tempoCPUi)*seconds;
tempoCPU := 0.958 seconds
O procedimento que no realiza pivotao mais rpido:
O tempoCPUi:=time():

(2.33)

O gauss1(A,B);
1 .. 90 Vectorcolumn
Data Type: anything
Storage: rectangular

(2.34)

Order: Fortran_order
O tempoCPU:=(time()-tempoCPUi)*seconds;
tempoCPU := 0.668 seconds
O comando LinearSolve gera a soluo:
O tempoCPUi:=time():
O LinearSolve(A,B);
90 x 1 Matrix
Data Type: float8
Storage: rectangular

(2.35)

(2.36)

Order: Fortran_order
O tempoCPU:=(time()-tempoCPUi)*seconds;
tempoCPU := 0.004 seconds

(2.37)

O procedimento abaixo, escrito por Peter Stone, realiza a eliminao de Gauss com pivotao parcial,
descrevendo as operaes realizadas a cada passo:
O restart:
O with(LinearAlgebra):
GaussElimination := proc(AA,ra
Por xemplo,
O A := <<0.91,3.3,-1.3>|<5.3,-2.3,1.4>|<1.2,4.1,1.7>>;
B := <1,1,1>;
Au := <A|B>;
0.91 5.3 1.2
A :=

3.3
K1.3

K2.3 4.1
1.4

1.7

1
B :=

1
1

0.91
Au :=

3.3
K1.3

5.3

1.2 1

K2.3 4.1 1
1.4

1.7 1

(2.38)

O J := GaussElimination(Au,info=true);
performing Gaussian elimination with implicit pivoting to
0.91
3.3
K1.3

5.3

1.2 1.

K2.3 4.1 1.
1.4

1.7 1.

searching for pivot in column 1

swap rows 2 and 1
3.3

K2.3 4.1 1.

0.91

5.3

1.2 1.

K1.3

1.4

1.7 1.

pivot element is , 3.3

subtract , 0.2757575758, times row 1 from row 2
3.3

K2.3

4.1

1.

5.934242424 0.069393939 0.7242424242

K1.3

1.4

1.7

1.

add , 0.3939393939, times row 1 to row 3

3.3

K2.3

4.1

1.

5.934242424 0.069393939 0.7242424242

0.4939393940 3.315151515 1.393939394

searching for pivot in column 2

pivot element is , 5.934242424
subtract , 0.08323545934, times row 2 from row 3
3.3
0

K2.3

1.

5.934242424 0.069393939 0.7242424242

0
3.3

J :=

4.1

3.309375479 1.333656743

K2.3

4.1

1.

5.934242424 0.069393939 0.7242424242

3.309375479 1.333656743

Pivotao por escala em Matlab

function x = gaussPiv(A,b)
% Solves A*x = b by Gauss elimination with row pivoting.
% USAGE: x = gaussPiv(A,b)
if size(b,2) > 1; b = b; end
n = length(b); s = zeros(n,1);
%----------Set up scale factor array---------for i = 1:n; s(i) = max(abs(A(i,1:n))); end

(2.39)

%---------Exchange rows if necessary---------for k = 1:n-1

[Amax,p] = max(abs(A(k:n,k))./s(k:n));
p = p + k - 1;
if Amax < eps; error(Matrix is singular); end
if p = k
b = swapRows(b,k,p);
s = swapRows(s,k,p);
A = swapRows(A,k,p);
end
%--------------Elimination pass--------------for i = k+1:n
if A(i,k) = 0
lambda = A(i,k)/A(k,k);
A(i,k+1:n) = A(i,k+1:n) - lambda*A(k,k+1:n);
b(i) = b(i) - lambda*b(k);
end
end
end
%------------Back substitution phase---------for k = n:-1:1
b(k) = (b(k) - A(k,k+1:n)*b(k+1:n))/A(k,k);
end
x = b;
Exerccios
Resolva, passo a passo, utilizando pivotao parcial, os sistemas de equaes abaixo, utilizando trs
dgitos significativos. Compare com a soluo obtida atravs da racionalizao do sistema.
1.

3.9 x C 0.013 y = 35.2

K6.32 x C 5.43 y = 34.5
0.01 x C 2 y C z = 15

2.

3 x C 2 y C 3 z = 6.3
5 x C 4.4 y C 5 z = 46

3. Compare os resultados passo a passo dos problemas 1 e 2 com o resultado da aplicao do

procedimento GaussElimination de Peter Stone
4. Resolva o sistema AX = B, passo a passo usando eliminao de Gauss simples e eliminao de
Gauss com pivotao parcial
0.0000033455 69.383 45.231
58.222
A :=

5.3400

7.3402 3.4543

32.345
3.2345 31.456
Use preciso de 8 dgitos significativos.

Bd

32.554

12.563

5. Resolva o sistema do problema 4 de forma automtica (usando os procedimentos construdos

anteriormente), sem e com pivotao parcial, com 8 dgitos de preciso. Verfique o resultado usando
racionalizao, usando os procedimentos do Maple GaussianElimination e BackwardSubstitute e o

procedimento de Peter Stone.

6. Resolva o sistema usando eliminao de Gauss

Sistemas mal condicionados

Seja um sistema linear AX = B e sejam os autovalores X1 e X2 duas aproximaes da soluo exata Xe.
O modo mais natural para decidir qual a melhor aproximao seria calcular os resduos: R1 = B K A X1
e R2 = Y K A X2 . Veremos a seguir que este no necessariamente o caso.
Exemplo 1 Consideremos o seguinte sistema linear AX = B:
O with(LinearAlgebra):
O A:=Matrix([[0.24,0.36,0.12],[0.12,0.16,0.24],[0.15,0.21,0.25]])
;
0.24 0.36 0.12
A :=

0.12 0.16 0.24

(3.1)

0.15 0.21 0.25

O B:=Vector([0.84,0.52,0.64]);
0.84
B :=

0.52

(3.2)

0.64
Consideremos agora dois candidatos a soluo deste sistema:
O X1:=Vector([25,-14,-1]);
25
X1 :=

K14

(3.3)

K1
O X2:=Vector([-3,4,0.7]);
(3.4)

K3
4

X2 :=

(3.4)

0.7
Os resduos so
O R1:=A.X1-B;
0.
R1 :=

K2.22044604925031 10-16

(3.5)

K0.0800000000000000
O R2:=A.X2-B;
K0.0360000000000000
R2 :=

K0.0720000000000000

(3.6)

K0.0750000000000001
Seria natural pensar que a soluo X1 a melhor aproximao, pois seu resduo menor. No entanto, a
soluo exata Xe
O Ar:=map(convert, (A,rational));
6
9
3
25
25
25
Ar :=

3
25

4
25

6
25

3
20

21
100

1
4

(3.7)

O Br:=map(convert, (B,rational));
21
25
13
25

Br :=

(3.8)

16
25
O Ar2:=GaussianElimination(<Ar|Br>);
6
9
3
25
25
25
Ar2 :=

1
50

9
50

1
10

1
25

1
25

21
25
(3.9)

O Xe:=BackwardSubstitute(Ar2);
(3.10)

K3
4

Xe :=

(3.10)

1
Portanto, a soluo mais prxima da verdadeira X2 , apesar do seu resduo ser maior.
Exemplo 2 Outro comportamento peculiar deste sistema refere-se a pequenas perturbaes.
Consideremos, por exemplo, uma pequena perturbao na matriz B:
O Bp:=Br+Vector([0,0,1/100]);
21
25
13
25

Bp :=

(3.11)

13
20
A soluo do sistema agora :
O ABp:=GaussianElimination(<Ar|Bp>);
6
9
3
25
25
25
ABp :=

1
50

9
50

1
10

1
25

1
20

21
25
(3.12)

O Xp:=BackwardSubstitute(ABp);
13
2

K
Xp :=

25
4

(3.13)

5
4
O evalf(%);
K6.500000000
6.250000000

(3.14)

1.250000000
A soluo acima a exata. Note o quanto ela mudou devido a uma pequena perturbao. Esta uma
tpica caracterstica de sistemas mal condicionados.
Matrizes de Hilbert, definidas por
Hij =

1
,
iCjKs

onde s indeterminado (nmero ou varivel), esto associadas a sistemas mal-condicionados.

Exemplo 3 Tomemos s = 1:
O restart:
O with(LinearAlgebra):
O f := (i, j) -> 1/(i+j-1) :
O H10:=Matrix(20, f);
20 x 20 Matrix
H10 :=

Data Type: anything

Storage: rectangular

(3.15)

Order: Fortran_order
O B:=Vector(20,1);
1 .. 20 Vectorcolumn
B :=

Data Type: anything

Storage: rectangular

(3.16)

Order: Fortran_order
O Au:=<H10|B>;
20 x 21 Matrix
Au :=

Data Type: anything

Storage: rectangular

(3.17)

Order: Fortran_order
Inicialmente resolvamos o sistema com aritmtica de ponto flutuante:
O Auf:=evalf(Au);
20 x 21 Matrix
Auf :=

Data Type: anything

Storage: rectangular

(3.18)

Order: Fortran_order
O H102:=GaussianElimination(Auf);
20 x 21 Matrix
H102 :=

Data Type: float8

Storage: triangularupper
Order: Fortran_order

O interface(rtablesize=200):
O X1:=BackwardSubstitute(H102);

(3.19)

26.5821344520956
K1987.06138836168
35057.1768774295
K2.46463455138518 105
8.12914650917389 105
K1.28716504077555 106
9.96809121421177 105
K8.97468232337462 105
1.10374453210925 106
2.80271685377704 105
X1 :=

K4.89869336486735 105

(3.20)

K1.23271313775619 106
K6.02252432293157 105
1.54242561627537 106
1.03984619133518 106
1.30558660156421 105
K1.05771152515241 106
K1.01361265335759 106
7.71654349975747 105
1.16134374450414 105
Calculemos o resduo:
O R1:= H10.X1-B;

(3.21)

0.00000303877641272265
0.0000155554434968508
K0.00000952395294007147
0.00000743779492040630
K0.00000664999424770940
K0.0000140550810101558
0.00000584843201067997
0.0000140040838232380
0.00000550479398953030
R1 :=

K0.00000567432334719342
K0.00000951934680415434

(3.21)

K0.00000542115412827116
0.00000171923511516070
0.00000652847575111082
0.00000618027115706354
0.00000121637594929780
K0.00000503690398545587
K0.00000764542801334755
K0.00000129345244204160
0.0000187187097253627
Ou, usando a norma infinito,
O Norm(R1,infinity);

0.0000187187097253627144
Resolvamos agora os sistema exatamente, usando aritmtica racional
O H103:=GaussianElimination(Au):
O X2:=BackwardSubstitute(H103);

(3.22)

(3.23)

K20
7980
K790020
34321980
K823727520
12355912800
K124932007200
894921112800
K4698335842200
X2 :=

18503322637800
K55509967913400

(3.23)

127994058246600
K227544992438400
311023037001600
K323717854838400
251780553763200
K141626561491800
54396360988200
K12759640231800
1378465288200
O resduo agora zero, por construo:
O R2:= Norm(H10.X2-B, infinity);
R2 := 0
Vejamos a real diferena entre as solues:
O X2-X1;

(3.24)

(3.25)

K46.5821344520956
9967.06138836168
K8.25077176877429 105
3.45684434551385 107
K8.24540434650917 108
1.23571999650408 1010
K1.24933004009121 1011
8.94922010268232 1011
K4.69833694594453 1012
1.85033223575283 1013
K5.55099674235307 1013

(3.25)

1.27994059479313 1014
K2.27544991836148 1014
3.11023035459174 1014
K3.23717855878246 1014
2.51780553632641 1014
K1.41626560434088 1014
5.43963620018127 1013
K1.27596410034543 1013
1.37846517206563 1012
ou
O DX:=Norm(X2-X1,infinity);
DX := 3.23717855878246188 1014
Ou seja, a soluo obtida com aritmtica de ponto flutuante desastrosamente errada.

(3.26)

Exerccios
1. Considere uma matriz de Hilbert 60 x 60. Resolva um sistema envolvendo tal tipo de matriz das
seguintes formas:
(i) Utilizando aritmtica racional exata, utilizando os procedimentos GaussianElimination e
BackwarSubstitute e LinearSolve Calcule o tempo de CPU.
(ii) Idem, Utilizando aritmtica de ponto flutuante do Maple, com preciso de 18 dgitos.
(iii) Determine a preciso necessria de modo que a a norma do vetor diferena dos resultados no
tenha ordem de magnitude menor que 10 E-8. Use GaussianElimination e BackwarSubstitute e
LinearSolve. Calcule o tempo de CPU

Sistemas Tridiagonais
Construo de uma matriz tridiagonal
Em vrias oportunidades no clculo numrico, como na soluo numrica de equaes diferenciais, o
processo de discretizao resulta numa matriz grande esparsa, com elementos no-nulos concentrados
em torno da diagonal. Uma classe de matrizes deste tipo a chamada matriz banda ou tridiagonal. Sua
forma geral dada abaixo:
d1 c1 0
...
0
0

A=

a2 d2 c2

...

0 a3 d3

...

0 . . . an K 1 dn K 1 cn K 1

...

an

dn

As componentes [c1 . . . cn K 1 ] constituem a super-diagonal. As componentes [a2 . . . an ] a subdiagonal e

[d1 . . . dn ] a diagonal principal. Um esquema grfico dado abaixo ( Peter Stone)

p1:=plot([[[.2,0],[0,0],[0,10]

Exemplo1

Vamos construir uma matriz tridiagonal de ordem 6 onde a diagonal principal tem elementos 1, 2,...n e
as outras diagonais com componentes 1. Usaremos os comandos do pacote LinearAlgebra.
O with(LinearAlgebra):
O n := 6:
Definimos uma matriz nula de ordem n:
O A := Matrix(n):
Definimos as componentes no nulas:
O for i from 1 to n-1 do
A[i,i+1] := 1;
A[i,i] := i;
A[i+1,i] := 1;
end do:
A[n,n] := n:
O A;
1 1 0 0 0 0
1 2 1 0 0 0
0 1 3 1 0 0
0 0 1 4 1 0

(4.1)

0 0 0 1 5 1
0 0 0 0 1 6
Outro modo de executar essa mesma tarefa consiste em definir as trs diagonais como listas e utiliz-las
no procedimento do pacote LinearAlgebra chamado BandMatrix:
O superdiag:=[seq (1, i=1..n-1)];
superdiag := 1, 1, 1, 1, 1
(4.2)
O subdiag:=superdiag;
subdiag := 1, 1, 1, 1, 1
(4.3)
O maindiag:=[seq(i,i=1..n)];
maindiag := 1, 2, 3, 4, 5, 6
(4.4)
O BandMatrix([subdiag,maindiag,superdiag]);
1 1 0 0 0 0
1 2 1 0 0 0
0 1 3 1 0 0
0 0 1 4 1 0
0 0 0 1 5 1
0 0 0 0 1 6
Exemplo 2
Vamos definir uma matriz tridiagonal de ordem 5 onde todos os elementos so nmeros inteiros
aleatrios entre -10 e 10, inclusive.
O restart:
O with(LinearAlgebra):
O n:=5:
O A:=Matrix(n):

(4.5)

O randomize():
O r:=rand(-10..10):
O for i from 1 to n-1 do
A[i,i+1] := r();
A[i,i] := r();
A[i+1,i] := r();
end do:
A[n,n]:=r():
O A;
K3 K4

K10 K9 K5

6 10 K4

4 K2

(4.6)

9 K2

Utilizando BandMatrix, definimos as listas de diagonais:

O randomize():
maindiag := [seq(r(),k=1..n)];
maindiag := K4, K3, K10, K5, K9
O superdiag:=[seq(r(),k=1..n-1)];
superdiag := 6, K4, 10, 4
O subdiag:=[seq(r(),k=1..n-1)];
subdiag := 6, K2, 9, K2
O BandMatrix([subdiag,maindiag,superdiag]);
K4 6
0 0 0
6 K3

K4

0 K2 K10 10

9 K5

0 K2 K9

(4.7)
(4.8)
(4.9)

(4.10)

Compactao de Matrizes Tridiagonais

Vamos definir agora a forma compacta de uma matriz tridiagonal, pois seria um desperdcio alocar
espao de memria para componentes nulas de uma matriz. No final apresentaremos um procedimento
que realiza sua expanso. A forma compacta definida da seguinte forma:
Todas as componentes no-nulas de uma matriz tridiagonal n # n A so representadas em uma matriz
B de dimenses 3 # n
As componentes da super-diagonal de A so colocadas na primeira coluna of B.
As componentes da digonal principal de A so colocadas na segunda coluna of B.
As componentes da sub-diagonal de A so colocadas na terceira coluna ofB.
Por exemplo, a matriz tridiagonal

K10 K21

A=

0
0

K17 K23

K23 K11 K21

25

13

K8

21 K18

K9 K19

pode ser convertida na matriz

K21 K23 K21 K8 K18
B=

K10 K17 K11 13

0

K23 25

21

K19

K9

Como a sub e superdiagonais tm uma componente a menos que a diagonal principal, ainda temos
componentes nulas na forma compacta.
Vamos agora construir o procedimento Tridiagonal, que expande uma matriz tridiagonal a partir de sua
forma compacta.
O restart:
O with(LinearAlgebra):
O Tridiagonal := proc(A::Matrix)
local m,n,T,i,j;
if not type(A,'Matrix') then
error "Argumento deve ser uma matriz"
end if;
m :=RowDimension(A);
if m<>3 then
error "Matriz deve ter 3 linhas"
end if;
n := ColumnDimension(A);
if n<3 then
error "Matriz deve ter ao menos 3 colunas"
end if;
T := Matrix(n);
T[1,1] := A[2,1];
T[1,2] := A[1,1];
for j from 2 to n-1 do
T[j,j-1] := A[3,j];
T[j,j] := A[2,j];
T[j,j+1] := A[1,j];
end do;
T[n,n-1] := A[3,n];
T[n,n] := A[2,n];
T;
end proc:

Tridiagonal := proc(A::Matrix)
Por exemplo, se B uma matriz diagonal na forma compacta:
O B := Matrix([[21,-32,-21,-8,-28,0],[10,-12,31,3,21,32],
[0,31,53,2,4,-79]]);
21 K32 K21 K8 K28
10 K12

B :=

31

31

53

21

0
32

(4.11)

4 K79

O Tridiagonal(B);
10

21

31 K12 K32

31 K21

0
0

53

K8

21 K28

0 K79

(4.12)

32

Vamos agora construir uma matriz tridiagonal compacta de ordem 6, onde a diagonal principal tem
elementos 1, 2,.., n e as outras diagonais com componentes 1. Em seguida faremos a expanso.
O n := 6:
O C := Matrix(3,n):
O for i from 1 to n do
C[1,i] := 1; C[2,i] := i; C[3,i] := 1;
end do:
C;
1 1 1 1 1 1
1 2 3 4 5 6

(4.13)

1 1 1 1 1 1
O Tridiagonal(C);
1 1 0 0 0 0
1 2 1 0 0 0
0 1 3 1 0 0
0 0 1 4 1 0
0 0 0 1 5 1
0 0 0 0 1 6

Soluo de um Sistema Tridiagonal

(4.14)

Um sistema linear envolvendo uma matriz de coeficientes que tridiagonal pode ser dada atravs de 4
listas, trs correspondentes diagonal, e uma ao termo no-homogneo. Sejam superdiag
superdiag := c1 , ..., cn K 1 , subdiag := a2 , ..., an , maindiag := d1 , ..., dn , e nonhom := b1 , ...,
bn . Podemos ento resolver o sistema por um mtodo mais simples do que o de eliminao e
retrosubstituio j vistos:
O restart:
O with(LinearAlgebra):
O Tridiagsolve:=proc(A,bb)
local j,n,k,x,a,c,d,b;
b:=bb:
n:=nops(b);
x:=Vector(n);
a:=Row(A,3);
d:=Row(A,2);
c:=Row(A,1);
for k to n-1 do
d[k+1]:=d[k+1]-a[k+1]*c[k]/d[k];
b[k+1]:=b[k+1]-a[k+1]*b[k]/d[k];
end do;
x[n]:=b[n]/d[n]:
for j from n-1 to 1 by -1 do
x[j]:=(b[j]-c[j]*x[j+1])/d[j];
end do:
evalf(x);
O end proc:

Tridiagsolve:=proc(A,bb)

Exemplo 3
Por exemplo, tomemos o sistema AX = B com, A dada em forma compacta:
O A := Matrix([[21,-32,-21,-8,-28,0],[10,-12,31,3,21,32],
[0,31,53,2,4,-79]]);
21 K32 K21 K8 K28
A :=

10 K12
0

O B:=[2,3,5,-3,2,1];

31

31

53

21

B := 2, 3, 5, K3, 2, 1

0
32

(4.15)

4 K79
(4.16)

A soluo dada por

O Tridiagsolve(A,B);

(4.17)

K0.8068273695
0.4794416045
K1.055154616

(4.17)

K0.5856851454
K0.1084205835
K0.2364133156

Exerccios
1. Aplique o procedimento Tridiagsolve a um sistema envolvendo uma matriz de coeficientes
tridiagonal 100 100, onde os coeficientes so nmeros aleatrios entre -1000 e 1000, inclusive.
2. Compare o desempenho no paroblema anterior, no que se refere a tempo de CPU, de Tridiagsolve
com os procedimentos gauss2, GaussianElimination+BackwardSubstitution e LinearSolve do
pacote LinearAlgebra. Antes de fazer as comparaes, defina as matrizes em ponto flutuante ou modifique
gauss2 e Triagsolve para fazer a converso a floats em cada clculo.

Fatorao LU
1. Introduo
possvel mostrar que qualquer matriz quadrada A pode ser expressa com um produto de uma matriz
triangular inferior L e uma matriz triangular superior U:
A = LU,
com
l11 0 0 ... 0
u11 u12 u13 ... u1n
l21 l22 0
L=

l31 l32 l33 0

0
,

ln1 ln2 ln3 ... lnn

U=

u22 u23 ... u2n

u33 ... u3n

... unn

O processo de computar L e U para uma dada matriz A conhecido como decomposio LU ou

fatorao LU. Esta decomposio no nica, a menos que certas restries seja impostas a L ou U.
Tais restries distinguem os diferentes tipos de decomposies. As decomposies mais utilizadas
so:
1. Decomposio de Doolitle: Lii = 1, i = 1, 2, ... , n
2. Decomposio de Crout: Uii = 1, i = 1, 2, ... , n
3. Decomposio de Choleski: L = UT
Podemos utilizar a fatorao LU para resolver um sistema linear. Dado um sistema AX = B podemos

fatorar a matriz A como A = L U , de modo que dividimos o nosso problema AX = LUX = B em duas
partes:
UX = Y,
LY = B.
Inicialmente, usando a segunda equao, determinamos Y atravs de retrosubstituio. Finalmente,
usando a primeira equao, determinamos X usando novamente retrosubstituio.
A vantagem da decomposio LU sobre o mtodo da eliminao gaussiana que uma vez que a matriz
A est decomposta, podemos resolver o sistema AX = B para diversos diferentes valores diferentes de
B com grande facilidade. O custo de cada soluo adicional relativamente pequeno, pois as estapas de
retrosubstituio so computacionalmente mais simples do que o processo de decomposio.

2. Decomposio de Doolittle e matrizes elementares de eliminao

Para entender o processo de determinao das matrizes L e U, consideremos uma matriz A 4 # 4:
4 1 K1 3
6

A=

3 K1 3

K2 K1

5 2

3 K9 2 7
Para criar zeros abaixo da diagonal na primeira coluna, devemos multiplicar A pela matriz de eliminao
elementar:
1 0 0 0
1
4

M1 =

1 0 0

1
4

K2

0 1 0

0 0 1

1
4

1 0 0 0
3
2

1 0 0

1
2

0 1 0

3
4

0 0 1

K
=

Ou seja,
1 0 0 0
3
2

1 0 0

1
2

0 1 0

3
K
4

0 0 1

K
A1 = M A =
1

1 K1 3

3 K1 3

K2 K1

5 2

3 K9

2 7

K1

3
2

1
2

1
2

9
2

7
2

39
4

11
4

19
4

0 K
0 K

3
3
2
.

De fato,
O with(LinearAlgebra):
O A1:=Matrix([[1,0,0,0],[-3/(2),1,0,0],[1/(2),0,1,0],[-3/(4),0,0,
1]]).Matrix([[4,1,-1,3],[6,3,-1,3],[-2,-1,5,2],[3,-9,2,7]]);

(5.1)

A1 :=

K1

3
2

1
2

1
2

9
2

7
2

39
4

11
4

19
4

0 K
0 K

3
3
2
(5.1)

Devemos agora criar zeros abaixo da diagonal da segunda coluna. Isso pode ser feito atravs da matriz
1
0 0 0
1
0 0 0
0
M2 =

1 0 0
2
3

0
0

1 0

39
4

0 1

2
3

1
2

0
=

1 0 0

1
3

1 0

13
2

0 1

de modo que

A2 = M2 M1 A =

0 0 0

1 0 0

1
3

1 0

13
2

0 1

K1

3
2

1
2

3
K
2

1
2

9
2

7
2

39
4

11
4

19
4

0 K
0 K

K1

3
2

1
2

14
3

K5

3
3
2

De fato,
O A2:=Matrix([[1,0,0,0],[0,1,0,0],[0,1/(3),1,0],[0,(13)/(2),0,1]]
).Matrix([[4,1,-1,3],[0,3/2,1/2,-3/2],[0,-1/2,9/2,7/2],[0,
-39/4,11/4,19/4]]);
4 1 K1
3
3
2

1
2

14
3

K5

0
A2 :=

3
2

(5.2)

Devemos, finalmente, criar um zero abaixo da diagonal da terceira coluna. Isso pode ser feito atravs da
matriz

M3 =

1 0

0 0

1 0

0 0

0 1

0 0

0 1

0 0

0 0

1 0

0 0

3
14

0 0

9
7

0 0 K

1 1

De modo que ,

A3 = M3 A2 = M3 M2 M1 A =

1 0

0 0

0 1

0 0

0 0

1 0

9
0 0 K
7

K1

3
2

1
2

3
K
2

14
3

K5

K1

3
2

1
2

14
3

3
2

62
7

De fato,
O A3:=Matrix(4, 4, {(1, 1) = 1, (1, 2) = 0, (1, 3) = 0, (1, 4) =
0, (2, 1) = 0, (2, 2) = 1, (2, 3) = 0, (2, 4) = 0, (3, 1) = 0,
(3, 2) = 0, (3, 3) = 1, (3, 4) = 0, (4, 1) = 0, (4, 2) = 0, (4,
3) = -9/7, (4, 4) = 1}). Matrix(4, 4, {(1, 1) = 4, (1, 2) = 1,
(1, 3) = -1, (1, 4) = 3, (2, 1) = 0, (2, 2) = 3/2, (2, 3) =
1/2, (2, 4) = -3/2, (3, 1) = 0, (3, 2) = 0, (3, 3) = 14/3, (3,
4) = 3, (4, 1) = 0, (4, 2) = 0, (4, 3) = 6, (4, 4) = -5});
4 1 K1
3

A3 :=

3
2

1
2

3
2

14
3

(5.3)

62
7

Faamos um resumo dos clculos acima e obtenhamos concluses gerais. Dada uma matriz A podemos
fazer a reduo gaussiana sua forma triangular superior aplicando matrizes elementares que aniquilam
os elementos abaixo da diagonal nas colunas sucessivas. Inicilamente aplicamos uma matriz M1 para
obter uma matriz A1 com zeros abaixo da diagonal na coluna 1:
A1 = M1 A.
Aplicando M2 a A1 obtemos a matriz A2 , com zeros abaixo da diagonal das colunas 1 e 2:
A2 = M2 A1 = M2 M1 A .
Repetindo o processo n K 1 vezes obtemos finalmente uma matriz triangular superior U:
U = An K 1 = Mn K 1 $$$M2 M1 A = MA
com

M = Mn K 1 $$$M2 M1 .
Supondo
A = LU = L MA = L Mn K 1 $$$M2 M1 A,
temos
L = M K1 = M1 M2 $$$Mn K 1

K1

1 K1
= MnK1K 1 $$$M K
M1
2

O clculo das inversas simples e no necessita ser formalmente computado: somente o sinal das
componentes diferentes de 1 trocado. Alm disso, a multiplicao matricial no precisa ser
1
formalmente computada: o resultado simplesmente a justaposio das colunas de MnK1K 1 , M K
, M1K1 .
2
Ou seja, a matriz L tem colunas formadas pelo negativo das colunas no elementares de
Mn K 1 , $$$, M2 , M1 . Voltando ao nosso exemplo, construmos as matrizes M1 , M2 , M3 dadas abaixo:

(5.4)
O M1:=Matrix(4, 4, {(1, 1) = 1, (1, 2) = 0, (1, 3) = 0, (1, 4) =
0, (2, 1) = -3/2, (2, 2) = 1, (2, 3) = 0, (2, 4) = 0, (3, 1) =
1/2, (3, 2) = 0, (3, 3) = 1, (3, 4) = 0, (4, 1) = -3/4, (4, 2)
= 0, (4, 3) = 0, (4, 4) = 1});
1 0 0 0
3
2

1 0 0

1
2

0 1 0

M1 :=

3
4

(5.5)

0 0 1

O M2:=Matrix(4, 4, {(1, 1) = 1, (1, 2) = 0, (1, 3) = 0, (1, 4) =

0, (2, 1) = 0, (2, 2) = 1, (2, 3) = 0, (2, 4) = 0, (3, 1) = 0,
(3, 2) = 1/3, (3, 3) = 1, (3, 4) = 0, (4, 1) = 0, (4, 2) =
13/2, (4, 3) = 0, (4, 4) = 1});
1 0 0 0

M2 :=

0 0

1
3

1 0

13
2

0 1

(5.6)

O M3:=Matrix(4, 4, {(1, 1) = 1, (1, 2) = 0, (1, 3) = 0, (1, 4) =

0, (2, 1) = 0, (2, 2) = 1, (2, 3) = 0, (2, 4) = 0, (3, 1) = 0,
(3, 2) = 0, (3, 3) = 1, (3, 4) = 0, (4, 1) = 0, (4, 2) = 0, (4,
3) = -9/7, (4, 4) = 1});

(5.7)

M3 :=

1 0

0 1

0 0

9
7

0 0 K

(5.7)

De acordo com o que foi explicado acima, podemos calcular a matriz diagonal inferior com
componentes diagonais iguais a 1,
K1

L = M1 M1 M2 K1 = M1
simplesmente justapondo o negativo das colunas de

M2

K1

M3

K1

O produto tambm facilmente obtido simplesmente justapondo o negativo colunas no elementares de

M1 , M2 e M3 :

L=

3
2

1
2

1
3

3
13 9
K
1
4
2
7
Podemos verificar esta afirmao fazendo a computao direta:
O L:=(1/M1).(1/M2).(1/M3);
1
0
0 0
3
2
L :=

1
2

1
3

13
2

9
7

3
4

3 Automatizando a fatorao LU de Doolitle.

Resolvamos o problema do exemplo anterior de forma computacional:
O restart:
O with(LinearAlgebra):

(5.8)

O A:=Matrix(4,4,[4,1,-1,3,6,3,-1,3,-2,-1,5,2,3,-9,2,7]);
4 1 K1 3
6

A :=

3 K1 3

K2 K1

5 2

3 K9

2 7

(5.9)

O L:=Matrix(4,4);
0 0 0 0
0 0 0 0

L :=

(5.10)

0 0 0 0
0 0 0 0

O for i to RowDimension(L) do L[i,i]:=1 od:

O L;
1 0 0 0
0 1 0 0

(5.11)

0 0 1 0
0 0 0 1

Coluna 1
O m:=-A[2,1]/A[1,1];

3
2

m := K
O L[2,1]:=-m:
O U:=RowOperation(A,[2,1],m);
4 1
U :=

K1

3
2

K2 K1
3

K9

O m:=-U[3,1]/U[1,1];
m :=

1
2

(5.12)

1
2

3
2

(5.13)

(5.14)

O L[3,1]:=-m:
O U:=RowOperation(U,[3,1],m);

(5.15)

K1

3
2

1
2

1
0 K
2

9
2

7
2

U :=

K9

O m:=-U[4,1]/U[1,1];

3
3
2

(5.15)

3
4

m := K
O L[4,1]:=-m:
O U:=RowOperation(U,[4,1],m);
4
1

U :=

K1

3
2

(5.16)

1
2

1
2

9
2

7
2

39
4

11
4

19
4

0 K
0 K

3
2
(5.17)

Coluna 2
O m:=-U[3,2]/U[2,2];
m :=
O L[3,2]:=-m:
O U:=RowOperation(U,[3,2],m);
4
1

U :=

1
3

(5.18)

K1

3
2

1
2

14
3

39
4

11
4

19
4

0 K
O m:=-U[4,2]/U[2,2];

m :=

13
2

3
2
(5.19)

(5.20)

O L[4,2]:=-m:
O U:=RowOperation(U,[4,2],m);

(5.21)

K1

3
2

1
2

14
3

K5

U :=

O m:=-U[4,3]/U[3,3];

3
3
2

9
7

m := K

(5.21)

(5.22)

Coluna 3
O L[4,3]:=-m:
O U:=RowOperation(U,[4,3],m);
4 1

U :=

K1

3
2

1
2

14
3

De fato,
O GaussianElimination(A);
4

3
2
(5.23)

62
7

K1

3
2

1
2

14
3

3
2

1
3

13
2

9
7

3
2
(5.24)

62
7

O L;

1
2

3
4

(5.25)

O L.U;

(5.26)

1 K1 3

3 K1 3

K2 K1

5 2

3 K9

2 7

(5.26)

4. Procedimento para o processo de fatorao LU de Doolittle:

Podemos automatizar o processo descrito na seo anterior atravs de um procedimento:
O LUfator:=proc(A)
local n,L, U,k,i,m,c,j,v;
n:=RowDimension(A);
L:=Matrix(n,n);
U:=A;
for c to n do L[c,c]:=1 od:
for i to n do #loop para colunas
for k from i+1 to n do #loop sobre linhas
m:=-U[k,i]/U[i,i];
L[k,i]:=-m:
U:=RowOperation(U,[k,i],m);
od:
od:
for j from 1 to n do #fora os elementos abaixo da diagonal
serem zero
for v from j+1 to n do
U[v,j]:=0:
od:
od:
return(L,U)
end:

LUfator:=proc(A)

Exemplo:
O with(LinearAlgebra):
O A:=Matrix([[-3,2,3,4],[5,6,7,8],[4,-3,2,1],[5,4,2,1]]);
K3 2 3 4
A :=

6 7 8

4 K3 2 1
5

(5.27)

4 2 1

O F:=LUfator(A);

(5.28)

1
5
3

K
F :=

4
3

5
3

K3

28
3

12

44
3

1
28

45
7

48
7

17
45

11
14

(5.28)

19
15

Verifiquemos este resultado:

O F[1].F[2]-A;
0 0 0 0
0 0 0 0

(5.29)

0 0 0 0
0 0 0 0

Exemplo
Resolver o sistema de equaes AX = B com
O nn:=9:N:=70:
O A:=RandomMatrix(nn, nn, generator = 0 .. N);
67 22 18 8 36 33 1 21 39
34 36 29 22 24 69 45 41 14
29 69

9 53 47 29 28 52 54

4 48 68 57 63 26 45 11 21
A :=

56 56 24 54 43 65 23 10 25
62 50 29
22 23

(5.30)

3 36 23 59 48 11

2 25 15

8 41 56 29

1 50 59 12 51 47 44 33 20
62 62 61

4 55 48 21 29

O B:=RandomMatrix(nn, 1, generator = 0 .. N);

(5.31)

41
30
21
25
B :=

34

(5.31)

55
59
66
52
Inicialmente faamos a fatorao LU da matriz A :
LUfator:=proc(A)
Devemos definir a matriz A com coeficientes em pontos flutuantes, caso contrrio o clculo ser feito
com aritmtica racional.
O Af:=evalf(A):
O LU:=LUfator(Af);
LU := 1, 0, 0, 0, 0, 0, 0, 0, 0 ,
(5.32)
0.5074626866, 1, 0, 0, 0, 0, 0, 0, 0 ,
0.4328358209, 2.394831731, 1, 0, 0, 0, 0, 0, 0 ,
0.05970149254, 1.879807693, K0.6380050026, 1, 0, 0, 0, 0, 0 ,
0.8358208955, 1.514423077, 0.4557178592, 0.6353262069, 1, 0, 0, 0, 0 ,
0.9253731343, 1.193509616, 0.2451492491, K1.016096001, K1.257897473, 1, 0, 0, 0
,
0.3283582090, 0.6352163462, 0.3564994231, 0.3198657392, 0.6164924081,
0.1949118832, 1, 0, 0 ,
0.01492537313, 2.000000000, K0.4097831581, K0.7893618514, K2.211401300,
K0.07612010604, K1.055364450, 1, 0 ,
0.9253731343, 1.676682693, K0.2379946338, K1.182531617, K2.075112985,
0.9296227919, K1.804374069, K4.455696763, 1 , 67., 22., 18., 8., 36., 33.,
1., 21., 39. ,
0, 24.83582089, 19.86567164, 17.94029851, 5.73134328, 52.25373134, 44.49253731,
30.34328358, K5.79104478 ,
0, 0, K46.36598558, 6.57331729, 17.69230770, K110.4224760, K78.98497592,
K29.75661058, 50.98798077 ,
0, 0, 0, 26.99188622, 61.36470390, K144.6472075, K89.08992518, K66.27813565,
62.08827912 ,

0, 0, 0, 0, K42.81853592, 100.5033099, 47.37968222, 2.16404769, K61.50936737 ,

0, 0, 0, 0, 0, K63.3852467, K6.58967087, K64.97582428, K44.96237547 ,
0, 0, 0, 0, 0, 0, 41.13935870, 72.96868854, 28.51925642 ,
0, 0, 0, 0, 0, 0, 0, K15.66301862, K8.44209162 ,
0, 0, 0, 0, 0, 0, 0, 0, K10.82042021
O L:=LU[1]:U:=LU[2]:
Resolvamos o sistema LY = B :
O LB:=<L|B>;
LB := 1, 0, 0, 0, 0, 0, 0, 0, 0, 41 ,
(5.33)
0.5074626866, 1, 0, 0, 0, 0, 0, 0, 0, 30 ,
0.4328358209, 2.394831731, 1, 0, 0, 0, 0, 0, 0, 21 ,
0.05970149254, 1.879807693, K0.6380050026, 1, 0, 0, 0, 0, 0, 25 ,
0.8358208955, 1.514423077, 0.4557178592, 0.6353262069, 1, 0, 0, 0, 0, 34 ,
0.9253731343, 1.193509616, 0.2451492491, K1.016096001, K1.257897473, 1, 0, 0, 0,
55 ,
0.3283582090, 0.6352163462, 0.3564994231, 0.3198657392, 0.6164924081,
0.1949118832, 1, 0, 0, 59 ,
0.01492537313, 2.000000000, K0.4097831581, K0.7893618514, K2.211401300,
K0.07612010604, K1.055364450, 1, 0, 66 ,
0.9253731343, 1.676682693, K0.2379946338, K1.182531617, K2.075112985,
0.9296227919, K1.804374069, K4.455696763, 1, 52
O Y:=ForwardSubstitute(LB);
41.
9.19402984940000
K18.7644230760043
K6.70256502810735
Y :=

K1.38270976093041

(5.34)

2.13686604985809
48.9664717861572
82.8023121876474
438.692471669308
Resolvamos agora o sistema UX = Y
O UY:=<U|Y>:
O X:=BackwardSubstitute(UY);

(5.35)

K8.80097581983356
K33.7841701107890
K49.6804798746807
K0.497275687881171
86.6020663059940

X :=

(5.35)

11.7532722333136
K0.0860192953441573
16.5654878709034
K40.5430161819296
De fato,
O evalf(LinearSolve(A,B));
K8.800975488
K33.78416891
K49.68047808
K0.4972756732
86.60206318

(5.36)

11.75327180
K0.08601925032
16.56548726
K40.54301468

5. Inverso de matrizes atravs de fatorao LU

O problema de inverter uma matriz A pode ser entendido como o problema de determinar os vetores
coluna v1 , v2 , $$$, v3 tais que
A v 1 v 2 $$$ vn = e 1 e 2 $$$ en ,
sendo e1 , e2 , $$$ , en os vetores que definem as colunas da matriz identidade de ordem n . Ou seja, a
matriz inversa AK1 dada por
AK1 = v 1 v 2 $$$ vn .
Aqui o uso da fatorao LU
Por exemplo, seja

A :=

Ento
O restart:

1 K1 3

3 K1 3

K2 K1

5 2

3 K9

2 7

O with(LinearAlgebra):
LUfator:=proc(A)

O A := Matrix(4, 4, {(1, 1) = 4, (1, 2) = 1, (1, 3) = -1, (1, 4)

= 3, (2, 1) = 6, (2, 2) = 3, (2, 3) = -1, (2, 4) = 3, (3, 1) =
-2, (3, 2) = -1, (3, 3) = 5, (3, 4) = 2, (4, 1) = 3, (4, 2) =
-9, (4, 3) = 2, (4, 4) = 7});
4 1 K1 3
A :=

O Af:=evalf(A):
O LU:=LUfator(Af);
1
1.500000000

LU :=

3 K1 3

K2 K1

5 2

3 K9

2 7

K0.5000000000 K0.3333333333
0.7500000000
4.

1.

(5.37)

K6.500000000 1.285714286 1
K1.

3.

0 1.500000000 0.500000000 K1.500000000

0

4.666666667

3.000000000

K8.857142858

O L:=LU[1]:U:=LU[2]:
O e[1]:=<1,0,0,0>;e[2]:=<0,1,0,0>;e[3]:=<0,0,1,0>;e[4]:=<0,0,0,
1>;
1
e1 :=

0
0
0
0

e2 :=

1
0
0

(5.38)

0
e3 :=

0
1
0
0

e4 :=

(5.39)

0
1

Resolvamos o sistema LYi = ei i = 1 ..4 :

O <L|e[1]>;
1
1.500000000

0 1

0 0

0 0

K0.5000000000 K0.3333333333
0.7500000000

K6.500000000 1.285714286 1 0

O for i to 4 do
LB[i]:=<L |e[i]>;
od;
1
LB1 :=

1.500000000

0 1

0 0

0 0

K6.500000000 1.285714286 1 0
0

0 0

1.500000000

0 1

0 0

K0.5000000000 K0.3333333333

K6.500000000 1.285714286 1 0

0 0

1.500000000

0 0

0 1

K0.5000000000 K0.3333333333
0.7500000000

LB4 :=

0.7500000000

LB3 :=

K0.5000000000 K0.3333333333
0.7500000000

LB2 :=

(5.40)

K6.500000000 1.285714286 1 0

0 0

1.500000000

0 0

0 0

K0.5000000000 K0.3333333333
0.7500000000

Faamos agora a substituio avanada:

K6.500000000 1.285714286 1 1

(5.41)

O for i to 4 do
V[i]:=ForwardSubstitute(LB[i]);
od;
1.
V1 :=

K1.50000000000000
5.00000041370186 10-11
K10.5000000000643
0.
1.

V2 :=

0.333333333300000
6.07142857137619
0.
0.

V3 :=

1.
K1.28571428600000
0.
V4 :=

0.

(5.42)

0.
1.

Resolvamos agora o sistema UX = Y

O for i to 4 do
UY[i]:=<U|V[i]>:
X[i]:=BackwardSubstitute(UY[i]);
od;
4.
1.
K1.
3.
UY1 :=

0 1.500000000 0.500000000 K1.500000000

1.
K1.50000000000000

4.666666667

3.000000000

5.00000041370186 10-11

K8.857142858

K10.5000000000643

K0.939516128880047
X1 :=

0.439516128880047
K0.762096774059313
1.18548387086028

4.
UY2 :=

1.

K1.

3.

0.

0 1.500000000 0.500000000 K1.500000000

0

4.666666667

3.000000000

1.
0.333333333300000

K8.857142858 6.07142857137619

0.689516128929951
X2 :=

K0.189516128929951
0.512096774103380
K0.685483870895491

4.
UY3 :=

1.

K1.

3.

0.

0 1.500000000 0.500000000 K1.500000000

0.

4.666666667

1.

3.000000000

K8.857142858 K1.28571428600000

K0.104838709702412
X3 :=

0.104838709702412
0.120967741915137
0.145161290340791

4.
UY4 :=

1.

K1.

3.

0.

0 1.500000000 0.500000000 K1.500000000 0.

0

4.666666667

3.000000000

0.

K8.857142858 1.

0.137096774178553
X4 :=

K0.137096774178553
0.0725806451490821

(5.43)

K0.112903225795526
A matriz inversa ento dada por
O AI:=<X[1]|X[2]|X[3]|X[4]>;
AI := K0.939516128880047, 0.689516128929951, K0.104838709702412,
0.137096774178553 ,
0.439516128880047, K0.189516128929951, 0.104838709702412,
K0.137096774178553 ,
K0.762096774059313, 0.512096774103380, 0.120967741915137,
0.0725806451490821 ,
1.18548387086028, K0.685483870895491, 0.145161290340791,
K0.112903225795526

(5.44)

Podemos verificar que esta soluo verdadeira:

O evalf(AI-1/A);
1.52211132600000 10-10 , K1.02307162700000 10-10 , K2.49925635700000 10-11 ,
-11

K1.49955048400000 10

(5.45)

K1.52211021600000 10-10 , 1.02307135000000 10-10 , 2.49925635700000 10-11 ,

1.49955048400000 10-11 ,
1.34235067500000 10-10 , K9.01683172600000 10-11 , K2.03471128800000 10-11 ,
K1.22082621800000 10-11 ,
K1.07466036100000 10-10 , 7.22509829700000 10-11 , 1.82101833600000 10-11 ,
1.09261072400000 10-11

6. Fatorao LU de Doolittle com os comandos do Maple

No Maple a fatorao LU pelo mtodo de Doolittle denominada fatorao LU pelo mtodo de
eliminao gaussiana (default). Mostremos num exemplo:
O with(LinearAlgebra):
O A:=Matrix([[2,4,5],[1,5,3],[6,2,1]]);
2 4 5
A :=

1 5 3

(5.46)

6 2 1
O LU:=LUDecomposition(A, method = 'GaussianElimination');
1
0
0
2 4
5
1 0 0
1
1
1
0
0 3
2
LU := 0 1 0 , 2
,
0 0 1

10
3

(5.47)

37
3

0 0 K

Notemos que a primeira matriz, chamada matriz de permutao, simplesmente a identidade, pois no
foi necessrio fazer nenhuma troca de linhas para evitar diviso por zero durante a eliminao
gaussiana. Podemos verificar o resultado:
O P:=LU[1];L:=LU[2];U:=LU[3];
1 0 0
P :=

0 1 0
0 0 1

L :=

1
2

10
3

U :=

2 4

0 3

1
2

(5.48)

37
3

0 0 K
O P.L.U;
2 4 5
1 5 3

(5.49)

6 2 1
Quando uma troca de linhas necessria, a matriz de permutao leva em tal troca. Por exemplo:
O A := Matrix(4, 4, {(1, 1) = 0, (1, 2) = 1, (1, 3) = 1, (1, 4) =
-3, (2, 1) = -2, (2, 2) = 3, (2, 3) = 1, (2, 4) = 4, (3, 1) =
0, (3, 2) = 0, (3, 3) = 0, (3, 4) = 1, (4, 1) = 3, (4, 2) = 1,
(4, 3) = 0, (4, 4) = 0});
0 1 1 K3
A :=

K2 3 1

0 0 0

3 1 0

O LU:=LUDecomposition(A, method =
1
0
0 1 0 0
0
1
1 0 0 0
LU :=
,
3 11
0 0 0 1
K
2
2
0 0 1 0
0
0

(5.50)

'GaussianElimination');
0 0
K2 3 1
4
0 0
1 0
0 1

0 K4

45
2

K3
(5.51)

de modo que
O P:=LU[1]:L:=LU[2]:U:=LU[3]:
O P.L.U;
0 1 1 K3
K2 3 1

0 0 0

3 1 0

(5.52)

Faamos o clculo da inversa com comandos embutidos do Maple, usando o mtodo LU de Doolittle:
O G d LUDecomposition A, method = GaussianElimination ;
1
0 0 0
K2 3 1
4
0 1 0 0
0
1 0 0
0 1 1 K3
1 0 0 0
G :=
,
,
(5.53)
3 11
45
0 0 0 1
K
1 0
0 0 K4
2
2
2
0 0 1 0
0
0 0 1
0 0 0
1
O AI2 d MatrixInverse G
1
8
AI2 :=

O evalf(%);
0.1250000000

1
8

7
8

1
4

21
8

1
4

3
8

3
8

11
8

45
8

3
8

(5.54)

1
4

K0.1250000000 0.8750000000

0.2500000000

K0.3750000000

0.3750000000

K2.625000000

0.2500000000

1.375000000

K0.3750000000

5.625000000

K0.2500000000

0.

0.

1.

0.

(5.55)

6. Exerccios
1. Compare a eficincia dos cdigos de fatorao LU (do tipo Doolitle, com L ii = 1) que voc
desenvolveu com aqueles que embutidos do seu sistema. Sugesto: Contabilize o tempo necessrio para
resolver um sistema linear aleatrio de ordem 100100.
2. A vantagem da decomposio LU sobre o mtodo da eliminao gaussiana que uma vez que a
matriz A est decomposta, podemos resolver o sistema AX = B para diversos diferentes valores de B
com grande facilidade. O custo de cada soluo adicional relativamente pequeno, pois as estapas de
retrosubstituio so computacionalmente mais simples do que o processo de decomposio. Ilustre
este fato utilizando:
(a) Dez diferentes sistemas lineares de equaes de sua escolha com matriz de coeficientes de ordem
88. Contabilize o tempo necessrio para realizar este clculo utilizando eliminao gaussiana e
fatorao LU (do tipo Doolitle:, com L ii = 1). Utilize os cdigos que voc desenvolveu.
(b) Dez diferentes sistemas lineares de equaes aleatrios, com matriz de coeficientes de ordem
200200. Contabilize o tempo necessrio para realizar este clculo utilizando eliminao gaussiana e
fatorao LU (do tipo Doolitle:, com

ii

= 1). Utilize os cdigos previamente implementados

(embutidos) no seu sistema.

3. Faa a inverso de uma matriz aleatria 300300 utilizando fatorao LU de Doolittle. Compare com
diferentes mtodos.