INTRODUÇÃO AO CÁLCULO NUMÉRICO

LABORATÓRIO – AULA 02

EQUAÇÕES NÃO LINEARES

1. INTRODUÇÃO
Nesta aula prática estudaremos alguns problemas que são expressos, matematicamente, como
equações não lineares, ou seja, iremos determinar a raiz dessas equações, em computador. A
ferramenta computacional que empregaremos é o Scilab, com o qual nos familiarizamos na
Aula 01 de Laboratório.

Na resolução das equações não lineares, empregaremos os métodos que aprendemos nas
aulas teórica: bissecção, falsa posição, ponto fixo, newton-raphson e secante. Cada um desses
métodos foi implementado como uma função do Scilab, armazenada em arquivos de extensão
.sci. A esta altura, você já deve ter copiado os arquivos ‘bisecção.sci’, ‘falsaposicao.sci’,
‘pontofixo.sci’, ‘newtonraphson.sci’ e ‘secante.sci’ para alguma pasta em seu computador.
Essa pasta será o diretório de trabalho para tudo o que for realizado nesta aula.

Antes de começarmos a explorar os métodos numéricos propriamente ditos, vamos conhecer

dois recursos do ambiente Scilab, funções e scritps. Ambos podem ser encarados como formas
de programação do ambiente permitindo organizar nossas atividades e alcançar um
desempenho significativamente melhor.
2. FUNÇÕES E SCRIPTS NO SCILAB

2.1. FUNÇÕES

O conceito de função do Scilab é similar ao de outras linguagens de programação

como, por exemplo, a linguagem C.

Considere o método da bissecção; na aula teórica o algoritmo foi apresentado e

discutido através do pseudocódigo correspondente e vamos supor que sabemos
traduzir esse algoritmo para a linguagem do Scilab. Então, numa situação prática,
executaríamos o Scilab e, na janela Console, definiríamos a função matemática
cuja raiz queremos determinar , digitaríamos todos os comandos correspondentes
ao método da bissecção e teríamos a solução.

Mas e se quiséssemos resolver novamente o mesmo problema com diferentes

estimativas iniciais ou, ainda, resolver uma equação não linear diferente? Teríamos
que digitar de novo todos os comandos correspondentes ao algoritmo da
bissecção mas, sem dúvida, isso é um enorme desperdício de tempo.

É aqui que entra o conceito de função; todas as instruções (ou comandos)

relacionados entre si e utilizados para executar uma tarefa bem definida são
agrupados em um único conjunto que pode ser utilizado sempre que necessário,
sem que precisemos digitar novamente todas as instruções.

Como dissemos, o conceito de função do Scilab é similar ao de outras linguagens,

porém, sua implementação tem características específicas que veremos a seguir.

As funções podem ter um número qualquer de argumentos de entrada e

argumentos de saída. Os argumentos de entrada da função não são por ela
modificados mas os argumentos de saída, sim. A sintaxe completa para a definição
de uma função é:

[o1, ... , on] = nome_da_funcao (i1, ... , in)

Os argumentos de entrada e de saída são separados por vírgulas mas os de

entrada são delimitados por parênteses enquanto que os de saída são delimitados
por colchetes.

As funções podem ser definidas de três modos distintos.

O primeiro deles corresponde a definir a função na própria Console e em seguida

utilizá-la através de chamadas a ela. Esse modo é útil quando a função é
relativamente simples (número não muito grande de instruções). Por outro lado, a
função só existe em quanto durar a sessão de trabalho. Se você fechar o Scilab, a
função se perde. Se você executar o comando clear a função também se perde,
pois esse comando limpa todo o espaço de trabalho do Scilab. Vejamos, na prática,
como funciona esse modo de definição de funções.

ATIVIDADE PRÁTICA

Na console, digite as seguintes linhas:

-->function [x2, x3] = potencias(x)

-->x2=x^2;
-->x3=x^3;
-->endfunction

Comentários
Toda definição de função começa com a palavra function e termina com
endfunction. Entre elas fica o corpo da função. A linha que começa com function é
chamada cabeçalho.

Agora a função está pronta para ser usada, isto é, podemos executar uma
chamada de função. Execute o comando:

-->[quadrado, cubo] = potencias(3)

cubo =

27.
quadrado =

9.

O segundo modo é chamado de funções “inline” e também é feito na Janela de

Console, valendo apenas na sessão de trabalho atual. Também é bastante útil
quando a função é dada por uma ou mais expressões simples.

ATIVIDADE PRÁTICA

Na console, digite os seguintes comandos. Examine a sintaxe do comando deff e

observe os resultados.

-->deff('[x2, x3]=potencias(x)',['x2=x^2';'x3=x^3;'])

-->[x2, x3]=potencias(3)
x3 =

27.
x2 =

9.
O terceiro modo de definir uma função é armazenar o código da função em um
arquivo. Desta maneira, o código não se perde quando a sessão de trabalho é
encerrada.

As funções escritas pelo usuário, por uma convenção da comunidade Scilab, ficam
armazenadas em arquivos de extensão .sci. Como são arquivos de texto, qualquer
editor de texto pode ser utilizado para escrever uma função e gravar o arquivo .sci
correspondente. No entanto, o Scilab oferece um editor de texto próprio chamado
SciNotes que pode ser acessado através do menu da Janela Principal do Scilab pela
sequência Aplicativos -> SciNotes. É recomendável utilizar sempre o SciNotes,
porque esse editor apresenta uma série de realces que facilitam muito a escrita e a
leitura de um arquivo .sci (o mesmo vale para os arquivos de script que serão
vistos no próximo item).

Como esta segunda maneira de definir funções envolve arquivos precisamos

sempre saber qual é o diretório de trabalho atual; isso pode ser feito digitando, na
Console, o comando pwd. Para mudar o diretório atual, o mais simples é usar o
Menu Principal; selecione Arquivo -> Alterar o diretório atual...

A questão, agora, é: como uma função que está armazenada em um arquivo pode
ser chamada durante uma sessão de trabalho? O Scilab fornece um procedimento
em duas etapas. Na primeira etapa, a função passa a integrar o ambiente de
trabalho, ou seja, fica disponível para ser executada. Isto é feito através do
comando exec:

--> exec(“nome_da_funcao.sci”);

(supondo que o arquivo nome_da_funcao.sci esteja no diretório atual; se não

estiver, você pode fornecer o caminho completo até o local onde o arquivo está,
exemplo: exec(“C:\...\...\nome_da_funcao.sci”)

Observe que, com o comando exec a função não é executada, de fato; ela, apenas
fica disponível para uso. Vamos repetir a ATIVIDADE PRÁTICA anterior só que,
desta vez, utilizando arquivos.
ATIVIDADE PRÁTICA

No Menu Principal, selecione Aplicativos->SciNotes. A janela do editor de texto

será exibida.

No editor, entre com o código da função ‘potencias’ da atividade anterior.

Selecione Arquivo->Salvar. Para ser usado corretamente, o nome do arquivo
deve ser exatamente igual ao nome da função, mas observe que a caixa de
diálogo apresentada pelo SciNotes já sugere esse nome. Certifique-se sobre o
diretório e salve o arquivo.

Agora, retorne para a Console do Scilab e execute os comandos e observe o

resultado.

-->exec("potencias.sci");

-->[quadrado, cubo]=potencias(4)
cubo =

64.
quadrado =

16.
 Observe que, a partir do próprio SciNotes é possível carregar o arquivo .sci para
uso futuro. Para isso, no Menu Principal do SciNotes, selecione a opção Executar e,
a seguir, uma das opções exibidas. Experimente com elas e veja o resultado na
Console.

No Scilab, assim como em outras linguagens, é possível construir bibliotecas

inteiras de funções, mas não discutiremos esse assunto aqui.

2.2. SCRIPTS

De modo semelhante ao caso das Funções do item anterior, quando vários

comandos devem ser executados pode ser conveniente gravar a sequência de
comandos em um arquivo chamado script e invocar esse script toda vez que for
necessário.

Um script também pode ser criado com o editor SciNotes, mas uma diferença
entre funções e scripts é que, enquanto funções são armazenadas em arquivos
com extensão .sci, por convenção, scripts são armazenados em arquivos com
extensão .sce.

Tanto funções quanto scripts são “carregados” no ambiente de trabalho do Scilab

através do comando exec, mas uma diferença essencial é que as funções apenas
ficam disponíveis para uso enquanto que um script é executado imediatamente.

Assim, por exemplo, se você tem um arquivo chamado estudoconvergencia.sce

que contém a função cuja raiz você quer determinar e uma sequência de
chamadas a vários métodos numéricos com o objetivo de compará-los entre si, ao
executar

--> exec(“estudoconvergencia.sce”);

todos os comandos contidos no arquivo serão imediatamente executados.

Nos estudos de caso discutidos a seguir veremos alguns scripts em ação.

3. ESTUDO DE CASO: CONVERGÊNCIA DOS MÉTODOS NUMÉRICOS

Nossa primeira atividade prática envolvendo os métodos numéricos usados na

determinação de raízes de equações não lineares consiste em tomar uma equação não
linear, aplicar cada um dos métodos e compará-los através do número de iterações e
da evolução do erro relativo aproximado, por meio de gráficos. Utilizaremos a função
f(x)=e-x-x, empregada por Chapra e Canale no livro Numerical Methods for Engineers
para exemplificar o comportamento de cada método.

3.1. ANATOMIA DOS SOLVERS

Antes de iniciarmos a atividade prática propriamente dita, vamos analisar a

estrutura dos programas (solvers). Com o editor SciNotes, visualize o arquivo
newtonraphson.sci, por exemplo. Você verá o seguinte conteúdo.

function [raiz, x, iter, ea]=newtonraphson(x0, f, fp, tol, imax)

iter = 0;
xr = x0;
x(iter+1)=x0;
ea(iter+1)=100;
while (1)
xrold = xr;
xr = xrold - f(xrold)/fp(xrold);
iter = iter+1;
x(iter+1) = xr;
if(xr ~= 0) then
ea(iter+1)=abs((xr-xrold)/xr)*100;
end;
if(ea(iter+1) <= tol) then
raiz = xr;
return;
end;
if(iter >= imax) then
error('Número Máximo de Iterações Alcançado');
end;
end

Interessa-nos aqui examinar os parâmetros de entrada e saída da função

newtonraphson. Observe que os parâmetros de entrada incluem todas as
informações que o método numérico precisa para determinar a raiz; no caso do
Método de Newton-Raphson, como vimos na aula teórica, esses parâmetros são:

x0 Estimativa inicial
f Função cuja raiz será determinada
fp Derivada da função f
tol Tolerância pré-especificada
imax Número Máximo de Iterações
 Os parâmetros x0, tol e imax são números que podem ser fornecidos diretamente
na chamada da função newtonraphson. Os parâmetros f e fp são nomes de
funções que avaliam, respectivamente, o valor da função matemática, f, e da
derivada de f, fp, em um determinado ponto. Devem ser definidas separadamente,
de acordo com o que foi estudado no item 2.

Outros métodos numéricos precisam de parâmetros de entrada diferentes. Por

exemplo, Bissecção, Posição Falsa e Secante exigem duas estimativas iniciais e não
precisam da derivada da função. As respectivas definições são mostradas a seguir:

function [raiz, x, iter, ea]=biseccao(xl, xu, f, tol, imax)

function [raiz, x, iter, ea]=falsaposicao(xl, xu, f, tol, imax)
function [raiz, x, iter, ea]=pontofixo(x0, f, tol, imax)
function [raiz, x, iter, ea]=secante(xi, xf, f, tol, imax)

Os parâmetros de saída, por sua vez, são os mesmos para todos os métodos e é
importante que seja assim porque permite compará-los entre si.

raiz Valor encontrado para a raiz

x Vetor com a sequência de raízes
iter Número de Iterações Executadas
ea Vetor com a sequência de erros relativos

3.2. DETERMINAÇÃO DAS ESTIMATIVAS INICIAIS GRAFICAMENTE

Todos os métodos numéricos para determinação de raízes de equações não

lineares necessitam de uma estimativa inicial para a raiz, de modo a dar início ao
processo iterativo.

Como vimos nas aulas teóricas, uma maneira de determinar a estimativa inicial (ou
duas estimativas no caso de alguns dos métodos) é fazer o gráfico da função e
identificar, aproximadamente, em que ponto o gráfico cruza o eixo das abscissas.

Vamos fazer o gráfico da função y=e-x-x, no intervalo [0,5]; esse intervalo pode ser
ajustado se for necessário para identificar melhor onde o gráfico cruza o eixo x. No
nosso caso, será suficiente e escolhemos 51 pontos igualmente espaçados para
avaliar a função. Também exibimos uma grade porque isso facilita a identificação
da estimativa inicial.
ATIVIDADE PRÁTICA: GRÁFICO DA FUNÇÃO

-->// MÉTODO GRÁFICO PARA DETERMINAR A ESTIMATIVA INICIAL

-->x=linspace(0,5,51);

-->y=exp(-x)-x;

-->plot(x,y);

-->xgrid

O resultado final é:

Examinando o gráfico podemos ver claramente que a raiz está localizada no

intervalo [0.5,1] e, de fato, bem mais próxima de 0.5 do que de 1. Então, tomemos
como estimativa inicial x0=0.5 e, para os métodos que necessitam de duas
estimativas iniciais, consideremos xl=0.5 e xu=0.7
3.3. DETERMINAÇÃO DA RAIZ

Na próxima atividade prática, você terá que digitar, na Console do Scilab, uma
longa sequência de comandos cujo resultado final é a determinação da raiz da
função de teste, através de cada um dos métodos numéricos estudados do ponto
de vista teórico em sala de aula.

Os comentários descrevem brevemente as etapas do cálculo. Inicialmente, você irá

definir, na linguagem do Scilab, a função e sua derivada (requerida por Newton-
Raphson) e, mais adiante, a função modificada (problema de ponto fixo) como
exige o método do Ponto Fixo. Nesta etapa, também são informados os
parâmetros do cálculo: estimativas iniciais, tolerância, número máximo de
iterações. A seguir, cada método (codificado no respectivo arquivo .sci) é
carregado no ambiente e a raiz é, então, calculada. Por último, é gerado um gráfico
com os erros relativos de cada método.

ATIVIDADE PRÁTICA
// VÁ PARA A PASTA DE TRABALHO (ONDE ESTÃO AS FUNÇÕES QUE
IMPLEMENTAM OS MÉTODOS
// NO MENU PRINCIPAL, SELECIONE A SEQUÊNCIA "ARQUIVO -> ALTERAR
DIRETÓRIO ATUAL..."

// DEFININDO A FUNÇÃO CUJA RAIZ SE QUER DETERMINAR

function [y] = expx_menos_x(x)

y=exp(-x)-x;
endfunction

// DEFININDO A DERIVADA DA FUNÇÃO (PARA O MÉTODO DE NEWTON-

RAPHSON)

function [y] = deriv_expx_menos_x(x)

y=-exp(-x)-1;
endfunction

// ESTIMATIVAS INICIAIS: XL e XU; SE APENAS 1 FOR NECESSARIA, X0 = XL

xl = 0.5;

xu = 0.7;

x0 = xl;

// TOLERANCIA (EM PORCENTAGEM)

tol = 0.0001;

// NUMERO MAXIMO DE ITERAÇÕES

imax = 100;

//=========================================================
// BISSECÇÃO
//=========================================================

// CARREGAR FUNÇÃO BISSECÇÃO NO AMBIENTE E CALCULAR

exec("bisseccao.sci");

// PARA COMPARAR OS MÉTODOS ENTRE SI, VAMOS DEFINIR NOMES

DIFERENTES PARA OS PARAMETROS DE SAIDA

[raiz_bisec, x_bisec, iter_bisec,

ea_bisec]=bisseccao(xl,xu,expx_menos_x,tol,imax)

//=========================================================
// FALSA POSICAO
//=========================================================

// CARREGAR FUNÇÃO FALSAPOSICAO NO AMBIENTE E CALCULAR

exec("falsaposicao.sci");

[raiz_falsap, x_falsap, iter_falsap,

ea_falsap]=falsaposicao(xl,xu,expx_menos_x,tol,imax)

//=========================================================
// PONTO FIXO
//=========================================================

// IMPORTANTE: NAO ESQUECER QUE O PROBLEMA TEM QUE SER

REFORMULADO COMO UM PROBLEMA DE

// PONTO FIXO. NESTE CASO, É IMEDIATO EXP(-X)-X=0 => X = EXP(-X)

// ASSIM DEVEMOS DEFINIR UMA FUNÇÃO DIFERENTE PARA O PONTO FIXO:

function [y]=expx_fp(x)
y=exp(-x);
endfunction

// CARREGAR FUNÇÃO PONTOFIXO NO AMBIENTE E CALCULAR

exec("pontofixo.sci");

[raiz_pfixo, x_pfixo, iter_pfixo, ea_pfixo]=pontofixo(x0,expx_fp,tol,imax)

//=========================================================
// NEWTON-RAPHSON
//=========================================================

// CARREGAR FUNÇÃO NEWTONRAPHSON NO AMBIENTE E CALCULAR

exec("newtonraphson.sci");

[raiz_newton, x_newton, iter_newton,

ea_newton]=newtonraphson(x0,expx_menos_x,deriv_expx_menos_x,tol,imax)

//=========================================================
// SECANTE
//=========================================================

// CARREGAR FUNÇÃO SECANTE NO AMBIENTE E CALCULAR

exec("secante.sci");

[raiz_secante, x_secante, iter_secante,

ea_secante]=secante(xl,xu,expx_menos_x,tol,imax)

// GRAFICO DOS ERROS RELATIVOS APROXIMADOS

[nr nc]=size(ea_bisec);
niter=linspace(1,nr,nr);
plot(niter,ea_bisec,'ro-');

[nr nc]=size(ea_falsap);
niter=linspace(1,nr,nr);
plot(niter,ea_falsap,'gx-');

[nr nc]=size(ea_pfixo);
niter=linspace(1,nr,nr);
plot(niter,ea_pfixo,'bs-');

[nr nc]=size(ea_newton);
niter=linspace(1,nr,nr);
plot(niter,ea_newton,'cd-');

[nr nc]=size(ea_secante);
niter=linspace(1,nr,nr);
plot(niter,ea_secante,'vm-');

xlabel("Número de Iterações","fontsize",4,"color","red");
ylabel("Erro Relativo Aproximado","fontsize",4,"color","red");
title("Gráfico de Convergência","color","red","fontsize",4);
//xtitle("Gráfico de Convergência f(x)=exp(-x)-x", "Número de Iterações", "Erro
Relativo Aproximado");
legend("Bissecção", "Falsa Posição", "Ponto Fixo", "Newton-Raphson",
"Secante");
O gráfico de convergência obtido deve ser o da figura abaixo:

ATIVIDADE PRÁTICA

Com base no que foi aprendido nas aulas teóricas, interprete o gráfico de
convergência.
Verifique quantas iterações foram necessárias para cada método convergir
construindo uma tabela simples com o comando:

itermatriz=[..
"Bissecção ", msprintf('%d',iter_bisec);
"Falsa Posicao ", msprintf('%d',iter_falsap);
"Ponto Fixo ", msprintf('%d',iter_pfixo);
"Newton-Raphson", msprintf('%d',iter_newton);
"Secante ", msprintf('%d',iter_secante)]

No gráfico obtido, algumas curvas ficam sobrepostas. Use o seguinte comando

para limitar os valores nos eixos x e y:

set(gca(),"data_bounds",matrix([0,8,0,3],2,-1));

(por ora, não discutiremos esse commando, use-o como uma “caixa preta”).
O resultado é:

Agora é possível visualizar que Newton-Raphson converge um pouco mais

rápido, por exemplo.
3.4. USANDO SCRIPTS PARA A DETERMINAÇÃO DA RAIZ

Suponha que você deseje realizar vários estudos variando, por exemplo, os
parâmetros do problema como as estimativas iniciais, a tolerância, etc. Seria um
grande desperdício de tempo e energia digitar todos os comandos novamente.
Esta é uma típica situação em que scripts devem ser usados. Todos os comandos
digitados anteriormente podem ser coletados e armazenados em um arquivo de
script que, como vimos, possui extensão .sce. Para agilizar as atividades práticas,
isso já foi feito previamente e está no arquivo ConvergenciaMetodos.sce.

ATIVIDADE PRÁTICA

Com o SciNotes, abra o arquivo ConvergenciaMetodos.sce e verifique que ele

contém todos os comandos digitados na Atividade Prática anterior. Usando o
script, podemos

Como vimos, para executá-lo, basta usar o comando:

exec(“ConvergenciaMetodos.sce”);

Verifique que o resultado do script é exatamente o mesmo da longa sessão de

digitação.

A vantagem é que, agora, podemos simplesmente editar o arquivo .sce, alterar

qualquer parâmetro e, até mesmo, determinar a raiz de outra equação não
linear; basta alterar as definições das funções no início do arquivo.

Com base no procedimento apresentado, você agora pode determinar a raiz de

qualquer equação não linear.

ATIVIDADE PRÁTICA

Altere o scrip ConvergenciaMetodos.sce (crie uma cópia) e encontre a raiz da

função f(x)= ex-4x2 com erro relativo igual a 0.01%.
Antes determine graficamente um intervalo que contenha a raiz.