Fala galera!
Estou fazendo um exercício em C mas com o foco em algoritmo.
O problema é o seguinte:
O valor de senx pode ser obtido com boa aproximação através dos 30 primeiros termos da série a seguir:
senx = x^1/1! - x^3/3! + x^5/5! - x^7/7! …
Construir um algoritmo que dado o valor de x, escrever quanto vale senx.
Bem, eu fiz a solução. O algoritmo compila, mas dar problemas no resultado: senX: -1.#INDOO
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
float calculaFatorial(int x) {
int i;
int fatorial = 1;
for(i = 1; i <= x; i++) {
fatorial *= i;
}
return fatorial;
}
int main() {
//Contador dos 30 termos a serem calculados
int i = 30;
//Valores se seno de X e resultados dos operadores
float senX = 0;
float resultadoPositivo = 0;
float resultadoNegativo = 0;
float x;
float contador1 = 1;
float contador2 = 3;
x = 45;
while(i != 0) {
resultadoPositivo = (pow(x, contador1)) / (calculaFatorial(contador1));
resultadoNegativo = -((pow(x, contador2)) / (calculaFatorial(contador2)));
contador1 += 4;
contador2 += 3;
i--;
}
senX = resultadoPositivo + resultadoNegativo;
printf("SenX: %f", senX);
return 0;
}
Alguém poderia me ajudar por favor?
Provavelmente seu problema está em tentar calcular o fatorial de números grandes (como 30). Os tipos primitivos (int, float) não são adequados para armazenar e calcular com números grandes (e o fatorial de 30 é um número beeeeem grande).
Abraço.
1 curtida
Agradeço o seu comentário meu amigo.
Tentei fazer em java, debuguei o programa manualmente e achei isso:
5.0
120.0
3125.0
120.0
1953125.0
120.0
1.220703125E9
120.0
Resultado! 1.0172526E7
5.0
120.0
3125.0
120.0
1953125.0
120.0
1.220703125E9
120.0
Resultado! 1.0172526E7
**SenX: 0.0**
O resultado que espero é o senX, e ainda encontro problemas. Você conhece alguma biblioteca que me ajuda com esses números grandes?
Sabe como posso usar?
É que nunca usei uma biblioteca na vida!
No caso do java, pode tentar com BigInteger e BigDecimal. Não sei quais as limitações exatas deles, mas são mais adequados para esses números grandes. No caso do C, não sei, mas acredito que haja soluções sim.
O tamanho dos tipos é um problema muito comum, presente em muitas linguagens (não digo todas pois não conheço todas). Outras linguagens podem conseguir trabalhar com números maiores, como Python.
Se é um exercício (e não é para entregar), considere isso como uma lição aprendida: há limitações na capacidade de armazenamento dos tipos.
Abraço.
1 curtida
Grupocodenome além dos problemas dos tipos primitivos que o TerraSkilll falou também tem alguns erros no seu código. Eu refiz aqui e deu pra calcular somente as 8 primeiras aproximações do valor de seno de 1.
Vamos aos erros:
-
Um dos erros do seu algoritmo está dentro do while. Os calculos das variáveis resultadoPositivo e resultadoNegativo você está perdendo, ficando armazenado somente o calculo atual.
-
Outro erro está na atualização da variável contador2 que está somando 3 o certo seria somar 4.
-
Altere também o tipo do parâmetro na função calculaFatorial para float, pois as variáveis contador1 e contador2 são do tipo float.
Segue o código alterado.
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
float calculaFatorial(float x) {
int i;
int fatorial = 1;
for(i = 1; i <= x; i++) {
fatorial *= i;
}
return fatorial;
}
int main() {
//Contador dos 30 termos a serem calculados
int i = 8;
//Valores se seno de X e resultados dos operadores
float senX = 0;
float resultadoPositivo = 0;
float resultadoNegativo = 0;
float x;
float contador1 = 1;
float contador2 = 3;
x = 1;
while(i != 0) {
resultadoPositivo += (pow(x, contador1)) / (calculaFatorial(contador1));
resultadoNegativo += -((pow(x, contador2)) / (calculaFatorial(contador2)));
contador1 += 4;
contador2 += 4;
i--;
}
senX = resultadoPositivo + resultadoNegativo;
printf("SenX: %f\n", senX);
return 0;
}
Abraço
1 curtida