CALCULO NUMÉRICO

Prof. Jorge C. Lucero

24 de agosto de 2005

Métodos da Bissecção e Newton-Raphson

Baseado no "Practicum in Numerical Analysis (for Maple V)", de G. Beliakov.

> restart;
> Digits:=20:
Este comando estabelece a quantidade de dígitos usados pelos número de ponto flutuante (números
reais) no Maple.

1. Consideremos o seguinte polinômio P(t)

> p:=t->3*t^4-16*t^3+6*t^2+24*t+1;
Este é o gráfico de P(t)

> plot(p(t),t=-2..5,xtickmarks=10);
Definamos a quantidade n de iterações em ambos métodos, o da Bissecção e o de
Newton-Raphson. Os resultados de cada iteração serão guardados nos vetores bss e nr.

> n:=10:
> bss:=array(0..n): nr:=array(0..n):

Esta é a implementação do método de Newton-Raphson. O parametro x0 é a aproximação inicial, n

é a quantidade de iterações, p é a solução obtida depois de n iterações, f é a função cujos zeros
procuramos, e trace é um vetor com os resultados de cada iteração.

> newton:=proc(x0,n,sol,f,trace)
local i,t,der:
der:=D(f):
trace[0]:=x0:
t:=x0:
for i from 1 to n do
t:=t-evalf(f(t))/der(t):
trace[i]:=t:
od:
sol:=t:
end:
>
Esta é a implementação do método da Bissecção. Os parametros a e b são os extremos do intervalo
onde procuramos os zeros,, n é a quantidade de iterações, p é a solução obtida depois de n
iterações, f é a função cujos zeros procuramos, e trace é um vetor com os resultados de cada
iteração.

> bisection:=proc(a,b,n,sol,f,trace)
> local c,i,u,v,w,a1,b1:
> a1:=a: b1:=b:
> u:=f(a1): v:=f(b1):
> if sign(u)=sign(v) then
> lprint(`a função não muda de sinal em [`,a,b,`]?`):
> else
> for i from 1 to n do
> c:=(a1+b1)/2: w:=f(c): trace[i]:=c:
> if sign(u)<>sign(w) then b1:=evalf(c): v:=w: else
a1:=evalf(c): u:=w: fi:
> od:
> sol:=(a1+b1)/2:
> fi:
> end:
Executemos o método da Bissecção com a função P(t), e guardemos os resultados de cada iteração
no vetor y.

> bisection(-1.5,-0.5,n,'solb','p','bss'):
Executemos agora o método de Newton-Raphson, e guardemos os resultados de cada iteração no
vetor x.

> newton(-2,n,'soln','p','nr'):
> lprint(`Newton=`,soln,` Bissecção=`,solb):

Compare as iterações de ambos métodos.

> lprint(` Iteração Newton Bissecção`):

for i from 1 to n do
printf(`%2d %15.13f %15.13f\n`,i,nr[i],bss[i]):
od;
>
Qual o método que converge mais rapidamente?

Encontre os outros zeros de P(t), e complete a tabela abaixo. Modifique os parametros necessários
(indicados com "?") nos procedimentos da Bissecção e Newton-Raphson.

> bisection( ? , ? ,n, 'solb','p','bss'):

> newton( ? ,n,'soln','p','nr'):
> lprint(soln,` `,solb):

Tabela:
 Bisecção Newton-Raphson
N a b zero x0 zero
1 ? ? ?? ? ??
2 ? ? ?? ? ??
3 ? ? ?? ? ??
4 ? ? ?? ? ??

2. Continuemos agora com a seguinte precisão:

> Digits:=10:

Definimos:
> n:=15:
> nr:=array(0..n): bss:=array(0..n):
Consideremos a seguinte função:
> p1:=t->t^3-10*t^2+22*t+6;
Este é o gráfico da função
> plot(p1(t),t=-2..8,xtickmarks=10);

Determinemos o zero negativo desta função. A solução exata é:

> exact_solution:=10/3+2*sqrt(34)*cos(arctan(71*sqrt(47)/1269)/3+5
*Pi/6)/3;
e em forma numérica:
> exact_solution:=evalf(%);

Utilizemos agora os métodos de Newton-Raphson e da Bissecção para calcular este zero.

> newton( -1 ,n,'soln','p1','nr'):
> bisection( -1, 0, n,'solb','p1','bss'):
> lprint(`sol_newton=`,soln,` sol_bisection=`,solb):

Compare as iterações de ambos métodos.

> lprint(` Iteração Newton Bissecção`):

for i from 1 to n do
printf(`%2d %15.13f %15.13f\n`,i,nr[i],bss[i]):
od;

Analisemos os erros em ambos métodos:

> errn:=array(1..n): errb:=array(1..n):

> lprint(`Iteração Erro Newton Erro bissecção`):
> for i from 1 to n do
> errn[i]:=abs(nr[i]-exact_solution):
> errb[i]:=abs(bss[i]-exact_solution):
> printf(`%2d %22.20f
%22.20f\n`,i,errn[i],errb[i]):
> od:
>
Nos vetores cn e cb abaixo coloque, nos locais indicados por "?", a quantidade de dígitos corretos
obtidos em cada método e em cada iteração (cn para o método de Newton, e cb para a Bissecção):

> cn:=array(1..n,[?,?,?,?,?,?,?,?,?,?,?,?,?,?,?]);
> cb:=array(1..n,[?,?,?,?,?,?,?,?,?,?,?,?,?,?,?]);
|____n veces__________|
>
Plote os resultados
> l1:=[[k,cn[k]] $k=1..15]:
l2:=[[k,cb[k]] $k=1..15]:
plot([l1,l2]);
>
Que acontece se a precisão é de 30 dígitos? Volte ao passo 2 e repita os cálculos com esta precisão.
Observe a forma dos gráficos obtidos, para ambos métodos. Qual a forma no método de Newton, e
qual a forma no método da Bissecção? Como está relacionada a forma dos gráficos com a
velocidade de convergencia?
>
Fim da folha.
Importante: tenha certeza de ter compreendido os algoritmos e respondido todas as perguntas
nesta folha (não precisa escrever as respostas). Os tópicos vistos aqui, com perguntas similares
às formuladas, poderão ser incluídos nas provas da disciplina.
>