Cómo Aproximar una Integral Usando la Regla del Trapecio en C

Introducción

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.

Definir f(x) y el Intervalo [a,b]

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.c

Ahora, 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_approximation

Salida de ejemplo:

Aproximación de la Integral
Función: f(x) = x^2
Intervalo: [0.00, 1.00]

En este código, hemos definido:

Una función f(x) que devuelve x^2
Un intervalo [a, b] de 0 a 1
Imprimido los detalles de la función y el intervalo

La función f(x) puede modificarse para representar cualquier función matemática que desee integrar.

Dividir el Intervalo y Aplicar la Fórmula del Trapecio

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.c

Reemplaza 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_approximation

Salida 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.333333

Puntos clave de esta implementación:

La función trapezoidalRule() calcula la integral aproximada.
h representa la anchura de cada trapecio.
n determina el número de trapecios para la aproximación.
Aumentar n mejora la precisión de la aproximación.

Imprimir la Integral Aproximada

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.c

Modifica 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_approximation

Salida 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:

Se agregó la función exactIntegral() para comparar el resultado numérico.
Se calcularon los errores absoluto y porcentual.
Se proporcionó una salida más detallada y formateada.

Resumen

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.