Primeiro Trabalho de Análise Numérica
Português Estruturado
A seguir será apresentado o português estruturado para “tentarmos” encontrar o valor de Pi (π)
aproximado para o número de casas decimais que o computador suporta.
Considere o polígono inicial sendo de quatro lados e cada lado medindo raiz de dois;
Considere o perímetro inicial sendo quatro vezes raiz de dois;
REPITA até que o perímetro seja igual ao perímetro anterior
O lado do polígono passa a ser quatro unidades menos o quadrado do lado anterior;
O lado do polígono passa a ser duas unidades menos a raiz do lado anterior;
O lado do polígono passa a ser a raiz do lado anterior;
O número de lados passa a ser o dobro do número de lados do polígono anterior;
O perímetro passa a ser o número de lados do polígono multiplicado pelo tamanho do lado;
Considere metade do perímetro
Informe o perímetro
Quando o perímetro é informado, nós obtemos um valor aproximado para π. O que podemos
afirmar à respeito do valor obtido é que ele ocupa toda a quantidade de dígitos que o computador
suporta com valores significativos, ou seja, corretos.
À respeito da repetição, ela só irá parar quando o perímetro atual for igual ao anterior. Isso quer
dizer que se continuar fazendo a repetição, o valor obtido não será mais alterado. Por isso a repetição
para e podemos afirmar que aquele valor está com a precisão máxima alcançada pelo computador.
Detalhe: Para obtermos o valor “exato”, essa repetição seria infinita, pois o número de
algarismos significativos também seria infinito.
Programa em Pascal
Durante a realização do trabalho, várias idéias foram surgindo e, para cada idéia, foi feito um
programa diferente para que a idéia pudesse ser exclusivamente analisada. A seguir, serão
apresentados dois desses programas que considero os mais importantes. A ordem a ser apresentada é
de acordo com a evolução do trabalho.
Primeiro Programa: Tentativa e Erro. (Explicação vem depois do programa)
Program Pi;
Uses crt;
Var
n,j : longint;
I,P : extended;
Begin
clrscr;
n:=4;
I:=sqrt(2);
For j:=1 to 17 do
Begin
I:=sqrt(2-sqrt(4-sqr(I)));
n:=2*n;
End;
P:=n*I;
Writeln(´O polígono final tem ´, n,´ lados´);
Writeln(´Cada lado mede: ´,I);
Writeln(´O valor obtido para o perímetro foi: ´,P);
P:=P/2;
Writeln(´O valor encontrado para Pi foi: ´,P);
Readkey;
End.
O programa acima é caracterizado pelo método da tentativa e erro, ou seja, a quantidade de
vezes que foi realizada a repetição central foi determinada de acordo com o valor obtido. Resumindo, o
programa era executado com uma quantidade de repetições e o valor obtido era analisado. Se o valor
estivesse correto até uma certa casa decimal, o número de repetições era aumentado uma unidade e
assim por diante até quando a repetição foi realizada 18 vezes e o valor obtido extrapolou o correto.
Com isso, foi concluído que o programa tinha uma certa precisão e essa precisão era realizar apenas 17
vezes a repetição central.
Quando realizada 17 vezes a repetição, o valor obtido para 2π, ou seja, o perímetro do
polígono, foi:
P=6,28318530724359.
Enquanto que o valor fornecido pela calculadora do “Windows” é:
2π=6,283185307179586476925286766559.
Com esses valores, podemos ver que a precisão de P (do programa) em relação a 2π (do
Windows) é de 9 casas decimais. (Nada mais, nada menos que a precisão de uma calculadora científica
comum.).
Quando realizada acima de 18 vezes a repetição, o valor obtido ultrapassava o do “Windows”.
Segundo Programa: Igual ao Português Estruturado. (Explicação vem depois do programa.)
Program Pi;
Uses crt;
Var
n,j : longint;
I,P,Pa : extended;
Begin
clrscr;
n:=4;
I:=sqrt(2);
P:=n*I;
j:=0;
Repeat
Pa:=P;
I:=sqrt(2-sqrt(4-sqr(I)));
n:=2*n;
j:=j+1;
P:=n*I;
until (P=Pa);
Writeln(´Foram realizadas ´, j,´ repetições´);
Writeln(´O polígono final tem ´, n,´ lados´);
Writeln(´Cada lado mede: ´,I);
Writeln(´O valor obtido para o perímetro foi: ´,P);
P:=P/2;
Writeln(´O valor encontrado para Pi foi: ´,P);
Readkey;
End.
O programa acima é semelhante ao português estruturado apresentado no começo do trabalho.
Nele foi realizada uma repetição que, teoricamente, é infinita. Mas como no computador existe o que
chamamos de “zero relativo”, chega uma hora que essa repetição para. Ou seja, se a repetição
continuar, as parcelas que serão acrescentadas dali por diante, não irão alterar o valor obtido. Isso quer
dizer que todas as casas decimais do computador foram preenchidas com valores significativos e os
próximos valores obtidos serão iguais. É por isso que a repetição deve parar e informar o valor.
O problema é que o valor obtido foi:
P=6,28319310740964
Já o valor de 2π numa calculadora comum é:
2π=6,283185307
Como podemos ver, o valor obtido apresenta uma precisão menor do que a do programa
anterior. Isso já era previsto, porque no outro programa já tínhamos visto que o valor obtido
extrapolava o valor correto quando era realizado mais de 17 vezes. Foi o que aconteceu nesse
programa, pois o valor de “j” foi 26. Isso quer dizer que a repetição foi realizada 26 vezes.
Não chegamos a uma explicação plausível para o fato. Mas temos uma especulação: Talvez, o
“erro” esteja nas raízes. A começar pela raiz de dois, que é um número irracional, a partir daí os
números começam a ficar menores e as raízes começam a dar erros que “afetam” o valor principal.
Mesmo com essa explicação, que não explica tudo, ainda existe um mistério no ar: “Por que
“raios” a repetição parou em j=26???”. Afinal, se usarmos o primeiro programa para fazer a repetição
até 27 ou 28, o valor obtido é diferente. Interessante, não?!