Zeros de Funções

O problema aqui é encontrar os valores da variável independente $x_{i}$ que fazem com 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$

Porem, 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 de que valor da variável independente partiu.

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-se 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 quando utlizados para encontrar raízes "instáveis" de iteração. Para descobrir se haverá raizes 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.

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:

$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.

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

...