Aqui não temos a intenção de ensinar ao leitor programação e nem técnicas de programação de computadores, mas apenas de fornecer algumas dicas que poderão ser de grande ajuda aos programadores menos experientes. Algumas das dicas dadas a seguir podem auxilia-lo a evitar erros de cálculo muito comuns com o uso de computadores.
Em cálculos astronômicos é muito comum aparecer ângulos muito grandes e também a utilização de diversas unidades angulares como por exemplos: o grau, o minuto o segundo, horas (uma hora equivale a 15 graus) e o radiano. Um computador poderia ter calculado, para um determinado ano dia de um certo ano, a média longitude do Sol como -2318.1980 graus. Então talvez seja necessário reduzir este ângulo para o intervalo de 0 a 360 graus porque algumas linguagens de programação podem fornecer valores de funções trigonométricas incorretos para ângulos de grande valor. Digite e execute o programa a seguir e verifique se sua linguagem de programação C++ produz erros para ângulos grandes.
Programa 5
——————————————————–
#include<stdio.h>
#include<stdlib.h>
#include<math.h>
#define PI 3.14159
int main(void)
{
system(“cls”);
/* Aqui fornecemos a funcao trigonometrica o cos()
valor do angulo 3600030 graus cuja conversao para
radianos fazemos multiplicando por PI e dividindo
por 180 */
printf(“\n\ncos(3600030) = %f”,cos(3600030*PI/180));
/* Aqui apresentamos o valor esperado para o cosseno
de 3600030 graus, que reduzido ao intervalo de 0 a 360,
seria equivalente a 30 graus */
printf(“\n\nO valor correto : %f\n\n”,cos(30*PI/180));
system(“pause”);
return(0);
}
——————————————————–
O resultado obtido no Borland Turbo C++ 3.0 foi cos(3600030) = 0.891330 enquanto que o valor melhor do cosseno para este ângulo seria 0.866026. Veja que as diferenças já ocorrem no segundo dígito significativo, o que poderia acarretar erros grandes em cálculos Astronômicos.
Algo que também pode ocasionar erros em cálculos computacionais são as diferentes unidades angulares e a forma de representar ângulos. A maioria dos computadores não calculam diretamente com as funções trigonométricas usando os valores dos ângulos em graus, mas sim em radianos. Por exemplo se desejarmos calcular o cosseno do ângulo 23o26’49” teríamos de converter esse valor para radianos. Para converter um ângulo de graus para radianos, basta multiplicarmos o valor do ângulo em graus por π/180. Então o ângulo 23o26’49” primeiro é convertido totalmente em graus para o valor 23.44694444o e depois multiplicado por π/180 resultando em 0.017453295199 radianos.
Em Astronomia é comum representar ângulos em horas, minutos e segundos. É o caso da ascensão reta, onde cada hora é equivalente à 15o. Por exemplo se queremos converter uma ascensão reta de valor α = 9h14m55.8s, então convertemos tudo para horas: 9 + 14/60 + 55.8/3600 = 9.248833333 horas. Depois multiplicamos esse valor por 15 obtendo o valor α = 138o.73250.
Outro caso que pode levar a erros de programação é a inserção de ângulos negativos. Ângulos representados por graus , minutos e segundos podem ser inseridos em C++ pela função scanf(“%f %f %f”,&g,&m,&s) onde g,m e s são variáveis do tipo float. Por exemplo o ângulo 21o 44′ 07″ pode ser armazenado numa variável (a), convertido para graus, por meio da seguinte instrução: a = g + m/60 + s/3600. Neste exemplo não temos nenhum problema, mas se o ângulo fosse negativo como -21o 44′ 07″ então os valores atribuídos as variáveis a g,m e s devem ser: a = -21, m = -44 e s = -7. Todos os valores precisam ter o mesmo sinal. Esse erro pode ser evitado se simplesmente garantirmos que os valores dos minutos e dos segundos sejam sempre negativos para o caso do valor em graus seja negativo. Digite o programa dado a seguir e teste vários valores de ângulos, como ou sem sinais e verifique os resultados.
Programa 6
——————————————————–
#include<stdio.h>
#include<stdlib.h>
#include <math.h>
int main(void)
{
float g,m,s,a; // g para graus, m para minutos e s para segundos
system(“cls”);
printf(“Entre com o angulo em graus minutos e segundos\: “);
scanf(“%f %f %f”,&g,&m,&s);
/* a condicional a seguir garante que o usuario
nao erre os sinais do angulo negativo */
if (g < 0)
{
m = -abs(m); // garante que m e s tambem sejam negativos
s = -abs(s);
}
a = g + m/60 + s/3600; // a, recebe o angulo convertido
printf(“\n\n\n a = %f\n\n\n”,a);
system(“pause”);
return(0);
}
——————————————————–
Outro problema que precisamos levar em consideração é com relação as funções trigonométricas inversas. Estas funções, na linguagem C, retornam ângulos apenas no intervalo de -90o a +90o para as funções arcsin() (arco seno) e arctan() (arco tangente) e de 0 a +180o para arccos() (arco cosseno). Por exemplo temos que o cosseno do ângulo 147o vale -0.8387 se revertermos esse valor arccos(-0.8387) obteremos o ângulo de 147o novamente. Porém, se o ângulo for de 213o seu cosseno também será de -0.8387 mas revertendo esse valor não obtemos 213o mas sim 147o. Digite o programa a seguir e verifique vários ângulos com as funções sin() e arcsin() da linguagem C.
Programa 7
——————————————————–
/ Teste das funções trigonométricas
#include<stdio.h>
#include<stdlib.h>
#include<math.h>
#define PI 3.14159265
int main(void)
{
float ang,seno_ang,ang_graus,ang_rad;
// ang e o angulo fornecido pelo usuario em graus
// seno_ang recebera o seno do angulo fornecido pelo usuario
// ang_graus recebera o valor de ang convertido para radianos
// ang_graus recebera o arcseno(ang) convertido em graus
system(“cls”);
printf(“\n\nEntre com o valor do angulo em graus: “);
scanf(“%f”,&ang);
// converte o angulo em radianos e armazena em ang_ra
ang_rad = ang*PI/180.0;
// Calcula o seno do angulo e armazena em seno_ang
seno_ang = sin(ang_rad);
// Retoma o angulo e converte em graus e
// armazena em ang_graus
ang_graus = asin(seno_ang)*180.0/PI;
// Imprime, na tela, os resultados obtidos
printf(“\n\nAngulo: %f”,ang);
printf(“\nSen(%f) = %f”,ang,seno_ang);
printf(“\narcsen(%f) = %f\n\n\n”,seno_ang,ang_graus);
system(“pause”);
return 0;
}
——————————————————–
Algumas fórmulas que determinam certas grandezas são feitas utilizando potências de tempo. Estas expressões, que geralmente são formas polinomiais em função de T, tem valores válidos para pequenos valores de T. Um exemplo disto é a fórmula que fornece a excentricidade do planeta Urano:
e = 0,04638122 – 0,000027293*T + 0,000 000 0789*T2
Onde T é medido em séculos julianos, que equivalem 36525 dias desde o início do ano 2000 DC. Pode-se verificar que esta fórmula é válida para apenas alguns séculos antes e após o ano 2000 DC, para um intervalo de tempo entre -30 a 30 . Para T muito maior que 30 a expressão perde a sua validade, por exemplo: para T = -3307,9 e = 1 o que indicaria que a órbita de Urano seria uma parábola e não uma elipse. Apesar da excentricidade das órbitas dos planetas sofrerem variações elas podem ser representadas , para um intervalo de alguns milênios, por um expressão polinomial de segundo grau.
As linguagens de programação geralmente possuem funções para cálculos de potências. Em C, a biblioteca math.h possui uma função para isto, a função pow(a,b) onde a é a base da potência e b o expoente. Apesar desta facilidade essas funções consomem um considerável tempo de processamento, assim é preciso evitá-las quando possível. Por exemplo se tivermos um polinômio escrito na forma:
y = A + B*x + C*x2 + D*x3 + E*x4
Poderemos reescrevê-lo na denominado método de Homer:
y = A+ x*(B + x*(C +x*(D +x*E)))
Nesta expressão as potências desapareceram ficando apenas operações simples como adições e multiplicações reduzindo assim o tempo de processamento da mesma.
Sempre que possível revise o seu programa em buscas de erros de sintaxe, lógica ou mesmo de digitação e se for possível, teste os resultados de seu programa comparando-os com os de soluções já conhecidas.
Referência:
Meeus, Jean, Astronomical Algorithms, 2. Ed. Richmond, Virginia: Willmann-Bell, Inc, 1991.
<Anterior Próxima>