En este laboratorio, aprenderemos a aproximar una integral utilizando la regla del trapecio en C. El laboratorio cubre los siguientes pasos: 1) definir la función f(x) y el intervalo [a, b], 2) dividir el intervalo y aplicar la fórmula del trapecio para calcular la integral aproximada, y 3) imprimir el resultado final. Este laboratorio tiene como objetivo proporcionar una comprensión práctica de las técnicas de integración numérica utilizando el lenguaje de programación C.
En este paso, definiremos la función matemática f(x) y especificaremos el intervalo [a,b] para la integración numérica utilizando la regla del trapecio en C.
Primero, creemos un nuevo archivo fuente C para implementar nuestra aproximación de la integral:
cd ~/project
nano integral_approximation.cAhora, escribamos el código inicial para definir nuestra función e intervalo:
#include <stdio.h>
#include <math.h>
// Definir la función a integrar f(x)
double f(double x) {
// Ejemplo: f(x) = x^2
return x * x;
}
int main() {
// Definir el intervalo [a, b]
double a = 0.0; // Límite inferior
double b = 1.0; // Límite superior
printf("Aproximación de la Integral\n");
printf("Función: f(x) = x^2\n");
printf("Intervalo: [%.2f, %.2f]\n", a, b);
return 0;
}Compilemos y ejecutemos el código para verificar:
gcc -o integral_approximation integral_approximation.c -lm
./integral_approximationSalida de ejemplo:
Aproximación de la Integral
Función: f(x) = x^2
Intervalo: [0.00, 1.00]En este código, hemos definido:
f(x) que devuelve x^2La función f(x) puede modificarse para representar cualquier función matemática que desee integrar.
En este paso, modificaremos nuestro código anterior para implementar la regla del trapecio para la integración numérica dividiendo el intervalo y calculando la integral aproximada.
Abre el archivo fuente anterior y actualiza el código:
cd ~/project
nano integral_approximation.cReemplaza el contenido con la siguiente implementación:
#include <stdio.h>
#include <math.h>
// Definir la función a integrar f(x)
double f(double x) {
return x * x;
}
// Implementación de la Regla del Trapecio
double trapezoidalRule(double a, double b, int n) {
double h = (b - a) / n; // Anchura de cada trapecio
double sum = 0.5 * (f(a) + f(b)); // Primeros y últimos puntos
for (int i = 1; i < n; i++) {
double x = a + i * h;
sum += f(x);
}
return sum * h;
}
int main() {
// Definir el intervalo [a, b]
double a = 0.0; // Límite inferior
double b = 1.0; // Límite superior
int n = 100; // Número de trapecios
double approximateIntegral = trapezoidalRule(a, b, n);
printf("Aproximación de la Integral\n");
printf("Función: f(x) = x^2\n");
printf("Intervalo: [%.2f, %.2f]\n", a, b);
printf("Número de Trapecios: %d\n", n);
printf("Integral Aproximada: %.6f\n", approximateIntegral);
return 0;
}Compila y ejecuta el código actualizado:
gcc -o integral_approximation integral_approximation.c -lm
./integral_approximationSalida de ejemplo:
Aproximación de la Integral
Función: f(x) = x^2
Intervalo: [0.00, 1.00]
Número de Trapecios: 100
Integral Aproximada: 0.333333Puntos clave de esta implementación:
trapezoidalRule() calcula la integral aproximada.h representa la anchura de cada trapecio.n determina el número de trapecios para la aproximación.n mejora la precisión de la aproximación.En este paso, mejoraremos nuestro programa de aproximación de integrales agregando una salida más detallada y comparando el resultado numérico con el valor exacto de la integral.
Abre el archivo fuente anterior y actualiza el código:
cd ~/project
nano integral_approximation.cModifica el código para incluir una salida más completa:
#include <stdio.h>
#include <math.h>
// Definir la función a integrar f(x)
double f(double x) {
return x * x;
}
// Cálculo de la integral exacta para x^2 de 0 a 1
double exactIntegral() {
return 1.0 / 3.0;
}
// Implementación de la Regla del Trapecio
double trapezoidalRule(double a, double b, int n) {
double h = (b - a) / n; // Anchura de cada trapecio
double sum = 0.5 * (f(a) + f(b)); // Primeros y últimos puntos
for (int i = 1; i < n; i++) {
double x = a + i * h;
sum += f(x);
}
return sum * h;
}
int main() {
// Definir el intervalo [a, b]
double a = 0.0; // Límite inferior
double b = 1.0; // Límite superior
int n = 100; // Número de trapecios
double approximateIntegral = trapezoidalRule(a, b, n);
double exact = exactIntegral();
double error = fabs(approximateIntegral - exact);
double percentError = (error / exact) * 100.0;
// Salida formateada con información detallada
printf("Resultados de la Aproximación de la Integral\n");
printf("------------------------------\n");
printf("Función: f(x) = x^2\n");
printf("Intervalo: [%.2f, %.2f]\n", a, b);
printf("Número de Trapecios: %d\n", n);
printf("\nResultados Numéricos:\n");
printf("Integral Aproximada: %.6f\n", approximateIntegral);
printf("Integral Exacta: %.6f\n", exact);
printf("\nAnálisis de Error:\n");
printf("Error Absoluto: %.6f\n", error);
printf("Error Porcentual: %.4f%%\n", percentError);
return 0;
}Compila y ejecuta el código actualizado:
gcc -o integral_approximation integral_approximation.c -lm
./integral_approximationSalida de ejemplo:
Resultados de la Aproximación de la Integral
------------------------------
Función: f(x) = x^2
Intervalo: [0.00, 1.00]
Número de Trapecios: 100
Resultados Numéricos:
Integral Aproximada: 0.333333
Integral Exacta: 0.333333
Análisis de Error:
Error Absoluto: 0.000000
Error Porcentual: 0.0000%Mejoras clave en esta versión:
exactIntegral() para comparar el resultado numérico.En este laboratorio, aprendimos a aproximar una integral utilizando la regla del trapecio en C. Primero, definimos la función matemática f(x) y el intervalo [a, b] para la integración numérica. Luego, implementamos la regla del trapecio dividiendo el intervalo y aplicando la fórmula para calcular la integral aproximada. Finalmente, imprimimos el resultado de la aproximación de la integral.
Los pasos clave en este laboratorio fueron definir la función y el intervalo, dividir el intervalo y aplicar la fórmula del trapecio para calcular la integral aproximada. Siguiendo estos pasos, pudimos implementar una técnica de integración numérica simple y efectiva en C.
