Você está na página 1de 29

UNIVERSIDADE FEDERAL DOS VALES DO JEQUITINHONHA E MUCURI

INSTITUTO DE CIÊNCIA E TECNOLOGIA


CURSO DE BACHARELADO EM ENGENHARIA QUÍMICA

MÉTODOS ITERATIVOS:
Implementação dos métodos de Newton-Raphson, Método da Bissecção e Método da
Substituição Sucessiva

Alessandra Byrro Rodrigues


Jéssica Lopes Pimenta
Tárik Silva Maurício

Diamantina
2015
UNIVERSIDADE FEDERAL DOS VALES DO JEQUITINHONHA E MUCURI
INSTITUTO DE CIÊNCIA E TECNOLOGIA
CURSO DE BACHARELADO EM ENGENHARIA QUÍMICA

MÉTODOS ITERATIVOS:
Implementação dos métodos de Newton-Raphson, Método da Bissecção e Método da
Substituição Sucessiva

Alessandra Byrro Rodrigues


Jéssica Lopes Pimenta
Tárik Silva Maurício

Relatório apresentado à disciplina de


Modelagem e Simulação de Processos
Químicos, como parte dos requisitos exigidos
para a conclusão do curso Bacharelado em
Engenharia Química.

Diamantina
2015
1.0 INTRODUÇÃO

Em um mercado competitivo é exigido do engenheiro químico a resolução de inúmeros


problemas matemáticos complexos que exigem eficiência e confiabilidade em sua resolução.
Para isso, ao longo do curso de graduação foram ofertadas diversas disciplinas que envolvem a
modelagem de processos, onde os desafios apresentados por elas nem sempre são solucionados
através de soluções analíticas, sendo necessário o uso de softwares computacionais. Dessa forma
o contato com a análise de modelos matemáticos complexos desenvolve no profissional de
engenharia habilidades que garantem uma alta confiança e segurança de seus resultados
(GREPINO & RODRIGUES, 2015).

“O uso de ferramentas computacionais em ciência e engenharia cresceu muito com o


aumento da velocidade de processamento dos computadores, a diminuição relativa dos seus
preços e o aparecimento de pacotes (ou aplicativos) para usos específicos ou gerais (POLON et.
all., 2006)”. Existem softwares livres ou de proprietários, exigindo o último o pagamento de uma
licença para utilizá-lo, ao passo que o primeiro permite rodar, copiar, distribuir, estudar, alterar e
melhorar o software (POLON et. all., 2006).

Dentre os programas pagos mais utilizados estão o Matlab e o Maple, cuja utilização no
meio acadêmico nem sempre é viável devido ao preço impostos pelos proprietários e a
dificuldade de distribuição legal para os estudantes. A fim de apresentarem as diferenças entre
softwares pagos e livres, alguns autores descrevem uma metodologia comparando dois softwares
de naturezas diferentes e que possuem praticamente as mesmas funções. Segundo POLON et.
all., (2006) alguns programas como planilhas de cálculo Gnumeric versus Excel, o software de
manipulação simbólica Maxima versus Maple, o software de manipulação numérica Octave
versus Matlab apresentaram desempenho muito próximos quanto ao tipo de problema analisado,
com pequenas vantagens para os proprietários .

A maioria dos softwares gratuitos possui “funções como cálculos matriciais, resolução de
integrais, derivadas, manipulação de vetores em geometria, análise numérica, além da construção
e visualização de gráficos de funções” (GREPINO & RODRIGUES, 2015). Dentre suas maiores
vantagens está o fato de permitir distribuição livre e acesso ao código fonte do programa

2
garantindo ao usuário informações de alta qualidade, além da linguagem e estrutura serem mais
interativas e de fácil utilização (GREPINO & RODRIGUES, 2015).

1.1 O Scilab e os métodos numéricos

Dentre os softwares livres mais utilizados está o Scilab, um software científico para
computação numérica bem próximo do Matlab, cuja distribuição é gratuita e por essa razão é
muito utilizado em diversos ambientes industriais e educacionais ao redor do mundo. Dentre suas
ferramentas mais utilizadas as que serão importantes no decorrer da disciplina são: construção de
gráficos em duas e três dimensões, álgebra linear e matrizes, polinômios e funções racionais,
interpolação, e a simulação que envolve um solver de sistemas de equações diferenciais.

Nas mais diversas áreas das ciências exatas ocorrem, frequentemente, situações que
envolvem a resolução de uma equação do tipo f(x)=0. Um número real ξ é um zero da função
f(x) ou uma raiz da equação f(x)=0 se f(ξ)=0. Para encontrar zeros da função em polinômios, por
exemplo, caso a equação seja do segundo grau, utilizamos a fórmula de Báskara, mas a solução
de polinômios de graus maiores envolvem cálculos com aproximações possíveis graças aos
métodos numéricos. A ideia central destes métodos numéricos é partir de uma aproximação
inicial para a raiz (um intervalo onde imaginamos a raiz estar contida) e em seguida refinar essa
aproximação através de um processo iterativo.

A primeira fase para resolução desses problemas consiste em identificar um intervalo que
contém a raiz. No caso do problema apresentado nesse relatório, o intervalo já foi dado. A
segunda fase consiste em escolher aproximações iniciais que estão dentro do intervalo e
melhorá-las sucessivamente até obter uma aproximação para a raiz dentro de uma margem de
erro fixada. Para isso três métodos numéricos serão testados a fim de identificar qual apresenta
melhor precisão e qual método é o mais rápido, ou seja, qual exige menos iterações.

1.2 Método da Substituição Sucessiva

3
Tomando-se a função f(x) tal que se deseja procurar a sua raiz. Para isso tem-se uma
função f(x)=0, colocando esta função na forma de g(x)=x, o x é isolado, e o mesmo nada mais é
que a raiz que será o ponto fixo da função g(x) e é o que deve ser procurada, contudo é gerada
uma nova função, que por sinal é função do x que é a raiz. Dessa forma, para encontrar uma raiz
de f(x), pode-se encontrar um valor numérico que substituindo em g(x) retorna o próprio valor
de x. A ideia nada mais é que estabelecer uma interpretação interativa para esta forma
alternativa, para isso é necessária uma aproximação inicial, tal que não seja muito distante da
raiz pretendida.
Para encontrar o valor de x, deve-se utilizar um processo interativo (como já citado
acima), portanto para começar a calcular o valor de g(x), é necessário estimar um valor inicial
para x (𝑥0), onde será recalculado repetidas vezes o valor de g(x), sempre usando o resultado de
uma dada interação com a nova estimativa de x (daí a denominação Substituição Sucessiva), ou
seja, é expresso da seguinte forma:
𝑥𝑘+1=g(𝑥𝑘)
onde, k é a ordem da interação (0, 1, 2, ..., n). E a função g(x) é denominada como função de
interação. Contudo para uma função 𝑓(𝑥), existe diversas funções interativas que podem ser
usadas no processo em busca do x que é a raiz. Vale ressaltar que o método só para quando os
dois últimos valores possuem casas decimais que atendam a tolerância exigida. O método de
convergência é:

Graficamente, o método procura o ponto no qual a curva de interação f(x)=g(x), na qual coincide
na reta tal que f(x)=x. Pode ser observado na figura 1 .

4
Figura 1: Interpretação gráfica do Método da Substituição sucessiva na qual a função converge. Fonte: (PINTO,
1997).

1.3 Método de Newton-Raphson

O que o Método de Newton-Raphson faz para acelerar a convergência é escolher para função
de iteração a função (x) tal que ’(ξ)=0. Dessa forma, é dada a equação f(x)=0 e partindo da
forma geral para (x), queremos obter a função A(x) tal que ’(ξ)=0. A forma geral para a
função de iteração:

(x)  x  A(x). f (x)

Calcula-se a derivada primeira e a derivada no ponto ξ e iguala a segunda derivada a zero, de


−1
onde obtêm-se A(x) = 𝑓′(𝑥) .

𝑓(𝑥)
Então, dada f(x), a função de iteração (x) 𝑥 − 𝑓′(𝑥) será tal que ’(ξ) 0, pois como pode-se

verificar:

𝑓(𝑥)𝑓′′(𝑥)
’(x) = [𝑓′(𝑥)]2

E, como f(ξ) 0, ’(ξ) 0 (desde que f’(ξ) ≠0)

5
𝑓(𝑥𝑘)
Assim, escolhido xo, a sequência {xk} será determinada por xk+1 = xk - 𝑓′(𝑥𝑘), k = 0, 1, 2…

Este método apresenta algumas condições de convergências, tais são apresentadas por
possuir:

a) 𝑥0 ∈[𝑎,𝑏], ou seja, as estimativas iniciais estejam suficientemente próximas de uma raiz da


equação;

b) f’(x) seja contínua no intervalo, e que não seja próxima de zero;

c) f’’(x) não toma valores excessivamente grandes.

O método de Newton é obtido geometricamente da seguinte forma:

dado o ponto (xk, f(xk)) traçamos a reta Lk(x) tangente à curva neste ponto: Lk(x) = f(xk)+
f’(xk)(x-xk) . Lk(x) é um modelo linear que aproxima a função f(x) numa vizinhança de xk.
Encontrando o zero deste modelo, obtemos:

𝑓(𝑥𝑘)
Lk(x)=0 ↔ x= xk - 𝑓′(𝑥𝑘).

Fazemos então xk+1 = x.

Figura 2. Representação gráfica do Método de Newton-Raphson. Fonte: (RUGGIERO & LOPES, 1996).

6
1.4 Método da Bissecção

Seja y = f(x) uma função contínua em um intervalo [a,b] que contém uma, e só uma, raiz,
ξ, da equação f(x) = 0. Este método consiste em dividir o intervalo [a, b], de forma iterativa, ao
meio. Para verificar se a raiz está contida na primeira ou na segunda metade do intervalo inicial,
é utilizado o teorema de Bolzano. Em seguida, o processo é repetido para aquela metade que
contém a raiz de f(x) = 0, ou seja, aquela em que a função, y = f(x), tem valores numéricos com
sinais opostos nos seus extremos.

Considerando que em cada iteração é atualizado o ponto “a” ou “b”, tem-se que a função
𝑎+𝑏
de iteração desse método é dada por: xk = , onde k=1, 2, 3...
2

Dada uma precisão ξ, o processo iterativo é finalizado quando se obtém um intervalo cujo
tamanho é menor ou igual a ξ, então qualquer ponto nele contido pode ser tomado como uma
estimativa para a raiz; ou quando for atingido um número máximo de iterações.

Se y = f(x) for contínua em [a, b] e f(a).f(b) < 0, então o método da Bisseção gera uma
sequência que converge para uma raiz de f(x) = 0.

É possível também prever o número mínimo de iterações para calcular uma raiz ξ com
uma precisão ξ a partir de um intervalo [a, b], mas não será abordado nesse relatório.

2.0 METODOLOGIA

Para a resolução do problema, foram utilizados três métodos:

 Método de Newton-Raphson;
 Métodos da Bissecção
 Método da Substituição Sucessiva (utilizando a forma recursiva);

7
A equação utilizada para a construção dos algoritmos para o cálculo de c, variando os
valores de φ2, e comparando a relação de não linearidade da função f(c), para os três métodos, é
dada abaixo:

𝑑𝑐
= 15𝑐 − 15𝑐2 + 𝜑 2 𝑓(𝑐)
𝑑𝑡
𝑐2 = 1,0

O mesmo foi aplicado para os seguintes casos abaixo:

A) 𝜑 2 = 1, 𝑓(𝑐) = 𝑐
B) 𝜑 2 = 40, 𝑓 (𝑐) = 𝑐
C) 𝜑 2 = 1, 𝑓 (𝑐) = 𝑐 2
D) 𝜑 2 = 1000, 𝑓 (𝑐) = 𝑐⁄(1 + 𝛼𝑐)2 , 𝛼 = 20

2.1 Método da Substituição Sucessiva

Para o método da substituição Sucessiva, foi utilizada a seguinte equação:

(15𝑐2 − 𝜑 2 𝑓(𝑐𝑘 ))
𝑐𝑘+1 =
15

2.2 Método de Newton- Raphson

No método de Newton – Raphson utilizou a derivada da função para cada hipótese:

15𝑐 − 15𝑐2 + 𝜑 2 𝑓(𝑐) = 0 = 𝑦

𝑑𝑦
A) , para 𝜑 2 = 1; 𝑐2 = 1,0, f(c) = c
𝑑𝑐
𝑑𝑦
= 15 + 𝜑 2
𝑑𝑐

8
𝑑𝑦
B) , para 𝜑 2 = 40; 𝑐2 = 1,0, f(c) = c
𝑑𝑐
𝑑𝑦
= 15 + 𝜑 2
𝑑𝑐

𝑑𝑦
C) , para 𝜑 2 = 1; 𝑐2 = 1,0, f(c) = c2
𝑑𝑐
𝑑𝑦
= 15 + 2𝑐𝜑 2
𝑑𝑐

𝑑𝑦
D) , para 𝜑 2 = 1; 𝑐2 = 1,0, 𝑓(𝑐) = 𝑐⁄(1 + 𝛼𝑐)2 , 𝛼 = 20
𝑑𝑐
𝑑𝑦 (1 − 𝛼𝑐)
= 15 + 𝜑 2 (
𝑑𝑐 (1 + 𝛼𝑐)3

2.3 Método da Bissecção

Para realizar o método da bissecção, foi definido o valor de ‘a’ e ‘b’ de acordo
com o intervalo estabelecido pelo problema [0,5;1], onde determinou f(a) e f(b),
posteriormente calculou a raiz (c) contida naquele intervalo utilizando o ponto médio do
intervalo dado pela seguinte equação ((a+b)/2), calculou-se f(c). Caso o valor de f(c)
tenha o mesmo sinal de f(a) o novo intervalo de busca deve ser [b,c], e quando f(c) possui
o mesmo sinal de f(b), o novo intervalo será [a,c]. O procedimento é repetido até o
intervalo e/ ou f(a) e f(b) sejam menores que a tolerância especificada.

3.0 RESULTADOS

Os resultados obtidos a partir de algoritmos que estabeleciam os métodos de Newton-


Raphson, Substituição Sucessiva e Bissecção, para a função:

15𝑐 − 15𝑐2 + 𝜑 2 𝑓(𝑐)


𝑐2 = 1,0,
9
seguem abaixo.

3.1 Método da Substituição Sucessiva

3.1.1 Alternativa A

𝜑 2 = 1; 𝑐2 = 1,0, 𝑓(𝑐) = 𝑐

Tabela 1. Resultado para a alternativa A do Método da Substituição Sucessiva


Método Substituição Sucessiva
Raiz encontrada 0.9375000
Tolerância 1,00x10-6
Número de iterações 5
Chute inicial 1

3.1.2 Alternativa B

𝜑 2 = 40; 𝑐2 = 1,0, 𝑓(𝑐) = 𝑐

Tabela 2. Resultado para a alternativa B do Método da Substituição Sucessiva


Método Substituição Sucessiva
Raiz encontrada Não Convergiu
Tolerância 1,00x10-6
Número de iterações Não Convergiu
Chute inicial 1

3.1.3 Alternativa C

𝜑 2 = 1; 𝑐2 = 1,0, 𝑓(𝑐) = 𝑐 2

10
Tabela 3. Resultado para a alternativa C do Método da Substituição Sucessiva
Método Substituição Sucessiva
Raiz encontrada 0.9409715
Tolerância 1,00x10-6
Número de iterações 6
Chute inicial 1

3.1.4 Alternativa D

𝜑 2 = 1000; 𝑐2 = 1,0, 𝑓(𝑐) = 𝑐⁄(1 + 𝛼𝑐)2 , 𝛼 = 20

Tabela 4. Resultado para a alternativa D do Método da Substituição Sucessiva

Método Substituição Sucessiva


Raiz encontrada 0.8193031
Tolerância 1,00x10-6
Número de iterações 8
Chute inicial 1

3.2 Método de Newton-Raphson

3.2.1 Alternativa A

𝜑 2 = 1; 𝑐2 = 1,0, 𝑓(𝑐) = 𝑐

Tabela 5. Resultado para a alternativa A do Método de Newton-Raphson

Método Newton-Raphson
Raiz encontrada 0.9375
Tolerância 1,00x10-6
Número de iterações 1
Chute inicial 1

11
3.2.2 Alternativa B

𝜑 2 = 40; 𝑐2 = 1,0, 𝑓(𝑐) = 𝑐

Tabela 6. Resultado para a alternativa B do Método de Newton-Raphson

Método Newton-Raphson
Raiz encontrada 0.2727273
Tolerância 1,00x10-6
Número de iterações 1
Chute inicial 1

3.2.3 Alternativa C

𝜑 2 = 1; 𝑐2 = 1,0, 𝑓(𝑐) = 𝑐 2

Tabela 7. Resultado para a alternativa C do Método de Newton-Raphson

Método Newton-Raphson
Raiz encontrada 0.9409715
Tolerância 1,00x10-6
Número de iterações 2
Chute inicial 1

3.2.4 Alternativa D

𝜑 2 = 1000; 𝑐2 = 1,0, 𝑓(𝑐) = 𝑐⁄(1 + 𝛼𝑐)2 , 𝛼 = 20

Tabela 8. Resultado para a alternativa D do Método de Newton-Raphson

Método Newton-Raphson
Raiz encontrada 0.819303
Tolerância 1,00x10-6

12
Número de iterações 3
Chute inicial 1

3.3 Método da Bissecção

3.3.1 Alternativa A

𝜑 2 = 1; 𝑐2 = 1,0, 𝑓(𝑐) = 𝑐

Tabela 9. Resultado para a alternativa A do Método da Bissecção

Método Bissecção
Raiz encontrada 0.937500
Tolerância 1,00x10-6
Número de iterações 2
Chute inicial 1

3.3.2 Alternativa B

𝜑 2 = 40; 𝑐2 = 1,0, 𝑓(𝑐) = 𝑐

Tabela 10. Resultado para a alternativa B do Método da Bissecção

Método Bissecção
Raiz encontrada 1.000000
Tolerância 1,00x10-6
Número de iterações 19
Chute inicial 1

3.3.3 Alternativa C

𝜑 2 = 1; 𝑐2 = 1,0, 𝑓(𝑐) = 𝑐 2

13
Tabela 11. Resultado para a alternativa C do Método da Bissecção

Método Bissecção
Raiz encontrada 0.940972
Tolerância 1,00x10-6
Número de iterações 19
Chute inicial 1

3.3.4 Alternativa D

𝜑 2 = 1000; 𝑐2 = 1,0, 𝑓(𝑐) = 𝑐⁄(1 + 𝛼𝑐)2 , 𝛼 = 20

Tabela 12. Resultado para a alternativa D do Método da Bissecção

Método Bissecção
Raiz encontrada 0.819303
Tolerância 1,00x10-6
Número de iterações 19
Chute inicial 1

4.0 CONCLUSÃO

A partir dos resultados apresentados, pode-se observar que o método de Newton-Raphson


se destacou devido apresentar um resultado mais rápido comparado com o Método da Bissecção
e o Método da Substituição, pois seu número de iterações foi menor para chegar ao resultado da
raiz. Isto pode ser explicado pelo fato do Método de Newton-Raphson utilizar a derivada, o que
acarretara numa convergência de forma mais rápida.

No método da Substituição Sucessiva em um ponto onde o 𝜑2 foi aumentado de forma


significativa, observou-se que o método não atingiu a convergência tornando-se invalido. Para o
número máximo de iterações igual a 150 o valor máximo do 𝜑2 seria de 13.68016, para que
fosse possível a conversão nesse método. E no mesmo caso, houve uma diferença significativa

14
entre as raízes entre o Método de Newton-Raphson e do Método da Bissecção, que pode ser
explicado pelo fato do valor encontrado no Método da Bissecção possa ser igual 1, isso não
corresponder a uma raiz, uma vez que a raiz tem que estar dentro do intervalo.

Avaliando a linearidade da função, mantendo o valor de fi^2 e alterando a função


iterativa, para o Método de Newton-Raphson o número de iterações aumentou, devido a menor
linearidade, o que influencia no cálculo da derivada. Já para os métodos da Bissecção, para uma
maior linearidade o número de iterações permaneceu o mesmo, pois o mesmo não depende da
linearidade da função, e o Método da Substituição Sucessiva diminuiu o número de iterações a
medida que a função se tornava menos linear.

Conclui-se que podemos obter as soluções de problemas de sistemas de equações lineares


utilizando os métodos propostos, onde todos apresentam precisão e eficiência nos resultados
apresentados.

5.0 BIBLIOGRAFIA

BURDEN, R. L., FAIRES, D., LIVRO ANÁLISE NUMÉRICA (8ª Edição), 2008.

GREPINO, P.H.F; RODRIGUES, F.A. UTILIZAÇÃO DE SOFTWARES LIVRES NO


ENSINO DA ENGENHARIA QUÍMICA Revista de Engenharia Química e Química -
REQ2. Vol. 01 N. 01 p.016-029, 2015.

PILLING, S. Métodos numéricos para encontrar raízes (zeros) de funções reais – UNIVAP.
Disponível em: http://www1.univap.br/spilling/CN/CN_Capt2.pdf. Acessado em 27/11/2015.

PINTO, J. C.; LAGE, P. L. MÉTODOS NUMÉRICOS EM PROBLEMAS DE


ENGENHARIA QUÍMICA. UFRJ, 1997.

POLON, P. E. et al. SOFTWARES CIENTÍFICOS E DE ENGENHARIA: LIVRES versus


PROPRIETÁRIOS. In: COBENGE, 34., 2006, Passo Fundo. Anais...Passo Fundo:
Universidade de Passo Fundo, 2006.

RUGGIERO, M. A. G.; LOPES, V. L. R., LIVRO CÁLUCLO NUMÉRICO – ASPECTOS


TEÓRICOS E COMPUTACIONAIS (2ª Edição), 1998.

15
UNESP, Método das Aproximações Sucessivas ou Método de Integração Linear (MIL),
disponível em: <http://www2.sorocaba.unesp.br/professor/amartins/aulas/numerico/mil.pdf>.
Acessado em 27/11/2015.

UNESP, Método de Newton-Raphson. Disponível em: <


http://www2.sorocaba.unesp.br/professor/amartins/aulas/numerico/nr.pdf>. Acessado em
27/11/2015.

ANEXOS:

Método Bissecção:
//BISSECÇÃO - ALTERNATIVA A

clc;
clear;
mode(0);
lines(0);
disp(" MÉTODO DA BISSEÇÃO");

function funcao=f(c, c2, fi2)


funcao=(15*c)-(15*c2)+(fi2*c)

endfunction

function [c, num_iter]=bissec(intervalo_inferior, intervalo_superior, tolerancia, num_max_it)


c0=intervalo_inferior;
c1=intervalo_superior;
cm=(c0+c1)/2;
it=0;

if f(c0)*f(c1)>0 then

printf('O intervalo inicial pode não conter solução.');


end;

while min((c1-c0),abs(f(cm)))>tolerancia & f(cm)<>0 & it<=num_max_it do


if f(c0)*f(cm) > 0 then
c0=cm;
else
c1=cm;
end;
cm=(c0+c1)/2;
it=it+1;
end;
c=cm;
num_iter=it;
endfunction;

16
c2=1;
fi2=1;
intervalo_superior=1;
intervalo_inferior=0.5;

num_max_it=150;
tolerancia=10^(-6);
[c,num_iter]=bissec(intervalo_inferior,intervalo_superior,tolerancia,num_max_it);

printf("\nA raiz aproximada da função é: %f\n",c ) ;

printf("\nO número de iterações é: %i\n",num_iter);

//BISSECÇÃO - ALTERNATIVA B

clc;
clear;
mode(0);
lines(0);
disp(" MÉTODO DA BISSEÇÃO");

function funcao=f(c, c2, fi2)


funcao=(15*c)-(15*c2)+(fi2*c)

endfunction

function [c, num_iter]=bissec(intervalo_inferior, intervalo_superior, tolerancia, num_max_it)


c0=intervalo_inferior;
c1=intervalo_superior;
cm=(c0+c1)/2;
it=0;

if f(c0)*f(c1)>0 then

printf('O intervalo inicial pode não conter solução.');


end;

while min((c1-c0),abs(f(cm)))>tolerancia & f(cm)<>0 & it<=num_max_it do


if f(c0)*f(cm) > 0 then
c0=cm;
else
c1=cm;
end;
cm=(c0+c1)/2;
it=it+1;
end;
c=cm;
num_iter=it;
endfunction;

c2=1;
fi2=40;
intervalo_superior=1;
intervalo_inferior=0.5;

num_max_it=150;

17
tolerancia=10^(-6);
[c,num_iter]=bissec(intervalo_inferior,intervalo_superior,tolerancia,num_max_it);

printf("\nA raiz aproximada da função é: %f\n",c ) ;

printf("\nO número de iterações é: %i\n",num_iter);

//BISSECÇÃO - ALTERNATIVA C

clc;
clear;
mode(0);
lines(0);
disp(" MÉTODO DA BISSEÇÃO");

function funcao=f(c, c2, fi2)


funcao=15*c-15*c2+fi2*(c^2)

endfunction

function [c, num_iter]=bissec(intervalo_inferior, intervalo_superior, tolerancia, num_max_it)


c0=intervalo_inferior;
c1=intervalo_superior;
cm=(c0+c1)/2;
it=0;

if f(c0)*f(c1)>0 then

printf('O intervalo inicial pode não conter solução.');


end;

while min((c1-c0),abs(f(cm)))>tolerancia & f(cm)<>0 & it<=num_max_it do


if f(c0)*f(cm) > 0 then
c0=cm;
else
c1=cm;
end;
cm=(c0+c1)/2;
it=it+1;
end;
c=cm;
num_iter=it;
endfunction;

c2=1;
fi2=1;
intervalo_superior=1;
intervalo_inferior=0.5;

num_max_it=150;
tolerancia=10^(-6);
[c,num_iter]=bissec(intervalo_inferior,intervalo_superior,tolerancia,num_max_it);

printf("\nA raiz aproximada da função é: %f\n",c ) ;

printf("\nO número de iterações é: %i\n",num_iter);

18
//BISSECÇÃO - ALTERNATIVA D

clc;
clear;
mode(0);
lines(0);
disp(" MÉTODO DA BISSEÇÃO");

function funcao=f(c, c2, fi2)


funcao=(15*c)-(15*c2)+fi2*(c/((1+alfa*c)^2))

endfunction

function [c, num_iter]=bissec(intervalo_inferior, intervalo_superior, tolerancia, num_max_it)


c0=intervalo_inferior;
c1=intervalo_superior;
cm=(c0+c1)/2;
it=0;

if f(c0)*f(c1)>0 then

printf('O intervalo inicial pode não conter solução.');


end;

while min((c1-c0),abs(f(cm)))>tolerancia & f(cm)<>0 & it<=num_max_it do


if f(c0)*f(cm) > 0 then
c0=cm;
else
c1=cm;
end;
cm=(c0+c1)/2;
it=it+1;
end;
c=cm;
num_iter=it;
endfunction;

c2=1;
fi2=1000;
intervalo_superior=1;
intervalo_inferior=0.5;
alfa=20;

num_max_it=150;
tolerancia=10^(-6);
[c,num_iter]=bissec(intervalo_inferior,intervalo_superior,tolerancia,num_max_it);

printf("\nA raiz aproximada da função é: %f\n",c ) ;

printf("\nO número de iterações é: %i\n",num_iter);

19
Método de Newton Rapson:

// NEWTON-RAPHSON - ALTERNATIVA A

clc;
clear;
mode(0);
lines(0);
disp(" MÉTODO DE NEWTON-RAPHSON");
disp('-------------------------------');

function func=f(c)
c2=1;
fi2=1;
func=15*c-15*c2+fi2*c;
endfunction
function func=derivada(c)
c2=1;
fi2=1;
func=15+fi2;
endfunction

function [c, erro]=newton(c0, tolerancia, nmac, erro)


N=nmac;
cc=c0;
while N>0
cn=cc-f(cc)/derivada(cc);
disp('-----------------');
disp(f(cc));
disp(derivada(cc));
disp(cn);
disp('----------------');
if abs(cc-cn)<tolerancia then
c=cn;
printf("O número de interações é %d:\n\n",(nmac-N))

return(c);
erro=0;
end
N=N-1;
cc=cn;
end
erro=1
c=cn;
return(c);
abort
endfunction

nmac=5000;
c2=1;
fi2=1;
tolerancia=10^(-6);
c0=1;
c0=1;
erro=0;
[c]=newton(c0,tolerancia,nmac,erro)
if erro==1 then

20
disp (" O ALGORITMO NÃO CONVERGIU!");
disp('-------------------------------');
else
disp('A solução é:');
disp(c);
disp('-------------------------------');
end

// NEWTON-RAPHSON - ALTERNATIVA B

clc;
clear;
mode(0);
lines(0);
disp(" MÉTODO DE NEWTON-RAPHSON");
disp('-------------------------------');

function func=f(c)
c2=1;
fi2=40;
func=15*c-15*c2+fi2*c;
endfunction
function func=derivada(c)
c2=1;
fi2=40;
func=15+fi2;
endfunction

function [c, erro]=newton(c0, tolerancia, nmac, erro)


N=nmac;
cc=c0;
while N>0
cn=cc-f(cc)/derivada(cc);
disp('-----------------');
disp(f(cc));
disp(derivada(cc));
disp(cn);
disp('----------------');
if abs(cc-cn)<tolerancia then
c=cn;
printf("O número de interações é %d:\n\n",(nmac-N))

return(c);
erro=0;
end
N=N-1;
cc=cn;
end
erro=1
c=cn;
return(c);
abort
endfunction

21
nmac=5000;
c2=1;
fi2=40;
tolerancia=10^(-6);

c0=1;
erro=0;
[c]=newton(c0,tolerancia,nmac,erro)
if erro==1 then
disp (" O ALGORITMO NÃO CONVERGIU!");
disp('-------------------------------');
else
disp('A solução é:');
disp(c);
disp('-------------------------------');
end

// NEWTON-RAPHSON - ALTERNATIVA D

clc;
clear;
mode(0);
lines(0);
disp(" MÉTODO DE NEWTON-RAPHSON");
disp('_________________________');

function func=f(c)
c2=1;
fi2=1000;
func=(15*c)-(15*c2)+fi2*(c/((1+alfa*c)^2));
endfunction
function func=derivada(c)
c2=1;
fi2=1000;
func=15+fi2*((1-20*c)/((1+20*c)^3));
endfunction

function [c, erro]=newton(c0, tolerancia, nmac, erro)


N=nmac;
cc=c0;
while N>0
cn=cc-f(cc)/derivada(cc);
disp('________________');
disp(f(cc));
disp(derivada(cc));
disp(cn);
disp('________________');
if abs(cc-cn)<tolerancia then
c=cn;
printf("O número de interações é %d:\n\n",(nmac-N))

return(c);

22
erro=0;
end
N=N-1;
cc=cn;
end
erro=1
c=cn;
return(c);
abort
endfunction
alfa=20;
nmac=5000;
c2=1;
fi2=1;
tolerancia=10^(-6);

c0=1;
erro=0;
[c]=newton(c0,tolerancia,nmac,erro)
if erro==1 then
disp (" O ALGORITMO NÃO CONVERGIU!");
disp('____________________________');
else
disp('A solução é:');
disp(c);
disp('_________________________________');
end

// NEWTON-RAPHSON - ALTERNATIVA C

clc;
clear;
mode(0);
lines(0);
disp(" MÉTODO DE NEWTON-RAPHSON");
disp('-------------------------------');

function func=f(c)
c2=1;
fi2=1;
func=15*c-(15*c2)+fi2*(c^2);
endfunction
function func=derivada(c)
c2=1;
fi2=1;
func=15+2*fi2*c;
endfunction

function [c, erro]=newton(c0, tolerancia, nmac, erro)


N=nmac;
cc=c0;
while N>0
cn=cc-f(cc)/derivada(cc);
disp('-----------------');

23
disp(f(cc));
disp(derivada(cc));
disp(cn);
disp('----------------');
if abs(cc-cn)<tolerancia then
c=cn;
printf("O número de interações é %d:\n\n",(nmac-N))

return(c);
erro=0;
end
N=N-1;
cc=cn;
end
erro=1
c=cn;
return(c);
abort
endfunction

nmac=5000;
c2=1;
fi2=1;
tolerancia=10^(-6);
c0=1;
erro=0;
[c]=newton(c0,tolerancia,nmac,erro)
if erro==1 then
disp (" O ALGORITMO NÃO CONVERGIU!");
disp('-------------------------------');
else
disp('A solução é:');
disp(c);
disp('-------------------------------');
end

Substituição Sucessiva:

//MÉTODO DA SUBSTITUIÇÃO SUCESSIVA - ALTERNATIVA A

clc;
clear;
mode(0);
lines(0);
disp(" MÉTODO DA SUBSTITUIÇÃO SUCESSIVA");
disp('_________________________________');

function func=f(c)
c2=1
fi2=1
func=(15*c2-(fi2*c))/15
endfunction

24
function c=substituicaosucessiva(c0, num_max_int, tolerancia)
N=num_max_int;
cc=c0;
while N>0
cn=f(cc);
if abs(cc-cn)<tolerancia then
c=cn;
disp ("O número de interações é:")
disp (num_max_int-N);
return(c);
end
N=N-1;
cc=cn;
end;
error ("Algoritmo não convergiu.")

abort
endfunction

c2=1;
fi2=1;

//ITERAÇÕES Usadas
num_max_int=150;
f0=1;
tolerancia=10^-6;
c0=f0;
c=substituicaosucessiva(c0,num_max_int,tolerancia)
disp("A solução do problema é:")
disp(c);

//MÉTODO DA SUBSTITUIÇÃO SUCESSIVA - ALTERNATIVA A

clc;
clear;
mode(0);
lines(0);
disp(" MÉTODO DA SUBSTITUIÇÃO SUCESSIVA");
disp('_________________________________');

function func=f(c)
c2=1
fi2=40
func=(15*c2-(fi2*c))/15
endfunction

function c=substituicaosucessiva(c0, num_max_int, tolerancia)


N=num_max_int;
cc=c0;
while N>0
cn=f(cc);
if abs(cc-cn)<tolerancia then
c=cn;

25
disp ("O número de interações é:")
disp (num_max_int-N);
return(c);
end
N=N-1;
cc=cn;
end;
error ("Algoritmo não convergiu.")

abort
endfunction

c2=1;
fi2=40;

//ITERAÇÕES Usadas
num_max_int=150;
f0=1;
tolerancia=10^-6;
c0=f0;
c=substituicaosucessiva(c0,num_max_int,tolerancia)
disp("A solução do problema é:")
disp(c);

//MÉTODO DA SUBSTITUIÇÃO SUCESSIVA - ALTERNATIVA C

clc;
clear;
mode(0);
lines(0);
disp(" MÉTODO DA SUBSTITUIÇÃO SUCESSIVA");
disp('__________________________________');

function func=f(c)
c2=1
fi2=1
func=(15*c2-(fi2*(c^2)))/15
endfunction

function c=substituicaosucessiva(c0, nmax, tolerancia)


N=nmax;
cc=c0;
while N>0
cn=f(cc);
if abs(cc-cn)<tolerancia then
c=cn;
disp ("O número de interações é:")
disp (nmax-N);
return(c);
end
N=N-1;
cc=cn;
end;

error ("Algoritmo não convergiu.")


abort
endfunction

26
//c2=1;
//fi2=1;

//Iterações Usadas//
nmax=15000;
f0=1;
tolerancia=10^-6;
c0=f0;
c=substituicaosucessiva(c0,nmax,tolerancia)
disp("A solução é:")
disp(c);

//MÉTODO DA SUBSTITUIÇÃO SUCESSIVA - ALTERNATIVA C

clc;
clear;
mode(0);
lines(0);
disp(" MÉTODO DA SUBSTITUIÇÃO SUCESSIVA");
disp('__________________________________');

function func=f(c)
c2=1
fi2=1000

func=(15*c2-(fi2*(c/(1+alfa*c)^2)))/15
endfunction

function c=substituicaosucessiva(c0, nmax, tolerancia)


N=nmax;
cc=c0;
while N>0
cn=f(cc);
if abs(cc-cn)<tolerancia then
c=cn;
disp ("O número de interações é:")
disp (nmax-N);
return(c);
end
N=N-1;
cc=cn;
end;

error ("Algoritmo não convergiu.")


abort
endfunction
//Valores das variáveis
c2=1;
fi2=1000;

alfa=20;
nmax=150;
f0=1;

27
tolerancia=10^-6;
c0=f0;
c=substituicaosucessiva(c0,nmax,tolerancia)
disp("A solução é:")
disp(c);

28

Você também pode gostar