UNIVERSIDADE FEDERAL DO PARAN

DEPARTAMENTO DE ENGENHARIA ELTRICA

EDGAR DOS REIS

GRR 20111758

CI 202 Mtodos Numricos

Relatrio Zeros de Equaes Transcendentes e
Polinomiais

Atividade apresentada
disciplina de Mtodos Numricos,
ministrada pela Professora Caroline
Mazetto, para turma do 6. Perodo
de Engenharia Eltrica.

CURITIBA
2014

1. INTRODUO
O trabalho consiste na implementao dos mtodos para encontrar as
razes de equaes transcendentes e polinomiais, e na anlise dos resultados
para resolver o problema proposto. Os mtodos que sero implementados so:
Bisseo, Falsa Posio, Iterao Linear, Newton-Raphson e Secante.
Alm de uma analise de todos os mtodos, considerando as vantagens e
desvantagens e a verificao de melhoria no desempenho dos respectivos
mtodos.

2. METODOLOGIA
Conforme solicitado foi desenvolvido um programa em C atravs do
programa DEV-C, dentro da funo principal optou-se por conter somente um
menu chamando as funes, para haver modularidade conforme as
especificaes, podendo o usurio, ao final de cada resultado, escolher outro
mtodo de resoluo, conforme Algoritmo 1.

//**********************************************************************//
// Funo Principal
//**********************************************************************//
void main()
{
int opcao = 0;

// Opes do menu

while( opcao < 6 )

{
printf( "Infome a opcao desejada:\n" ); // Lista de Mtodos
printf( "1) Bissecao\n" );
printf( "2) Falsa Posicao\n" );
printf( "3) Iteracao Linear\n" );
printf( "4) Newton Raphson\n" );
printf( "5) Secante\n" );
printf( "6) Sair\n" );
scanf("%i",&opcao);
switch(opcao)
{
case 1:
bissecao ();
break;
case 2:
fposicao ();
break;
case 3:
iteracao_linear ();
break;
case 4:

newton_rapshon ();
break;
case 5:
secante ();
break;
case 6:
exit(1);
break;
default:
printf( "Nenhuma Opcao valida\n\n" );
break;
}
}
}

Algoritmo 1 - Funo Principal

Seguindo a modularidade do cdigo, foi feito uma funo para cada

equao, ou seja, f(x), df(x), g(x) e dg(x), para facilitar a utilizao destas
funes e alteraes para outras funes polinomiais, como possvel verificar
no Algoritmo 2 abaixo. No caso de g(x) havia dois modo de isolar x, porm com
g(x) = log(4*sin(x)) a funo no convergia, porm no caso de g(x) =
asin(exp(x)/4) a resposta estava dentro do intervalo desejado.

//**********************************************************************//
// Funes
//**********************************************************************//
// Chamada da Funo f(x)
float f( float x )
{
return 4*sin(x)-exp(x);
}
// Chamada da derivada de f(x)
float df( float x )
{
return 4*cos(x)-exp(x);
}
// Chamada da Funo g(x)
float g( float x )
{
//return log(4*sin(x));
return asin(exp(x)/4);
}
// Chamada da derivada de g(x)
float dg( float x )
{
//return -cos(x)/sin(x);
return exp(x)/(4*sqrt(1 - exp(2*x)/16));
}

Algoritmo 2 - Funes

// f(x)

// df(x)

// g(x)

// dg(x)

2.2

MTODOS NUMRICOS

importante resaltar que para validar os mtodos de quebra (bisseo

e falsa posio) e de mltiplos pontos (secante) foi utilizado o teorema de
Bolzano, de modo a verificar a existncia de apenas uma raiz no intervalo [0,1],
conforme abaixo:
( ) ( ) < 0
(0) (1) < 0
(4

(0) exp (0)) (4

(1) exp (1)) < 0

(1) (0.6476) < 0

(0.6476) < 0

2.2.1

Mtodo da Bisseo

O mtodo da bisseo o mtodo mais simples de implementao porm o

que possui a convergncia mais demorada, inicialmente necessrio escolher
o intervalo [a,b] para obter x1. Para facilitar a escolha deste intervalo temos a
Figura 1, onde possvel verificar que a raiz pertence ao intervalo [0,1] dado.

Figura 1 - Raiz da Equao

Aps dado o intervalo, aplica-se na formula para encontrar xn:

x =

a+b
2

Por se tratar de um mtodo de quebra, aps encontrar cada novo x

necessrio a escolha do melhor extremo, para isto utiliza-se a verificao
abaixo:
se f(a) f(x ) < 0, b = x
seno, a = x
O critrio de parada utilizado o mesmo para todos os mtodos aqui
aplicados, sendo ele:
|b a| erro
Conforme descrito todos os passos acima, o Algoritmo 3 contm a lgica
desenvolvida (sem os printf) para o mtodo da Bisseo.
Em todos os mtodos foram utilizados a mesma estrutura: uma funo para
cada mtodo; inicializao das variveis utilizadas; lao do-while para o critrio
de parada e a substituio dos valores das iteraes anteriores de xn para xm,
substituio esta necessria para a verificao de parada.
//**********************************************************************//
// Funo - Metodo da bisseco
//**********************************************************************//

void bissecao (void)

{
int n = 0;

// numero de iteraes

float erro = 0.00001;

// erro maximo

float a = 0;

// valor inicial

float b = 1;

// valor inicial

float xn;

// raiz da funo

float xm;

// xn-1 (anterior)

do{
xm = xn;

// guardar valor anterior de xn

n++;

// incremento

xn = (a + b)/2;

// algoritmo

// Escolha do intervalo
if (f(a) * f(xn) < 0)

b = xn;

// melhor extremo b

else

a = xn;

// melhor extremo a

printf( "x%i = %f\n" ,n,xn );

} while( fabs(xn-xm) > erro );

}

Algoritmo 3 - Mtodo da Bisseo

// print x1, x2, x3...

// Condio para interao

2.2.2 Mtodo da Falsa Posio

Este mtodo toma como base a mdia aritmtica ponderada entre a e b com
pesos |f(a)| e |f(b)|, respectivamente, desta forma obtemos o x

esperado,

uma forma mais aprimorada e com convergncia mais rpida do que o mtodo
da bisseo.
x = a

(b + a) f(a)
para n = 1,2,3,
f(b) f(a)

possvel verificar qual ser o ponto fixo para este mtodo, segundo o
procedimento:
A analise da concavidade importante para verificar se a funo muda de
inclinao num dado intervalo, conforme abaixo:
"(x) < 0
"(0) < 0
(4

(0) exp (0)) < 0

(1) < 0

Aps verificao da concavidade, conferida a funo dos extremos a e b.

( ) ( )
(0) (1)
(4

(0) exp (0)) (4

(1) exp (1))

(1) (0.6476)
Tendo os valores acima, podemos concluir que f(x) <0, f(a) < 0 e f(b) > 0,
desta forma a o ponto fixo. Por fim temos o critrio de parada:
|b a| erro
//**********************************************************************//
// Funo - Metodo da Falsa Posico
//**********************************************************************//

void fposicao (void)

{
int n = 0;

// numero de iteraes

float erro = 0.00001;

// erro maximo

float a = 0;

// valor inicial a

float b = 0.5;

// valor inicial b

float xn;

// raiz da funo

float xm;

// xn-1 (anterior)

do{

xm = xn;

// guardar valor anterior de xn

n++;

// incremento

xn = a - (b-a)*f(a) / (f(b)-f(a));

// algoritmo

// Escolha do intervalo
if (f(a) * f(xn) < 0)

b = xn;

// melhor extremo b

else

a = xn;

// melhor extremo a

} while( fabs(xn-xm) > erro );

// Condio para interao

Algoritmo 4 - Mtodo da Falsa Posio

2.2.3

Mtodo da Iterao Linear

O mtodo da iterao linear utiliza um artifcio algbrico que transformar f(x)

= 0 em duas funes que sejam equivalentes,
( )=0

=0
= ( )

Onde g(x) chamada funo de iterao, temos a primeira aproximao de

x0 = 0.5, calculando-se g(x0). Faz-se ento x1= g(x0), x2=g(x1), x3=g(x2) e assim
sucessivamente, conforme o Algoritmo 5.
Temos tambm de forma simplificada a equao abaixo para que haja a
convergncia de f(x), conforme implantao no Algoritmo 5.
|g ( x)| < 1
A maior dificuldade deste mtodo encontrar uma funo de interao que
satisfaa condio de convergncia, outro aspecto importante que o teste
mencionado |g ( x)| < 1 pode levar a um engano se x0 no estiver
suficientemente prximo da raiz.

//**********************************************************************//
// Funo - Metodo da Iterao Linear
//**********************************************************************//

void iteracao_linear (void)

{
int n = 0;

// numero de iteraes

float erro = 0.00001;

// erro maximo

float xn = 0.5;

// raiz da funo

float xm;

// xn-1 (anterior)

do{

xm = xn;

// guardar valor anterior de xn

n++;

// incremento

xn = g(xm);

// algoritmo

// Verificao de Convergncia
if (fabs(dg(xm)) > 1)

printf( "Nao Convergente\n" );

} while( fabs(xn-xm) > erro );

// Condio para interao

Algoritmo 5 - Mtodo da Iterao Linear

2.2.4

Mtodo de Newton Rapshon

Este mtodo inicialmente escolhe-se uma aproximao inicial. Aps isso,

calcula-se a equao da reta tangente (derivada) da funo nesse ponto e a
interseo dela com o eixo das abscissas, a fim de encontrar uma melhor
aproximao para a raiz, o que se pode classificar entre o os mtodos
estudados, o mais complexo de sua resoluo. Repetindo-se o processo, criase um mtodo iterativo para encontramos a raiz da funo. O Mtodo de
Newton representado da seguinte forma:
x =x

f(x
f(x

)
para n = 1,2,3,
)

Para decidir qual o melhor extremo de intervalo (a,b) a iniciar o mtodo,

basta verificar qual dos extremos possui funo e segunda derivada com o
mesmo sinal.
f(x ) f"(x ) > 0
(0) "(0) > 0
(4

(0) exp (0)) (4

(0) exp (0)) > 0

(1) (1) > 0

( 1) > 0
Para aplicarmos todas as condies, temos o que repete o processo
interativo at que |x x | erro.

//**********************************************************************//
// Funo - Metodo de Newton Rapshon
//**********************************************************************//

void newton_rapshon (void)

{
int n = 0;

// numero de iteraes

float erro = 0.00001;

// erro maximo

float a = 0;

// valor inicial

float b = 0.5;

// valor inicial

float xn = 0.5;

// raiz da funo

float xm;

// xn-1 (anterior)

do{
xm = xn;

// guardar valor anterior de xn

n++;

// incremento

xn = xm-f(xm)/df(xm);

// algoritmo

// Verificao de Convergncia
if (df(a)*df(b) < 0)

printf( "Nao Convergente\n" );

} while( fabs(xn-xm) > erro );

// Condio para interao

Algoritmo 6 - Mtodo de Newton Rapshon

2.2.5

Mtodo da Secante

O mtodo da Secante um algoritmo de busca de razes que usa uma

sequncia de razes de linhas secantes para aproximar cada vez melhor a raiz
de uma funo f(x).
x

= x

(x x ) f(x )
para n = 1,2,3,
f(x ) f(x )

Este um mtodo de mltiplos pontos, e inicialmente necessrio de x0 e

x1, dados respectivamente 0 e 1, a repetio do processo ocorre at que
|x x | erro, conforme o Algoritmo 7. Este mtodo tenta contornar uma
grande desvantagem que o mtodo de Newton possui, que a necessidade de
se obter a derivada de f(x) e calcular o seu valor numrico a cada interao,
conforme dito anteriormente.
//**********************************************************************//
// Funo - Metodo da Secante
//**********************************************************************//

void secante (void)

{
int n = 1;

// numero de iteraes

float erro = 0.00001;

// erro maximo

float a = 0;

// valor inicial

float b = 0.5;

// valor inicial

float xn = 1;

// valor inicial

float xm = 0;

// valor inicial

float x;

// raiz de f(x)

do{
xm = xn;

// guardar valor anterior de xn

xn = x;

// guardar valor anterior de x

n++;

// incremento

x = xn - (xn - xm)*f(xn) / (f(xn) - f(xm));

// algoritmo

// Verificao de Convergncia
if (f(a)*f(b) > 0)

printf( "Nao Convergente\n" );

} while( fabs(xn-xm) > erro );

// Condio para interao

Algoritmo 7 - Mtodo da Secante

3. CONCLUSO
Aps a execuo e anotao dos resultados de todos os mtodos foi
possvel completar a Tabela 1 e analisar os melhores mtodos so os que
convergem com menor numere de iteraes, na sequncia: Newton, Falsa
Posio, Secante, Iterao Linear e por ultimo o mtodo da Bisseo. Isto deve
se ao nvel de complexidade que os mtodos de convergncia mais rpidos
possuem, como Newton e Falsa Posio. Outro aspecto que demonstra a
preciso do mtodo de Newton o quo prxima sua raiz |2 10 | foi de zero
em relao aos outros mtodos.
Tabela 1- Comparativo de Desempenho 1

Mtodo:
Dados

Bisseo

Falsa Posio

Iterao Linear

[0,1]

[0,1]

X0 = 0.5

Newton
X0 = 0.5

Iniciais
xi

Secante
X0 = 0
X1 = 1

0.370552
-6

0.370559

f(xi)

4*10

1*10

Iteraes

17

-6

0.370563
-6

0.370555

7*10

-2*10

11

-7

0.370558
6*10-6
8

Em relao melhoria do desempenho de cada mtodo, uma forma rpida

de reduzir consideravelmente o numero de iteraes reduzir o intervalo e/ou
aproximar o x inicial do valor real da raiz, conforme testado na Tabela 2.
possvel notar que para alguns casos houver a reduo de duas iteraes,

como do da Falsa Posio, Iterao Linear e Secante. Convergindo assim mais

rapidamente ao valor da raiz.
Tabela 2 - Comparativo de Desempenho 2

Mtodo:
Dados

Bisseo

Falsa Posio

Iterao Linear

[0,0.4]

[0,0.4]

X0 = 0.4

Newton
X0 = 0.4

Secante
X0 = 0
X1 = 0.4

Iniciais
xi

0.370563

0.370559

0.370564

0.370558

0.370558

f(xi)

6*10-6

2*10-6

10*10-6

-2*10-7

2*10-6

Iteraes

16