Trabajando en código para calcular coseno con sum factorial.

He estado luchando con este código y parece que no entiendo lo que estoy haciendo mal.

Se supone que el código debe calcularse: la sum de una serie de “coseno” con patrón [(-1) ^ i (x) ^ 2i] / (2i)!

modelo

Aquí está mi código hasta ahora:

#include  #include  float factorial(int n){ if (n==0) return 1; else return 2*n*factorial(n-1); } int main (){ float i, n; float sum=0; printf("Enter desired interger: "); scanf("%f", &n); for (i=0; i<=1; i++) sum = sum + (pow(-1,i)*pow(n,2*i))/(factorial(n)); printf("The value is %f\n", sum); return 0; } 

Todavía estoy trabajando en ello, cualquier información o ayuda será muy apreciada!

editar:

Solo lo arreglaron chicos, este es el nuevo formato que tuve que usar para mi profesor:

 #include  #include  int factorial(int n) { if (n==0) return 1; else return n*factorial(n-1); } float mycos(float x) { float sum=0; int i; for (i=0;i<=10;i++) sum = sum + (pow(-1,i)*pow(x,2*i))/factorial(2*i); return sum; } int main() { int i=1; printf(" x mycos(x) cos(x)\n"); for (i=1;i<=10;i++) printf(" %f %f %f\n", i*.1, mycos(i*.1), cos(i*.1)); return 0; } 

¡Gracias a todos por sus explicaciones, ayudaron inmensamente!

Una cosa que veo, es que su bucle for en main solo se ejecuta a través de 2 iteraciones reales, una para i == 0, y otra vez para i == 1.

Para que la expansión de taylor funcione de manera bastante efectiva, debe ejecutarse a través de más términos de secuencia (más iteraciones de bucle).

Otra cosa que veo, es que tu denominador es el n! en lugar de (2 * n)!

Por eficiencia, también podría implementar la rutina factorial de la siguiente manera:

 unsigned int factorial(int n){ unsigned int product = 1; for(int I = 1; I <= n; I++) product *= I; return product; } 

La rutina factorial anterior es para un cálculo factorial más EXACTO, que quizás no necesite para este propósito. Para sus propósitos, tal vez la variante de punto flotante podría ser lo suficientemente buena.

 float factorial(int n){ float product = 1; for(int I = 1; I <= n; I++) product *= (float)I; return product; } 

También debo tener en cuenta por qué estoy diciendo que realizar factorial de esta manera. En general, una construcción de bucle será más eficiente que su contraparte recursiva. Su implementación actual es recursiva y, por lo tanto, la implementación que DEBO DEBERÍA ser un poco más eficiente tanto en rendimiento como en utilización de memoria.

Teniendo en cuenta los gastos de cálculo, debe dejar de calcular la serie en un punto. Cuanto más vaya, más preciso será el resultado, pero más tiempo pasará su progtwig. ¿Qué tal este progtwig simple?

 #include  #include  #define ITERATIONS 10 //control how far you go float factorial(int n){ if (n==0) return 1; else return n*factorial(n-1); } int main (){ float n; float sum=0; printf("Enter desired float: "); scanf("%f", &n); int c, i; for (i=0; i<=ITERATIONS; i++) { c = (i%2)==0? 1 : -1; sum = sum + (c*pow(n,2*i+1))/(factorial(2*i+1)); } printf("The value is %f\n", sum); return 0; } 

1.) Solo está multiplicando incluso no.s en la función factorial return 2*n*factorial(n-1); Solo daré incluso no.s. En su lugar, puede reemplazar n con 2n aquí: sum = sum + (pow(-1,i)*pow(n,2*i))/(factorial(2n)); Esto le dará el correcto (2n!). 2.) Verifique el no, de iteraciones for (i=0; i<=1; i++) esto solo ejecutará su bucle dos veces. Intenta más no. de iteraciones para una respuesta más precisa.

¿Por qué estás calculando el poder, etc. para cada elemento de la serie? También es necesario mantener los números en un rango adecuado para los tipos de datos

es decir, para cos

 bool neg_sign = false; float total = 1.0f; float current = 1.0f; for (int i = 0; i < length_of_series; ++i) { neg_sign = !neg_sign; current = current * (x / ((2 * i) + 1)) * (x / (( 2 * i) + 2)); total += neg_sign ? -current : current; } 

EDITAR

Por favor vea http://codepad.org/swDIh8P5

 #include # define PRECISION 10 /*the number of terms to be processed*/ main() { float x,term=1,s=1.0; int i,a=2; scanf("%f",&x); x=x*x; for(i=1;i 

Tu función factorial() realidad calcula 2 n .n! , que probablemente no sea lo que tenías en mente. Para calcular (2n)! , debe eliminar el 2* del cuerpo de la función e invocar factorial(2*n) .