¿Cómo podría implementar un programa que calcule [math] e ^ x [/ math] sumando los primeros 100 términos de su expansión en serie?

Desea calcular e ^ x aproximándolo usando una serie de Taylor. El resto de su pregunta está redactada de forma difusa, pero supongo que quiere interrumpir la expansión después de n términos.

Te daré un método, pero te digo directamente que no es el mejor. Más sobre eso más tarde.

¡Puedes escribir 1 como 1/1 y luego como 1/0! ¡Incluso podría ir tan lejos para escribirlo como x ^ 0/0 !. ¡Y puedes reescribir x como x ^ 1/1 !. ¿Entonces un patrón debería ser obvio para ti?

Para cada próximo término, el numerador se multiplica por x.

El denominador se multiplica por 1, 2, 3, 4, 5, …

Aquí hay un programa C (++):

#include

#include

double aproximate_exp_x (double x, unsigned int n)

{

doble aproximación = 1;

doble nominador = 1;

sin signo largo largo denominador = 1;

double realValue = exp (x);

for (unsigned int i = 1; i <n; ++ i)

{

nominador * = x; // x ^ 1, x ^ 2, x ^ 3, …

denominador * = i; // 1 !, 2 !, 3 !, …

aproximación + = (nominador / ((doble) denominador));

// Estas líneas no son necesarias para el cálculo, sino solo para mostrar resultados:

double errAbs = fabs (realValue – aproximación);

printf (“paso =% d, aproximación =% g, ‘valor real’ =% g, error (abs) =% g, error (%%) =% g \ n”, i, aproximación, realValue, errAbs, 100.0 * errAbs / realValue);

}

aproximación de retorno;

}

int main (int argc, char * argv [])

{

doble x = 10;

aproximada_exp_x (x, 25);

printf (“Listo, presione cualquier tecla \ n”);

getchar ();

devuelve 0;

}


Puede ver que después del paso 21, el resultado ya no converge. Esto probablemente se deba a errores de redondeo.

Algunas notas

Pasé un poco de contrabando calculando previamente el término 0 e inicializando la aproximación con 1. Esto es importante cuando su maestro pregunta por el resultado después de n pasos. Mi n podría estar fuera por uno.

Sería mejor, de alguna manera mágica, hacer el ciclo en orden inverso. La razón es esta: cada próximo término debe ser más pequeño que el anterior. Si agrega un valor muy pequeño a un valor muy grande, entonces podría “perderse” debido al desplazamiento (normalización) y al redondeo. Una buena regla general para lidiar con esto sería ordenar los valores en función del valor absoluto, desde pequeños (cerca de cero) hacia arriba y agregar todos los términos en este orden. Luego sumas primero valores muy pequeños y no pierdes muchos dígitos. Dado que ‘nuestros’ valores para los términos ya están ordenados (pero al revés), podemos sumar desde el último término al revés.

Al menos para las expansiones de Taylor de seno , coseno y ln cada término siguiente se está reduciendo en comparación con el anterior, porque x está en [-1, 1] o [0, 1]. Así x ^ n se hace cada vez más pequeño mientras que el denominador se hace más y más grande.

Hay mejores formas de calcular x ^ n que n multiplicado por x. Si n es par, podemos escribir: x ^ n = (x ^ 2) ^ n / 2. Si n es impar, multiplicamos por x. Puede hacer esto de forma recursiva, o usando un ciclo iterativo que hace n = n >> 1; Esto es importante, porque el nuevo método es más rápido, y dado que hacemos menos multiplicaciones, el resultado es más preciso.

Si de alguna manera evitamos valores altos para x, tal vez podamos evitar grandes errores de redondeo. Una forma cruda de hacerlo es calcular previamente e ^ 10, e ^ 100, e ^ 1000, … Luego podemos dividir nuestra x por 10, 100 o 1000 para obtener un valor pequeño cerca de 1 o incluso cerca de 0.

También podríamos (si x> 1) calcular (e ^ x / 2) y cuadrar esto. Podemos repetir este truco recursivamente hasta que x esté cerca de cero.

Ver exponenciación

http://www.themathpage.com/alg/e…

Serie de Taylor

¡Parece tarea! Creo que la venganza apropiada es dar una solución solo en Scheme …

(let (sum-rest term xn nmax) (if (

(let (aproximadamente y exacto) (list (sum-rest 1 x 0 100) (exp x)))

(let (x-in (read)) (impresión de mapa (entrada x aproximada y exacta)))