Zeros de Funções

Calcular o zero de uma função significa encontrar os valores da variável independente $x_{i}$ que fazem com que a função $f(x_{i})$ tenha o valor zero.

Matematicamente pode ser formalizado assim:

$x:f(x)=0\,$

Os zeros da função f são também chamados de raízes.

Um exemplo simples é achar as raízes da função $1/(x+1)-2$. A simplicidade vem do fato dessa função ter inversa, com o qual a solução pode ser encontrada isolando o x: $x=-1/2$ que é o zero dessa função ou equação.

Outro exemplo clássico são as raízes de uma parábola:

$f(x)=ax^{2}+bx+c\,$

da qual existe uma expressão para as raízes (cuja programação é um dos exercícios):

$x=(-b+-{\sqrt {b^{2}-4ac}})/2a$

Porém, quando a função é mais complicada, o problema de achar os zeros pode não ter (é o mais comum) solução analítica.

Vale notar que ao tratar dos zeros podemos generalizar o conceito para qualquer outro valor. Por exemplo, achar x tal que $f(x)=d$ é equivalente a achar os zeros de $f(x)-d$. De outra forma podemos dizer que trata-se do problema inverso: dado o valor da função queremos saber a qual valor da variável independente ele corresponde.

Numericamente, temos três métodos usuais que serão descritos aqui, os métodos da Iteração Simples, Newton-Raphson e Método da Bisecção.

Iteração Simples

Para o método da iteração simples, utiliza-se uma nova função $F(x)$ para encontrar o zero da função original $f(x)$, de modo que se define

$F(x)=f(x)+x,$

assim

$F(x)=x\,\;para\,\;f(x)=0.$

Utilizamos a própria função para definir o valor de $x$ nas iterações, tendo que existir um "chute" inicial para o valor $x_{0}$. Assim, a iteração pode ser definida como

$x_{n+1}=F(x_{n})$.

Itera-se a equação até atingir-se um valor fixo, ou seja, $x_{n+1}=x_{n}$.

As duas principais destavantagens deste método devem-se ao fato de ele ser mais lento que demais métodos e por existir funções que apresentam raízes "instáveis" de iteração. Ou seja, são raízes que este método não é capaz de encontrar. Para descobrir se haverá raízes instáveis de convergência, utilizamos a condição de convergência do método, perturbando a solução $x_{n+1}=x_{n}=x^{*}$ e expandindo em série de Taylor:

$x^{*}+\delta =F(x^{*}+\delta )=F(x^{*})+{\frac {dF(x^{*})}{dx}}\delta +...$

Note que para

$\|{\frac {dF(x^{*})}{dx}}\|\leqslant 1$

o efeito da perturbação decai, indicando que a raíz $x^{*}$ é estável por este método. Ao contrário, se expressão acima for maior do 1, isto implica que uma pequena perturbação faria com que os valores da função se afastassem do valor de $F(x^{*})$ mesmo se estivéssemos calculando um valor da função em $x^{*}+\delta$ com $\delta$ muito pequeno. Se este for o caso, então o método de iteração simples não consegue encontrar a raiz $x^{*}$.

Newton-Raphson

O método de Newton-Raphson é um procedimento para encontrar zeros de funções de maneira iterativa, assim como o método da iteração simples. Partindo de um ponto qualquer da função vamos ao próximo ponto com deslocamento dado pela derivada no ponto inicial:

Método de Newton-Raphson com $x_{0}$ e $x_{1}$.

$f'(x_{n})={\frac {f(x_{n})-0}{x_{n}-x_{n+1}}}={\frac {0-f(x_{n})}{(x_{n+1}-x_{n})}}\,\!$

Desta forma o próximo ponto está dado por:

$x_{n+1}=x_{n}-{\frac {f(x_{n})}{f'(x_{n})}}\,\!$.

e o processo é repetido até a precisão desejada. Note que numericamente não temos garantia de achar exatamente a raiz. Devemos fixar um $\epsilon$ que determina a tolerância com que vamos a aceitar o zero. Ou seja quando $|f(x)|<\epsilon$ paramos a procura.

Por outra parte o método não garante a convergência, isto é, pode acontecer que o processo entre num ciclo infinito pipocando de uma lado para outro da raiz, sem poder encontrar uma solução.

Geometricamente, como mostrado na figura ao lado, tendo sido escolhido o ponto $x_{0}$, queremos que o ponto $x_{1}$ seja o encontro da reta tangente (ou da derivada) da função no ponto $x_{0}$ com a reta das abcissas. Sendo

$f'(x_{0})=tan(\theta )$,

temos que

$x_{0}-x_{1}={\frac {f(x_{0})}{f'(x_{0})}}$.

A figura abaixo mostra as iterações do método de Newton-Raphson (retirado da Wikipedia [1])

Bissecção

O método da bissecção consiste em utilizar um intervalo de valores de $x$ que é sabido que contenha uma raíz. Note que temos que ter uma noção prévia da função para utilizar este método. Definindo um intervalo

$a\leqslant x\leqslant b$,

temos a condição $f(a)f(b)<0$, indicando que há pelo menos um zero contido neste intervalo, ou seja, que a função "corta" o eixo das abcissas, de modo que um valor da função seja maior que zero e outro menor.

Definindo o intervalo inicial $[a,b]$, dividimos este por dois, encontrando o valor médio $x_{m}$, dado por

$x_{m}=a+{\frac {b-a}{2}}={\frac {a+b}{2}}.$

Note que estamos com dois intervalos de $x$, primeiro $[a,x_{m}]$ e segundo $[x_{m},b]$. Agora precisamos descobrir em qual desses dois intervalos há uma raíz. Para isso calculamos o produto das funções nos pontos específicos. Se $f(a)f(x_{m})<0$ e $f(x_{m})f(b)>0$, continuamos com o primeiro intervalo (que contém um raíz), caso contrário com o segundo. Prosseguindo com o algoritmo, dividimos o novo intervalo que contém a raiz novamente

$x_{m2}={\frac {x_{m}+a}{2}}.$

Repetimos o processo anterior, verificando em qual dos dois novos intervalos, $[a,x_{m2}]$ ou $[x_{m2},x_{m}]$ está a raiz.

O algoritmo é repetido até encontrarmos a raíz, com a precisão $\eta$ ou seja, até que $-\eta ^{2}\leqslant f(a)f(b)\leqslant 0$. O ideal é ao final ficar com o valor intermediário das funções.

Abaixo há uma figura com duas iterações do método da bissecção, assim como descrito acima.

Programação

Para programá-lo em FORTRAN o mais prático é definir como funções tanto a própria função como a sua derivada. Sejam elas f(x) e g(x) respectivamente, o trecho de código com a implementação do método fica:

...
x = x0
Do
   if (g(x)==0) then
     print*, "em x=", x, "a derivada é zero"
   else
     x = x - f(x)/g(x)
     if (abs(f(x)) < eps) then
        print*, "raiz em x=", x, "f(x)=", f(x)
        exit
     endif
   endif
endo
...

Plano Complexo

O método pode ser estendido a funções f(z) onde z, e f(z) pertencem a C (domínio dos números complexos). Dessa forma todas as raízes de um polinômio podem em princípio ser encontradas. O método tem a mesma formulação teórica. Só muda o programa pois precisamos usar complexos.

Complex f, z
Real x,y
Read*, x,y

z = CMPLX(x,y) ! função FORTRAN intrínseca para converter un par x,y de variáveis reais numa variável complexa
...

if (abs(f(z)<eps) print*, z

...