Introducción
En este laboratorio, exploraremos cómo aproximar la constante matemática e utilizando su expansión en serie en C. La serie para e se define como la suma de los recíprocos de los factoriales: e = 1 + 1/1! + 1/2! + 1/3! + ... Primero crearemos un programa en C para calcular esta aproximación de la serie, y luego lo modificaremos para sumar los términos hasta alcanzar un nivel de precisión deseado. Esto nos permite controlar la precisión de nuestro cálculo y obtener una aproximación más precisa de e.
Uso de e = ∑(1/n!)
En este paso, exploraremos cómo aproximar la constante matemática e utilizando su expansión en serie en C. La serie para e se define como la suma de los recíprocos de los factoriales: e = 1 + 1/1! + 1/2! + 1/3! + ...
Primero, creemos un programa en C para calcular esta aproximación de la serie. Abre un nuevo archivo en el directorio del proyecto:
cd ~/project
nano e_approximation.c
Ahora, introduce el siguiente código C:
#include <stdio.h>
double factorial(int n) {
if (n == 0 || n == 1) return 1;
double result = 1;
for (int i = 2; i <= n; i++) {
result *= i;
}
return result;
}
double approximate_e(int terms) {
double e = 0;
for (int n = 0; n < terms; n++) {
e += 1.0 / factorial(n);
}
return e;
}
int main() {
int num_terms = 10;
double e_approximation = approximate_e(num_terms);
printf("Aproximación de e con %d términos: %f\n", num_terms, e_approximation);
return 0;
}
Ahora, compilemos y ejecutemos el programa:
gcc e_approximation.c -o e_approximation
./e_approximation
Salida de ejemplo:
Aproximación de e con 10 términos: 2.718282
Sumar Términos Hasta Alcanzar la Precisión Deseada
En este paso, modificaremos nuestro programa anterior para calcular la aproximación de e sumando términos hasta alcanzar un nivel de precisión deseado. Este enfoque nos permite controlar la precisión del cálculo.
Actualicemos el archivo C anterior:
cd ~/project
nano e_approximation.c
Reemplaza el contenido anterior con el siguiente código mejorado:
#include <stdio.h>
#include <math.h>
double factorial(int n) {
if (n == 0 || n == 1) return 1;
double result = 1;
for (int i = 2; i <= n; i++) {
result *= i;
}
return result;
}
double approximate_e_with_accuracy(double desired_accuracy) {
double e = 0;
double term = 1;
int n = 0;
while (fabs(term) > desired_accuracy) {
e += term;
n++;
term = 1.0 / factorial(n);
}
return e;
}
int main() {
double accuracy = 1e-6; // Nivel de precisión deseado
double e_approximation = approximate_e_with_accuracy(accuracy);
printf("Aproximación de e con precisión %e: %f\n", accuracy, e_approximation);
printf("Valor estándar de e de math.h: %f\n", M_E);
return 0;
}
Compila y ejecuta el programa actualizado:
gcc e_approximation.c -o e_approximation -lm
./e_approximation
Salida de ejemplo:
Aproximación de e con precisión 1.000000e-06: 2.718282
Valor estándar de e de math.h: 2.718282
Esta versión del programa continúa agregando términos a la serie hasta que el siguiente término sea menor que el umbral de precisión especificado. La función fabs() asegura que trabajemos con el valor absoluto del término.
Puntos clave a tener en cuenta:
- Usamos
1e-6como nuestro nivel de precisión deseado. - El programa determina dinámicamente cuántos términos son necesarios.
- Comparamos nuestra aproximación con el valor estándar de e de la biblioteca matemática.
Imprimir la Aproximación
En este paso final, mejoraremos nuestro programa para imprimir la aproximación de e con diferentes niveles de precisión y proporcionar una salida más detallada.
Actualiza el archivo C una vez más:
cd ~/project
nano e_approximation.c
Reemplaza el contenido anterior con el siguiente código completo:
#include <stdio.h>
#include <math.h>
double factorial(int n) {
if (n == 0 || n == 1) return 1;
double result = 1;
for (int i = 2; i <= n; i++) {
result *= i;
}
return result;
}
void print_e_approximations() {
double accuracies[] = {1e-1, 1e-3, 1e-6, 1e-9};
int num_accuracies = sizeof(accuracies) / sizeof(accuracies[0]);
printf("Aproximaciones de e con diferentes niveles de precisión:\n");
printf("---------------------------------------------\n");
for (int i = 0; i < num_accuracies; i++) {
double e = 0;
double term = 1;
int n = 0;
int terms_used = 0;
while (fabs(term) > accuracies[i]) {
e += term;
n++;
term = 1.0 / factorial(n);
terms_used++;
}
printf("Precisión: %e\n", accuracies[i]);
printf("Aproximación: %.10f\n", e);
printf("Términos Usados: %d\n", terms_used);
printf("Diferencia con el valor de e de math.h: %.10f\n\n", fabs(e - M_E));
}
}
int main() {
print_e_approximations();
return 0;
}
Compila y ejecuta el programa:
gcc e_approximation.c -o e_approximation -lm
./e_approximation
Salida de ejemplo:
Aproximaciones de e con diferentes niveles de precisión:
---------------------------------------------
Precisión: 1.000000e-01
Aproximación: 2.7000000000
Términos Usados: 4
Diferencia con el valor de e de math.h: 0.0182818284
Precisión: 1.000000e-03
Aproximación: 2.7182500000
Términos Usados: 8
Diferencia con el valor de e de math.h: 0.0000318284
Precisión: 1.000000e-06
Aproximación: 2.7182818000
Términos Usados: 14
Diferencia con el valor de e de math.h: 0.0000000284
Precisión: 1.000000e-09
Aproximación: 2.7182818285
Términos Usados: 21
Diferencia con el valor de e de math.h: 0.0000000000
Mejoras clave en esta versión:
- Imprime aproximaciones a múltiples niveles de precisión.
- Muestra el número de términos utilizados para cada aproximación.
- Calcula y muestra la diferencia con el valor estándar de e de la biblioteca matemática.
Resumen
En este laboratorio, aprendimos a aproximar la constante matemática e utilizando su expansión en serie en C. Primero implementamos una función para calcular el factorial de un número, y luego la utilizamos para calcular la aproximación de e sumando los términos de la serie hasta un número deseado de términos. Posteriormente, modificamos el programa para continuar sumando los términos hasta alcanzar un nivel de precisión deseado, lo que nos permite controlar la precisión del cálculo. El programa final imprime la aproximación de e con la precisión deseada.
