Você está na página 1de 7

1º Trabalho Métodos Computacionais 2013

UNIVERSIDADE FEDERAL DE UBERLÂNDIA


Faculdade de Engenharia Elétrica

Prof: Phd. José Roberto Camacho

Aluno: Eng. Roberto Batista Neto

1º Trabalho:

Exercício nº 26, Lista 1 - Data de entrega 23/04/2013

Uberlândia, 22 de abril de 2013

1
1º Trabalho Métodos Computacionais 2013

1 – OBJETIVO

Este trabalho tem como objetivo resolver o sistema do exercício 23 da lista 1 pelo método
iterativo do gradiente conjugado utilizando chute inicial x1= x2= x3=x4= 0. Verificando o
−1
número de iterações e o resultado para uma tolerância de 1.10 , e comparando o
−5
resultado com a tolerância de 1.10 .

2 – METODOLOGIA

O exercício foi solucionado pela implementação do algoritmo do método do gradiente


conjugado em script do MATLAB. Por se tratar de um método que possui restrições para que
se obtenha a convergência, para o resultado foram feitos três testes antes de se rodar o
algoritmo:

1. Testar se a matriz é quadrada, isto é se o número de linhas “m” e igual ao número de


colunas “n”, para isso foi implementado a seguinte rotina:

[m,n]=size(A)
if (m~=n)
disp({'A Matriz M inserida não é quadrada,não será possível
resolver pelo método'})
break
end

Sendo que não satisfeita a condição o programa para. E é impresso na tela que não será
possível resolver pelo método.

2. Testar se a matriz é simétrica, para isso foi implementado a seguinte rotina:

k=0
for i=1:m
for j=1:n
if A(i,j)==A(j,i)
k=k+1
end
end
end

if k~=m*n
display({'Matriz não Simétrica, não será possível resolver pelo
método'})

break
end

O programa vai percorrer as linhas de 1 a m e as colunas de 1 a n comparando os temos


A(i,j) com A(j,i) assim fazendo mxn comparações se todas as comparações forem

2
1º Trabalho Métodos Computacionais 2013

iguais o contador k terá o valor mxn se não, apresentará uma mensagem que não será
possível realizar pelo método.

3. Testar se a matriz é definida positiva, Uma matriz real simétrica A, n × n, é positiva


definida se para todos os menores principais Ak, constituído das k primeiras linhas e k
primeiras colunas vale: det(Ak) > 0 , k =1,2, . . . , n.
Portanto, seja A uma matriz n × n da forma:

Os menores principais de A de ordens 1,2, . . . n são definidos pelas sub-matrizes de A:

Para isso foi implementado a seguinte rotina:

 Para Menor principal de ordem 1 temos uma matriz 1x1 sendo que o determinante
será o elemento A(1,1)

s=0

DA1=A(1,1)

if DA1>0
s=s+1

end

 Para Menor principal de ordem 2 temos uma matriz 2x2 sendo que o determinante
será a diferença do produto dos elementos das diagonais

DA2= (A(1,1)*A(2,2))-(A(1,2)*A(2,1))

if DA2<0
s=s+1

end

3
1º Trabalho Métodos Computacionais 2013

 Para o Menor principal de ordem 3 temos uma matriz 3x3 sendo que o determinante
será calculado pela regra de Sarrus, que é obtido pela seguinte expressão:
a11⋅a22⋅a 33+ a12⋅a23⋅a 31+a 13⋅a21⋅a32−a13⋅a21⋅a 32−a12⋅a21⋅a33−a11⋅a23⋅a32

DA3= (A(1,1)*A(2,2)*A(3,3))+(A(1,2)*A(2,3)*A(3,1))+
(A(1,3)*A(2,1)*A(3,2))-((A(1,3)*A(2,2)*A(3,1))+(A(1,1)*A(2,3)*A(3,2))+
(A(1,2)*A(2,1)*A(3,3)))

if DA3<0
s=s+1

end

 Para o Menor principal de ordem 4 temos a própria matriz 4x4 sendo que o
determinante será calculado fixando a linha 1
det A=a11⋅A 11 +a12⋅A12 +a13⋅A 13+a14⋅A14 . Em que
A 11 , A 12 , A13 , A 14 são
os cofatores da matriz. O cofator é dado pela expressão:

Em que
Dij é o menor complementar e pode ser calculado pelo determinante da
matriz quando se retira a linha i e coluna j.

sm=A(2:end,1:end);

sm1=sm(1:end,2:end);

D11= (sm1(1,1)*sm1(2,2)*sm1(3,3))+(sm1(1,2)*sm1(2,3)*sm1(3,1))+
(sm1(1,3)*sm1(2,1)*sm1(3,2))-((sm1(1,3)*sm1(2,2)*sm1(3,1))+
(sm1(1,1)*sm1(2,3)*sm1(3,2))+(sm1(1,2)*sm1(2,1)*sm1(3,3)));

A11=D11;

sm2=sm(:,[1 3 4]);

D12= (sm2(1,1)*sm2(2,2)*sm2(3,3))+(sm2(1,2)*sm2(2,3)*sm2(3,1))+
(sm2(1,3)*sm2(2,1)*sm2(3,2))-((sm2(1,3)*sm2(2,2)*sm2(3,1))+
(sm2(1,1)*sm2(2,3)*sm2(3,2))+(sm2(1,2)*sm2(2,1)*sm2(3,3)));

A12=(-1)*D12;

sm3=sm(:,[1 2 4]);

D13= (sm3(1,1)*sm3(2,2)*sm3(3,3))+(sm3(1,2)*sm3(2,3)*sm3(3,1))+
(sm3(1,3)*sm3(2,1)*sm3(3,2))-((sm3(1,3)*sm3(2,2)*sm3(3,1))+
(sm3(1,1)*sm3(2,3)*sm3(3,2))+(sm3(1,2)*sm3(2,1)*sm3(3,3)));

A13=D13;

sm4=sm(1:end,1:end-1);

4
1º Trabalho Métodos Computacionais 2013

D14= (sm4(1,1)*sm4(2,2)*sm4(3,3))+(sm4(1,2)*sm4(2,3)*sm4(3,1))+
(sm4(1,3)*sm4(2,1)*sm4(3,2))-((sm4(1,3)*sm4(2,2)*sm4(3,1))+
(sm4(1,1)*sm4(2,3)*sm4(3,2))+(sm4(1,2)*sm4(2,1)*sm4(3,3)));

A14=(-1)*D14;

DA4= (A(1,1)*A11)+(A(1,2)*A12)+(A(1,3)*A13)+(A(1,4)*A14)

if DA4<0
s=s+1
end

if s>0
disp({'A Matriz inserida não é positiva definida poderá não
convergir'})
end

Nota-se que não foi inserido o break para parar o programa caso a matriz não seja definida
definida pelo fato de que apesar do fato do método ser bem definido para essas matrizes em
alguns casos haverá a convergência mesmo não atendendo a esse critério, como é o caso do
exercício.

Para a implementação do método dos conjugados gradientes seguiu-se o seguinte algoritmo:

0 0 0
Inicialização p =r =b− A⋅x
k k
1. u = A⋅p
(r k )T .( r k )
αk=
2. ( p k )T .(u k )

3. x k +1=x +α k . p k

4. r k +1 =r +α k .u k
(r k +1 )T .(r k +1 )
βk=
5. (r k )T .(r k )

6. pk +1=r k +1 +β k . p k

Ficando:

%Método dos Gradientes Conjugados


%Inicialização do método, o vetor c representa o produto Axº do
algoritmo.

c=[A(1,1)*x(1,1)+A(1,2)*x(2,1)+A(1,3)*x(3,1)+A(1,4)*x(4,1);
A(2,1)*x(1,1)+A(2,2)*x(2,1)+A(2,3)*x(3,1)+A(2,4)*x(4,1);
A(3,1)*x(1,1)+A(3,2)*x(2,1)+A(3,3)*x(3,1)+A(3,4)*x(4,1);
A(4,1)*x(1,1)+A(4,2)*x(2,1)+A(4,3)*x(3,1)+A(4,4)*x(4,1)];

p = [b(1,1)-c(1,1);b(2,1)-c(2,1);b(3,1)-c(3,1);b(4,1)-c(4,1)];

5
1º Trabalho Métodos Computacionais 2013

r = p;

% R maiúsculo é o valor máximo encontrado no vetor resíduo r minúsculo

R = max(abs(r));

z=0;

%Depois de inicializado o método, entra no loop while em que enquanto


R>T,
%isto e, residuo>tolerancia ocorrerá as iterações.

while R>T

u = [A(1,1)*p(1,1)+A(1,2)*p(2,1)+A(1,3)*p(3,1)+A(1,4)*p(4,1);
A(2,1)*p(1,1)+A(2,2)*p(2,1)+A(2,3)*p(3,1)+A(2,4)*p(4,1);
A(3,1)*p(1,1)+A(3,2)*p(2,1)+A(3,3)*p(3,1)+A(3,4)*p(4,1);
A(4,1)*p(1,1)+A(4,2)*p(2,1)+A(4,3)*p(3,1)+A(4,4)*p(4,1)];

alfa=
(r(1,1)*r(1,1)+r(2,1)*r(2,1)+r(3,1)*r(3,1)+r(4,1)*r(4,1))/(p(1,1)*u(1,
1)+p(2,1)*u(2,1)+p(3,1)*u(3,1)+p(4,1)*u(4,1));

x1 =
[x(1,1)+alfa*p(1,1);x(2,1)+alfa*p(2,1);x(3,1)+alfa*p(3,1);x(4,1)+alfa*
p(4,1)]

r1 = [r(1,1)-alfa*u(1,1);r(2,1)-alfa*u(2,1);r(3,1)-alfa*u(3,1);r(4,1)-
alfa*u(4,1)];

beta=
(r1(1,1)*r1(1,1)+r1(2,1)*r1(2,1)+r1(3,1)*r1(3,1)+r1(4,1)*r1(4,1))/
(r(1,1)*r(1,1)+r(2,1)*r(2,1)+r(3,1)*r(3,1)+r(4,1)*r(4,1));

p =
[r1(1,1)+beta*p(1,1);r1(2,1)+beta*p(2,1);r1(3,1)+beta*p(3,1);r1(4,1)+b
eta*p(4,1)]

R = max(abs(r1))

z=z+1;

r=r1;

x=x1;
end
str=['O número de iterções é igual a ' num2str(z)];
disp(str);

break

3 – RESULTADOS E CONCLUSÕES

6
1º Trabalho Métodos Computacionais 2013

−1 −5
Para uma tolerância de 1.10 e uma tolerância de 1.10 , chegou-se ao mesmo número
de iterações. Devendo-se ao fato de que a convergência foi bem eficaz acertando os zeros do
sistema com uma boa precisão sem a necessidade de muitos refinamentos.

4– BIBLIOGRAFIA

Para uma tolerância

[1] GRIFFITHS ,D. V.; SMITH, I.M. Numerical Methods for Engineers A Programming
Approach. Oxford University Press, 1993.

[2] FRANCO,N.B. Cálculo Numérico. São Paulo: Pearson Prentice Hall, 2006.

[3] CHAPMAN, Steven J. Programação em MATLAB® para engenheiros. São Paulo:


Thomson Learning, 2006.

[4] GOUVÊIA, Pimentel. Matrizes e Determinantes. Belo Horizonte, 2005.