P1 - Cálculo Numérico

Aluna: Lauane de Souza Lessa

Metrícula:119035005

Métodos para zero de funções

1.1 - Método de Newton-Raphson
De forma geral, o método consiste em aproximações baseadas nas derivadas das
funções em determinados pontos. Portanto, claramente precisamos de uma função contínua
que seja diferenciável em todos os pontos do intervalo estudado. Podemos iniciar o programa
atribuindo um valor x0 de saída ou implementarmos um código que insira um valor aleatório
para a função em análise.
Uma vez iniciado, o programa irá entrar em um laço que irá obter valores cada vez
mais próximos da raiz da função e que apresentarão a estrutura que segue:
· x1 = x0 – f (x0) / f ’(x0)
· x2 = x1 – f (x1) / f ’(x1)
.
.
.
· xn+1 = xn – f (xn) / f ’(xn)
Tal processo irá se repetir até que uma precisão pré-determinada seja alcançada (isso
pode ser facilmente interrompido por um critério de parada.
Dependendo do valor inicial x0 utilizado no programa, o método pode nos afastar da
solução e exigir um número maior de iterações. Tendo isso em mente, é aconselhável plotar
os gráficos das funções estudadas, sempre que possível, para que o chute inicial seja feito de
maneira mais racional e inteligente. Outro modo de realizarmos o chute é combinarmos o
método de Newton-Raphson a outro método que possa nos retornar um intervalo seguro para
a obtenção da aproximação.
O método tem a vantagem de possuir uma convergência quadrática. Porém, há
necessidade do cálculo da derivada da função estudada para que o método seja
implementado, o que é uma desvantagem.

1.2 - Método de Bissecção

De forma geral, o método consiste em uma busca binária pelo zero da função
problema. Suponhamos uma função f(x), contínua ou não, mas bem definida no intervalo
[a,b] (o intervalo [a,b] deve ser contínuo). Primeiro analisamos se f(a).f(b)<0. Em caso
verdadeiro, isto indica que os valores da função para os pontos a e b têm valores opostos: -
f(a)/|f(a)|= f(b)/|f(b)|.
Em seguida, dividimos o intervalo [a,b] pela metade, em um ponto p. Analisando os
sinais da função para os três pontos em questão [f(a),f(b),f(p)], chegamos em três casos:
I - f(p)=0: O ponto p é raiz da função.
II - f(p).f(a)<0: A raiz da função encontra-se no intervalo [a,p]. Deste modo, há uma
atualização do intervalo inicial [a,b] para [a,p].
III - f(p).f(a)>0: A raiz da função encontra-se no intervalo [p,b]. Deste modo, há uma
atualização do intervalo inicial [a,b] para [p,b].
O processo anterior se repete até que um critério de parada o interrompa.

Ao implementarmos o método, é aconselhável que o cálculo para obtenção do ponto

médio Pn seja feita da seguinte forma:
Pn = an + (bn - an)/2
Uma forma equivalente e mais intuitiva seria:
Pn = (an + bn)/2
Porém, esta segunda forma apresenta maior ampliação do erro em relação à primeira.
Ou seja, o primeiro modo irá resultar em menores erros de arredondamento quando
implementado.
É possível determinar previamente o número de iterações necessárias para se obter a
aproximação desejada, de acordo com o tamanho do intervalo inicial definido e a tolerância
imposta:
Sabemos que o comprimento de um intervalo [bk,ak] é sempre a metade do
comprimento do intervalo anterior [bk-1,ak-1], logo:
 O menor valor de k que satisfaz a desigualdade é também o menor número de
iterações necessárias. Como se pode ver pela desigualdade, ao tomar um intervalo muito
grande, se comparado a ε, a convergência do método é muito lenta.

1.3 - Método da Falsa-Posição

De forma geral, o método consiste na utilização de pares [a,b] de aproximações que
englobam a raiz nesse intervalo. Inicialmente devemos inserir no método dois valores de
saída, dois parâmetros iniciais: P0 e P1. Além disso, temos que analisar o valor de f(P0). f(P1).
Casos possíveis:
I - f(P0). f(P1) = 0: P0 e/ou P1 é raiz da função.
II - f(P0). f(P1) < 0: A raiz da função encontra-se no intervalo [P0, P1].
III - f(P0). f(P1) > 0: Não necessariamente a função possui raiz e, para o Método da Falsa-
Posição, este caso não é interessante.
Como visto no caso II, para que possamos utilizar o Método da Falsa-Posição, os
valores da função nos pontos P0 e P1 devem ser opostos. Nesse caso, o Teorema de Bolzano
nos garante a existência de uma raiz. Para determinarmos o valor de P 2, é necessário
traçarmos uma reta r entre os pontos [P0, f(P0)] e [P1, f(P1)], como indicado na figura a seguir.
A posição do ponto P2 é onde a reta r intercepta o eixo das abscissas.
Porém, P2 é a primeira aproximação de raiz do programa, é necessário que haja um
refinamento dos valores obtidos. Para que isso ocorra, precisamos encontrar um P 3, P4, P5...
até que algum critério de parada seja satisfeito.
Para encontrarmos P3, devemos analisar o sinal de f(P1). f(P2):
- Se f(P1). f(P2) > 0: Atualiza-se o intervalo [P0, P1] para [P0, P2];
- Se f(P1). f(P2) < 0: Atualiza-se o intervalo [P0, P1] para [P1, P2];
Este processo é repetido, em termos gerais, da seguinte maneira:
Para encontrarmos Pn, devemos analisar o sinal de f(Pa). f(Pb):
- Se f(Pa). f(Pb) > 0: Atualiza-se o intervalo [Pc , Pd] para [Pc , Pb] ;
- Se f(Pa). f(Pb) < 0: Atualiza-se o intervalo [Pd , Pd] para [Pd , Pb] ;
1.4 - Método da Secante
O método da secante é similar ao método da falsa-posição, o qual, na realidade, é um
caso particular do primeiro. Estudemos o método:
Este algoritmo consiste em determinar um intervalo [x1, x0] onde a função é contínua.
Nesta aplicação, não é necessário que a raiz da função esteja contida no intervalo e, por essa
razão, é sua viabilidade em certos casos é maior.
Definido o intervalo, o próximo passo é traçar uma reta secante à curva, que passe
pelos dois pontos. Esta reta intercepta o eixo das abcissas em um dado ponto x2. Este, por sua
vez, configura um novo intervalo, definido por [x2, x1].
O passo anterior se repete e novos intervalos [xk, xk-1] são definidos, como mostra a
figura abaixo. O método chega ao fim após atender um dos critérios de parada.
 O valor aproximado da raiz da função (xn+1) é dado pela expressão abaixo:

O método da secante também é similar ao método de Newton-Raphson. Uma

diferença é que a reta secante é substituída pela tangente em um dado ponto. A substituição
da tangente no método de Newton pela secante torna o método relativamente mais simples,
pois não é necessário calcular a derivada da função para de obter o coeficiente angular da
reta.
Outra diferença entre o método da secante e o de Newton diz respeito à ordem de
convergência (α) que, neste método, é dada por:

Onde α recebe a denominação de razão áurea. O valor de 1.618 configura

convergência superlinear (α>1 e α<2).

1.5 - Método do Ponto Fixo

Definição: um número α é um ponto fixo de uma dada função se Φ(α) = α.
Com a definição acima, temos que um ponto fixo de uma função é um número no qual
o valor da função não muda quando a função é aplicada. Considerando uma função Φ(x) = x2
– 2, por exemplo, temos que os pontos fixos são as intersecções de y = Φ(x) com y = x, ou
seja, α1 = -1 e α2 = 2, conforme ilustra o gráfico abaixo:

Encontrar raízes e encontrar pontos fixos são problemas equivalentes no seguinte sentido:
• Seja f(x) uma função contínua em [a, b], intervalo que contém uma raiz da equação
f(x) = 0. O Método do Ponto Fixo consiste em transformar esta equação em uma
equação equivalente x = Φ(x) e a partir de uma aproximação inicial gerar a sequência
{xk} de aproximações para a raiz R pela relação xk+1 = Φ(xk), pois a função Φ(x) é tal
que f(R) = 0 se e somente se Φ(R) = R. Assim, transforma-se o problema de encontrar
 um zero de f(x) no problema de encontrar um ponto fixo de Φ(x). Uma função que
satisfaz essa condição é chamada função de iteração para a equação f(x) = 0.
Resumindo: se existir um α no intervalo [a,b] tal que α = Φ(α), este número é dito ponto
fixo de Φ e pode ser calculado pelo seguinte algoritmo, que é chamado de iterações de ponto
fixo:

no qual x(0) é a aproximação inicial.

Vale ressaltar que nem sempre a função φ(x) irá convergir para a raiz, como ilustram
as figuras abaixo:

Assim sendo, existe um teorema, o qual determina que, dado um intervalo I contendo
a raiz, para que a função φ(x) possa ser utilizada na implementação do método,

Das definições de convergências, concluímos que o método do ponto fixo, em geral,

apresenta convergência linear:
De acordo com o teorema enunciado acima, temos
 Se tomarmos o limite de k-> ∞, obtemos

Dessa forma, por conta do teorema,

Onde ek é o erro associado à iteração k. Sendo assim, conclui-se que a convergência

é, em geral, linear. Porém, isto nem sempre ocorre.
Observações:
Nas condições do Teorema do Ponto Fixo expostas acima, temos:
• Se 0<g'(x)<1 então a convergência é monótona, isto é, se a iteração inicial estiver à
direita (à esquerda) da raiz, então todas iterações ficam à direita (à esquerda) da raiz.
• Se -1<g'(x)<0 então a convergência é alternada, isto é, as iterações irão alternar à
esquerda e à direita da raiz.
Caso as condições do Teorema não tenham sido atendidas, o comportamento da
função será como os dois gráficos localizados na região inferior da figura abaixo, isto é, os
valores calculados divergem da raiz esperada.
Critérios de Parada:
Dada uma função f(x), contínua e diferenciável no intervalo [a,b]. O programa irá sair do laço
quando:
• |f(p)|<E; sendo p um ponto aproximado da solução exata e E a precisão (épsilon)
fornecida pela máquina.
• |b-a|<E; sendo a e b os limites do intervalo utilizado para obter a aproximação da raiz
da função. |b-a| corresponde ao comprimento do intervalo.
• f(a).f(b)<E;
Além desses, existem outras condições que serviriam como parâmetro para que o programa
fosse interrompido. A utilização de um critério de parada depende do algoritmo
implementado, do número de iterações e da disponibilidade computacional da máquina.
Desse modo, é necessário avaliar cada um deles para que o mais eficiente seja utilizado nos
resultados finais.

Exemplos:
1. Os algoritmos desenvolvidos a seguir têm como objetivo encontrar o valor de x para
valores negativos de E na seguinte função:

Para isso, utiliza-se o Método da Bissecção, o Método de Falsa-Posição e o Método de Newton-

Raphson, pois o problema é equivalente a encontrar zeros da função f(x) = – 1/x3 – 1/x2 – E
para diferentes valores negativos de E. Além disso, deve-se determinar o número de iterações
até que o erro seja |xn+1-xn| ≤ eps.max{1, |xn+1|}, sendo eps o épsilon da máquina.

Método da Bissecção
Os resultados a seguir foram obtidos utilizando o valor E=-5 e ao chamarmos a função
no intervalo [0.66,0.76]. Alguns comandos incomuns foram utilizados no código, como deff.
Tal comando define a função que está contida nos parênteses e possibilita sua análise pelo
método descrito como "function[x]=Bisection_Method(f,A,B)". O método implementado
busca um valor intermediário em relação ao intervalo inicial para cada iteração realizada.
Analisando os valores da função para cada ponto obtido, o programa prossegue na busca de
uma raiz que satisfaça o critério de parada (proposto pelo exercício acima) utilizado.

E=input("Entre com um valor negativo para E:")

x=0.66:0.001:0.76
y=[(-1-x)./x.^(3)]-E;
plot(x,y)
xlabel('x')
ylabel('Função em Análise')
set(gca(),"grid",[0.001 0.001])

deff('[y]=f(x)','y=[(-1-x)./x.^(3)]-E')

function[x]=Bisection_Method(f,A,B)
i=1;
Nmax=100;
Fa=f(A)
while i<=Nmax do
x=A+(B-A)./2;
F=f(x)
if (F==0|abs(B-A)./2< %eps.*max(1,abs(x))) then
disp(i,"Número de iterações: ");
return(x);
break;
end
i=i+1
if Fa.*F>0 then
A=x;
Fa=F;
else
B=x;
end
end
endfunction
Método da Falsa-Posição
Considerando E = -5 e o mesmo intervalo [0.66,0.76] (chamado na função) do Método da
Bissecção, podemos resolver o problema pelo Método de Falsa-Posição. Alguns comandos
incomuns foram utilizados no código, como deff. Tal comando define a função que está contida
nos parênteses e possibilita sua análise pelo método descrito como
"function[x]=False_Position(x0,x1,f)". Os parâmetros x0 e x1 são valores de x quaisquer
pertencentes a um intervalo onde a função é contínua. Caso contrário, o programa irá indicar
tal erro. Além disso, é necessário rodar o programa para que o método implementado seja
gravado pela máquina. Desse modo, não é necessário rodar o programa novamente para
obtermos os resultados esperados. Isso facilita o teste do método para diferentes intervalos sem
que o programa tenha que ser inicializado a cada mudança de parâmetro.

E=input("Entre com um valor negativo para E:")

y=[(-1-x)./x.^(3)]-E
deff('[y]=f(x)','y=[(-1-x)./x.^(3)]-E')

function[x]=False_Position(x0,x1,f)

i=2;
Nmax=100;
b0=f(x0);
b1=f(x1);
while i<=Nmax do
 x=x1-(b1.*(x1-x0))./(b1-b0);
if (abs(x-x1))<%eps.*max(1,abs(x)) then
disp(i,"Número de iterações: ");
return(x);
break;
end
i=i+1;
q=f(x);
if (q.*b1<0) then
x0=x1;
b0=b1;
end
x1=x;
b1=q;
end
endfunction

Ao chamarmos a função "function[x]=False_Position(x0,x1,f)" definida no código acima,

utilizamos os parâmetros x0=0.66 e x1=0.76:
--> False_Position(0.66,0.76,f)
Número de iterações: 17.
ans =
0.6976285

Método de Newton-Raphson
Alguns comandos incomuns foram utilizados no código, como deff. Tal comando
define a função que está contida nos parênteses e possibilita sua análise pelo método descrito
como "function[x]=Newton_Raphson(xi,f,fd)". O parâmetro x0 representa um chute inicial
para a raiz procurada. Além disso, é necessário rodar o programa para que o método
implementado seja gravado pela máquina. Desse modo, não é necessário rodar o programa
novamente para obtermos os resultados esperados. Isso facilita o teste do método para
diferentes chutes iniciais sem que o programa tenha que ser inicializado a cada mudança de
parâmetro. O valor de E utilizado nos resultados descritos abaixo foi E = -5, para permitir uma
comparação mais fiel entre os códigos.
E=input("Entre com um valor negativo para E:")

deff('[y]=f(x)','y=[(-1-x)./x.^(3)]-E')
deff('[y] = fd(x)','y=(2*x+3)/x.^(4)')
x=(1:0.001:100)
y=f(x)

function[x]=Newton_Raphson(xi,f,fd)
Ni=100;
xx=xi;
while(Ni>0)
x=xi-f(xi)/fd(xi);
if abs(x-xi)<=%eps.*max(1,abs(x)) then
disp(100-Ni,"Número de iterações: ")
return(x);
break;
end;
Ni=Ni-1;
xi=x;
end;
endfunction

Ao chamarmos a função "function[x]=Newton_Raphson(xi,f,fd)" definida no código acima,

utilizamos os parâmetros xi=0.7 como uma aproximação inicial da raiz:
-->Newton_Raphson(0.7,f,fd)
Número de iterações: 3.
ans =
0.6976285
Comparação dos resultados obtidos:
Para o valor de E = -5 estabelecido previamente, observa-se mesma precisão da raiz e
mesmo número de iterações nos algoritmos desenvolvidos pelo Método da Bissecção. O
mesmo ocorre para o Método da Falsa-Posição. Porém, este segundo método permitiu obter
uma precisão muito maior (o valor de f(x) ao fim das iterações foi dado como 0.0) em relação
ao primeiro, além de ter sido finalizado com apenas 17 iterações, enquanto o primeiro teve 49
iterações.
O Método de Newton-Raphson foi ainda mais eficiente, sendo possível obter uma
precisão tão boa quanto a do Método da Falsa-Posição e ainda diminuir o número de iterações.
Esta diferença de iteração é explicada pelo fato de que a resolução em Scilab não considera o
"chute" inicial como uma iteração, enquanto no outro algoritmo isso é considerado, e o laço já
começa com uma iteração contabilizada. A maior eficiência desse método é explicada pelo fato
de que sua convergência é quadrática, ou seja, mais rápida do que a convergência linear dos
outros dois métodos.

2. Considerando a figura a seguir:

O máximo comprimento L de uma barra que pode passar de uma extremidade a outra
deslizando no solo, na situação acima, é dado por:

onde α é a solução da equação não linear:

Alguns comandos incomuns foram utilizados no código, como deff. Tal comando define a
função que está contida nos parênteses e possibilita sua análise pelo método descrito como
"function[a]=Newton_Raphson(a0,f,fd)". O parâmetro x0 representa um chute inicial para a
raiz procurada. Além disso, é necessário rodar o programa para que o método implementado
seja gravado pela máquina. Desse modo, não é necessário rodar o programa novamente para
obtermos os resultados esperados. Isso facilita o teste do método para diferentes chutes iniciais
sem que o programa tenha que ser inicializado a cada mudança de parâmetro.
A função utilizada nesse código foi y=cos(p-a).cos(a).[b-c] + c.cos(p-a) - b.cos(a). O motivo
para a escolha desse formato para a expressão é a ausência de variáveis no denominador. Por
termos uma expressão com denominador comum igual a 1, excluímos uma das potenciais
fontes de erro.
c=10; //L2=c
b=8; //L1=b
p=2.*%pi./5;
g=3.*%pi./5;
tol=10.^(-12);
//y=cos(p-a).*cos(a).*(b-c)+c.*cos(p-a)- b.*cos(a)
deff('[y]=f(a)','y=cos(p-a).*cos(a).*(b-c)+c.*cos(p-a)- b.*cos(a)')
deff('[y] = fd(a)','y=(c-b).*sin(2.*a-p)+b.*sin(a)-c.*sin(a-p)')
a=(0:0.001:2.*%pi)
//y=f(a)
function[a]=Newton_Raphson(a0,f,fd)
Ni=100;
aa=a0;
while(Ni>0)
a=a0-f(a0)/fd(a0);
if abs(a-a0)<tol then
disp(100-Ni,"Número de iterações: ")
L=c./(sin(%pi-g-a))+b./(sin(a))
disp(L,"Comprimento máximo da barra: ");
return(a);
break;
end;
Ni=Ni-1;
a0=a;
end;
endfunction

Ao chamarmos a função "function[a]=Newton_Raphson(a0,f,fd)" definida no código acima,

utilizamos os parâmetros xi=π/4 como uma aproximação inicial da raiz:
-->Newton_Raphson(%pi/4,f,fd)
Número de iterações: 3.
Comprimento máximo da barra: 30.548969
ans =
0.5990104

Método da Secante
Alguns comandos incomuns foram utilizados no código, como deff. Tal comando define a
função que está contida nos parênteses e possibilita sua análise pelo método descrito como
"function[a]=Secante(x0,x1,f)". Os parâmetros x0 e x1 determinam um intervalo, cada extremo
com um determinado valor de função f(x0) e f(x1), para que o método possa iniciar as iterações.
Além disso, é necessário rodar o programa para que o método implementado seja gravado pela
máquina. Desse modo, não é necessário rodar o programa novamente para obtermos os
resultados esperados. Isso facilita o teste do método para diferentes chutes iniciais sem que o
programa tenha que ser inicializado a cada mudança de parâmetro.
c=10; //L2=c
b=8; //L1=b
p=2.*%pi./5;
g=3.*%pi./5;
tol=10.^(-12);
//y=cos(p-a).*cos(a).*(b-c)+c.*cos(p-a)- b.*cos(a)
deff('[y]=f(a)','y=cos(p-a).*cos(a).*(b-c)+c.*cos(p-a)- b.*cos(a)')
a=(0:0.001:2.*%pi)
//y=f(a)
function[x]=Secante(x0,x1,f)
i=2;
Nmax=100;
b0=f(x0);
b1=f(x1);
while i<=Nmax do
x=x1-(b1.*(x1-x0))./(b1-b0);

if (abs(x-x1)<%eps) then
disp(i,"Número de iterações: ");
L=c./(sin(%pi-g-x))+b./(sin(x))
disp(L,"Comprimento máximo da barra: ");
return(x);
break;
end
i=i+1;
q=f(x);
if (q.*b1<0) then
 x0=x1;
b0=b1;
end
x1=x;
b1=q;
end
endfunction
Ao chamarmos a função "function[x]=Secante(0.3,0.7,f)" definida no código acima,
utilizamos os parâmetros x0=0.3 e x1=0.7:
-->Secante(0.3,0.7,f)
Número de iterações: 10.
Comprimento máximo da barra: 30.548969
ans =
0.5990104

Comparação dos resultados obtidos:

Algumas comparações sobre os resultados obtidos para os códigos implementados em
diferentes linguagens (e considerando diferentes funções possíveis para resolução do
problema) foram feitas entre os algoritmos, a fim de facilitar a visualização das diferenças
obtidas. A principal conclusão é que a função considerada, a forma de escrevê-la, e o erro por
arredondamento gerado por essas condições exercem grande influência no resultado obtido,
como notado nas discussões mencionadas.
A diferença no número de iterações entre métodos ocorre devido ao tipo de convergência,
super-linear (mais rápida que a linear) para a secante e quadrática (mais rápida que a super-
linear) para Newton.

3. O exercício consiste em analisar a convergência das iterações de ponto fixo

para o cálculo da raiz quadrada de um número positivo a, sendo que k representa a k-ésima
iteração.
Inicialmente, estabelecemos um número positivo a = 10 para o cálculo de sua raiz. Com isso,
temos que a função de iteração é dada por: Φ(x) = x(x2+30)/(3x2+10). O ponto fixo p é tal que
Φ(p) = p, cuja única solução conveniente é p = √10, como determinado pelo método.
A derivada da função de iteração para a = 10 é dada por:
E a segunda derivada é:

Temos que Φ’(p) = 0 e Φ’'(p) = 0. O método converge pelo menos quadraticamente.

Verificaremos este resultado teórico por meio do algoritmo desenvolvido a seguir:
A função auxiliar utilizada no código abaixo foi a mesma implementada no algoritmo
anterior. Optamos por esse caminho para podermos comparar, de forma mais clara, os
resultados obtidos pelos programas. Além disso, os cálculos apresentados abaixo irão indicar
o processamento do programa para o cálculo da raiz de a = 9.108 e a = 3.10-4.
Detalhes do programa: Um dos parâmetros de entrada do programa (x0) é uma aproximação
qualquer da raiz do número analisado. Tal valor é variável, ou seja, funciona como um chute
inicial. Suponhamos que nós não soubéssemos a raiz de 25, ou, de alguma forma, achássemos
que a raiz de 25 fosse próxima de 4. Desse modo, nós chamaríamos a função
Fixed_Point(x0,a,f) trocando os parâmetros x0 e a por x0=4 e a=25: Fixed_Point(4,25,f). Ao
fazermos isso, o que acontece é que a condição presente no interior do laço não será satisfeita
e o programa irá entrar em loop até que a diferença entre dois valores calculados abs(x-x0)
seja menor do que a tolerância/precisão (E) desejada. Porém, o número de iterações depende
desse chute inicial.
E=10^-12
deff('[x]=f(x0)','x=(x0*(x0^2+3*a))/(3*(x0^2)+a)')
function [x0]=Fixed_Point(x0,a,f)
i=1
Nmax=50
while i<=Nmax do
x=(x0*(x0^2+3*a))/(3*(x0^2)+a)
if abs(x-x0)<E
disp(i,"Número de iterações: ")
return(x);
break;
end
i=i+1
x0=x
plot(i,x,'r.')
xlabel('Número de Iterações')
ylabel('Raiz de a')
set(gca(),"grid",[0.001 0.001])
end
endfunction
Para a= 9.108 = 900000000
-->Fixed_Point(1,900000000,f)

Número de iterações: 14.

ans =
30000.
Para a= 3.10-4 = 0.0003

-->Fixed_Point(1,0.0003,f)
Número de iterações: 7.
ans =
0.0173205

Discussão dos resultados:

Observa-se que, para valores distantes da raiz, o resultado de uma iteração é aproximadamente
o triplo do resultado da iteração anterior. Conforme esses valores se aproximam da raiz, essa
"velocidade" com que o método se aproxima da raiz diminui, até que se alcance a raiz com
uma precisão adequada e com número de iterações relativamente baixo. Como dito
anteriormente, o número de iterações depende da distância da raiz para a aproximação inicial.
Nos resultados práticos, mesmo com a aproximação inicial não sendo tão próxima da raiz, o
número de iterações foi baixo.
Dessa forma, a convergência observada por meio dos resultados obtidos a partir do algoritmo
confirmam o resultado teórico.