Resumo Calculo Numério

Prévia do material em texto

Bisseção: 
Define-se o intervalo (a,b) que satisfaça a relação f(a).f(b)<0, o que significa dizer que nesse 
intervalo há uma raiz. Então se faz a média dos valores extremos do intervalo, obtendo xm e, 
com ele, testa-se a relação anterior (f(a).f(b)<0) porém substituindo a ou b por xm (no exemplo 
do algoritmo substituiu-se b por xm). Verificando a validade da relação temos 2 opções: 
 Verdadeira: significa que a raiz está entre a e xm, então muda-se o intervalo de (a,b) 
para (a,xm); 
 Falsa: significa que a raiz está entre xm e b, então muda-se o intervalo de (a,b) para 
(xm,b). 
 
Núcleo do Algoritmo: 
 
%Início do núcleo do método da bisseção 
 xm=(a+b)*0.5 
 if(f(a)*f(xm)<0) 
 %a=a 
 b=xm; 
 else 
 a=xm; 
 %b=b 
 end %if 
%Final do núcleo 
 
Falsa Posição: 
A base é a mesma que o método da Bisseção, porém não se usa o valor médio do intervalo, 
mas sim um valor qualquer escolhido, o que implica numa mudança no algoritmo. Adiciona-se 
a fórmula 
 
 
 para calcula o xf(valor intermediário do intervalo que funcionará 
como se fosse o xm do método da bisseção). 
 
Núcleo do Algoritmo: 
 
%Início do núcleo do método da falsa posição 
 xf=(a*f(b)-b*f(a))/(f(b)-f(a)) 
 if(f(a)*f(xf)<0) 
 %a=a 
 b=xf; 
 else 
 a=xf; 
 %b=b 
 end %if 
%Final do núcleo 
 
 
 
Método da Interação Linear: 
Isola-se uma das incógnitas da função trabalhada, não há restrições com qual incógnita isolar, 
porém para facilitar os cálculos isola-se a mais fácil. No exemplo do algoritmo a função é 
f(x)=x.cos(x)+1,8 e isolando x e fazendo f(x)=0, tem-se x= 
 
 
 . Só que ao isolar um dos x 
fazemos o outro depender dele, ou seja, dentro do algoritmo o x é a raiz da função e xi é o 
valor inicial de chute. 
 
Núcleo do Algoritmo: 
 
%Início do núcleo do método da interação linear 
 x=(-1.9)/(cos(xi)) 
 xi=x; 
%final do núcleo 
 
Newton-Raphson 
Nada mais é que o truncamento da Série de Taylor no segundo termo, já que os valores depois 
do segundo termo são desprezíveis com relação aos 2 primeiros. 
Truncando a Série de Taylor, substituindo x por xi + dx, igualando a zero e isolando dx, tem-se: 
x=xi+dx 
f(x) = f(xi+dx) = f(xi) + f’(xi).dx => dx = 
 
 
 
 
Núcleo do Algorismo: 
 
%Início do núcleo do método de newton-raphson 
 dx=-f(xi)/df(xi) 
 x=xi+dx 
 xi=x; 
%final do núcleo do método 
 
Observação: 
Caso tenha-se uma função cuja derivada não seja tão simples de se achar usa-se a fórmula 
geral de derivação para achar o dx, mudando alguns detalhes no algoritmo. 
 
Núcleo do Algorismo: 
%Início do núcleo do método de newton raphson 
 der=(f(xi+dxi)-f(xi))/dxi; 
 dx=-f(xi)/der 
 x=xi+dx 
 xi=x; 
 dxi=dx; 
%final do núcleo do método 
 
 
Aplicação: 
Aplica-se esse método juntamente com o briot-ruffini para achar as raízes de polinômios 
complicados. Então f(x) torna-se Pn(x) e no algoritmo existem alguns detalhes adicionados, 
como um vetor para os coeficientes do polinômio e uma variável para o grau. No exemplo do 
algoritmos também criou-se um vetor para as prováveis raízes e também um looping para 
calcular as raízes, refiná-las e diminuir o grau do polinômio original para poder achar todas 
raízes distintas. 
 
Algoritmos: 
 
Calcular e refinar todas raízes 
n=5 
a=[1 2 3 0 2 1] 
no=n;ao=a; 
xi=[-1 complex(1,1) complex(1,-1) complex(-1,1) complex(-1,-1)] 
for ir=1:no 
 %A raiz número ir 
 [x(ir) erro cont]=fnrp(n,a,xi(ir)); 
 printf("\n A raiz com redução de grau %d eh (%.20f + %.20fi) com erro=|Pn(x)|=%.20f 
em %d iteracoes\n",ir,real(x(ir)),imag(x(ir)),erro,cont); 
 %Refinamento das raízes obtidas por redução de grau, aplicadas no polinômio original 
 [x(ir) erro cont]=fnrp(no,ao,x(ir)); 
 printf("\n A raiz refinada %d eh (%.20f + %.20fi) com erro=|Pn(x)|=%.20f em %d 
iteracoes\n",ir,real(x(ir)),imag(x(ir)),erro,cont); 
 %reduzindo o grau do polinômio 
 b(1)=a(1); 
 for i=2:n+1 
 b(i)=a(i)+x(ir)*b(i-1); 
 end %for 
 r1=b(n+1); 
 %Redefinindo o polinômio quociente 
 n=n-1; 
 a=b; 
end 
 
Calcular raiz 
function [x erro cont]=fnrp(n,a,xi) 
 erro=1.e2; 
 cont=0; 
 while(erro>1.e1 & cont<200) 
 cont=cont+1; 
 %nucleo do metodo de newton raphson para polinomios 
 b(1)=a(1); 
 for i=2:n+1 
 b(i)=a(i)+xi*b(i-1); 
 end %for 
 r1=b(n+1); 
 c(1)=b(1); 
 for i=2:n 
 c(i)=b(i)+xi*c(i-1); 
 end %for 
 r2=c(n); 
 dx=-r1/r2; 
 x=xi+dx; 
 xi=x; 
 %final do nucleo do metodo 
 erro=abs(r1); 
 end %while 
end 
 
Observação final: só copiei e colei o algoritmo inteiro do polinômio porque nos outros é só 
usar o looping do while sempre usado 