Universidade Federal de Minas Gerais

Cálculo Numérico

Turma A2
Bruno dos Santos Rocha 2007013023
Diogo Moreira da Silva 2007013260

Professor: Alexandre Salles da Cunha

Data: 17/JUNHO/2008
INTRODUÇÃO

Encontrar a solução de um sistema de equações algébricas lineares é um dos

processos numéricos mais utilizados para simular situações do mundo real. Para
encontrar essas soluções computacionalmente dispomos de alguns métodos, ou
algoritmos, que podem ser divididos em duas classes: os métodos iterativos e os métodos
diretos. Os métodos iterativos são métodos baseados em infinitas repetições e não serão
tratados neste trabalho. Os métodos diretos são aqueles em que a solução do sistema é
obtida com um número finito de operações aritméticas.

Neste trabalho utilizaremos um método direto conhecido como Decomposição LU,

derivado do método da eliminação de Gauss, para resolver um sistema linear simples e
posteriormente verificar os resultados obtidos. A Decomposição LU consiste basicamente
em reescrever uma matriz A de coeficientes como uma multiplicação de duas novas
matrizes, de modo que A = LU, onde L é uma matriz triangular inferior de diagonal unitária
(lii = 1, para todo i) e U uma matriz matriz triangular superior. Deste modo para resolver o
sistema Ax = b usa-se a matriz A em sua forma decomposta

Introduzindo uma variável intermediária y

a partir daí encontramos a solução y do sistema triangular inferior intermediário Ly = b por

substituições sucessivas e a utilizamos como termo independente no sistema triangular
superior Ux = y, cuja solução x é calculada pelas substituições retroativas.

Utilizaremos a Decomposição LU (com pivotação parcial), explicada acima, para

construir um script em Linguagem Scilab que resolva um sistema linear e o testaremos
com o seguinte sistema:
 Onde os n pares de pontos serão gerados da seguinte forma:

● O valores de t serão valores inteiro do intervalo [2,n+1], onde n será um

parâmetro dado.
● As ordenadas p(t) podem ser obtidas observando que

uma vez que p(t) representa a soma dos termos de uma progressão
geométrica de primeiro termo 1 e razão igual a t.

Desta forma o sistema linear a ser resolvido adquire a forma:

Após a resolução do sistema linear acima para alguns valores predeterminados de

n, pede-se para que seja implementada uma rotina que calcula a norma de máxima
magnitude do vetor solução e que seja feita uma análise dos resultados encontrados.
CÓDIGO-FONTE

clear;
clc;

// parâmetro de entrada
n = input("\nDigite a ordem da matriz: ");

// constrói a matriz A a partir do parâmetro de entrada, n.

for i=1:n
for j=1:n
A(i,j) = (i+1)^(j-1);
end
end

// exibe a matriz de coeficientes A

A

// constrói o vetor de termos independentes a partir do parâmetro de entrada, n.

for i=1:n
c(i)=(((i+1)^n)-1)/i;
end

// exibe o vetor de termos independentes

c

for i=1:n
pivot(i)=i;
end
Det=1;

for j=1:(n-1)
// escolhendo o elemento pivotal
p=j; Amax = abs(A(j, j));

for k=(j+1):n
if abs(A(k, j)) > Amax
Amax=abs(A(k,j)); p = k;
end
end

if p~=j
 // troca as linhas
for k=1:n
t=A(j,k); A(j,k)=A(p,k); A(p,k)=t;
end

t=pivot(j); pivot(j)=pivot(p); pivot(p)=t;

// inverte o sinal do determinante (devido a troca de linhas)

Det=-Det;
end

Det = Det*A(j,j);

if abs(A(j,j)) ~= 0
// eliminaçao de Gauss
r = 1/A(j,j);

for i=(j+1):n
m=A(i,j)*r; A(i,j)=m;

for k=(j+1):n
A(i,k)=A(i,k) - m * A(j,k);
end
end
end
end

Det=Det*A(n,n);

//////////
// Substituições sucessivas
/////////

k = pivot(1); y(1)=c(k);

for i=2:n
Soma=0;
for j=1:(i-1)
Soma=Soma+A(i,j)*y(j);
end

k=pivot(i); y(i)=c(k)-Soma;
end
// exibe o vetor intermediário y
y

//////////
// Substituições retroativas
/////////

x(n)=y(n)/A(n,n);
for i=(n-1):-1:1
Soma=0;
for j=(i+1):n
Soma=Soma+A(i,j)*x(j);
end
x(i)=(y(i)-Soma)/A(i,i);
end

// exibe o vetor resposta x

x

// calculo da norma de máxima magnitude do vetor x (resposta)

maxValue=0;

for i=1:n
value=sqrt(x(i)^2);
if value>maxValue
maxValue=value;
end
end

// exibe o valor da norma de máxima magnitude

maxValue
RESPOSTAS

Executando o script com os valores estabelecidos para n = { 4, 14, 20, 32 }

obtemos os seguintes valores para a norma de máxima magnitude.

Como sabemos as respostas obtidas deveriam ser sempre um, e conseguimos

obter essa resposta até o parâmetro n = 7, após esse valor começam a surgir
perturbações no vetor solução x que são refletidas à norma de máxima magnitude.

Essas perturbações são ocasionadas devido a erros de arredondamento, onde o

Scilab ao efetuar os cálculos do nosso sistema linear efetua conversões para exibir o
número de forma normalizada. Com o aumento do n nosso programa estará realizando
operações entre números cada vez mais distantes uns dos outros, e com isso realizando
arredondamentos que terão maior influência na resposta encontrada. Como podemos
observar, a norma de máxima magnitude está tendendo para o infinito a medida que
aumentamos o n, assim podemos inferir que em algum momento em nosso programa há
uma divisão por um número que está sendo aproximado para zero, causando assim o
erro observado.