Cómo Aproximar una Integral Usando la Regla de Simpson en C

Introducción

En este laboratorio, aprenderás a aproximar una integral utilizando la Regla de Simpson en C. El laboratorio cubre el proceso paso a paso de definir la función a integrar, el intervalo de integración y luego implementar el algoritmo de la Regla de Simpson para calcular la integral aproximada. Al final de este laboratorio, tendrás un programa C funcional que puede integrar numéricamente una función dada en un intervalo especificado utilizando el método de la Regla de Simpson.

El laboratorio consta de dos pasos principales: definir la función y el intervalo, y luego utilizar la Regla de Simpson con subintervalos pares para calcular la integral aproximada. Este ejercicio práctico te ayudará a obtener experiencia práctica en la aplicación de técnicas de integración numérica en la programación en C.

Definir f(x) e Intervalo [a, b]

En este paso, configuraremos los componentes fundamentales para implementar la Regla de Simpson para la integración numérica en C. Definiremos la función a integrar y especificaremos el intervalo de integración.

Primero, creemos un nuevo archivo C en el directorio ~/project:

cd ~/project
nano simpson_integration.c

Ahora, escribamos el código inicial para definir nuestra función e intervalo:

#include <stdio.h>
#include <math.h>

// Función a integrar: f(x) = x^2
double f(double x) {
    return x * x;
}

int main() {
    // Definir el intervalo de integración [a, b]
    double a = 0.0;  // Límite inferior
    double b = 1.0;  // Límite superior

    printf("Integrando f(x) = x^2 desde %f hasta %f\n", a, b);

    return 0;
}

Analicemos el código:

Incluimos los encabezados necesarios: stdio.h para entrada/salida y math.h para funciones matemáticas.
f(x) se define como una función cuadrática simple x^2, que integraremos.
En main(), establecemos el intervalo de integración de 0 a 1.
Imprimimos el intervalo para mayor claridad.

Compila y ejecuta el código para verificar:

gcc simpson_integration.c -o simpson_integration -lm
./simpson_integration

Salida de ejemplo:

Integrando f(x) = x^2 desde 0.000000 hasta 1.000000

Usar la Regla de Simpson con Subintervalos Pares

En este paso, implementaremos el algoritmo de la Regla de Simpson para aproximar la integral definida de nuestra función. Añadiremos la función de integración a nuestro programa C existente.

Abre el archivo anterior:

cd ~/project
nano simpson_integration.c

Actualiza el código para incluir la implementación de la Regla de Simpson:

#include <stdio.h>
#include <math.h>

// Función a integrar: f(x) = x^2
double f(double x) {
    return x * x;
}

// Implementación de la Regla de Simpson
double simpsons_rule(double a, double b, int n) {
    double h = (b - a) / n;  // Anchura de cada subintervalo
    double sum = f(a) + f(b);  // Primeros y últimos puntos

    // Calcular la suma de los puntos pares e impares
    for (int i = 1; i < n; i++) {
        double x = a + i * h;
        sum += (i % 2 == 0 ? 2 : 4) * f(x);
    }

    return (h / 3) * sum;
}

int main() {
    // Definir el intervalo de integración [a, b]
    double a = 0.0;  // Límite inferior
    double b = 1.0;  // Límite superior
    int n = 100;     // Número de subintervalos (debe ser par)

    double integral = simpsons_rule(a, b, n);

    printf("Integral de f(x) = x^2 desde %f hasta %f\n", a, b);
    printf("Aproximación usando la Regla de Simpson con %d subintervalos: %f\n", n, integral);

    return 0;
}

Compila y ejecuta el código:

gcc simpson_integration.c -o simpson_integration -lm
./simpson_integration

Salida de ejemplo:

Integral de f(x) = x^2 desde 0.000000 hasta 1.000000
Aproximación usando la Regla de Simpson con 100 subintervalos: 0.333333

Analicemos la implementación de la Regla de Simpson:

simpsons_rule() recibe los límites del intervalo y el número de subintervalos.
h calcula la anchura de cada subintervalo.
Comenzamos con los primeros y últimos puntos del intervalo.
El bucle suma las contribuciones ponderadas de los puntos intermedios.
Los puntos pares se multiplican por 2, los impares por 4.
El resultado final se escala por h/3.

Imprimir la Aproximación de la Integral

En este paso final, mejoraremos nuestra implementación de la Regla de Simpson agregando una salida más detallada y comparando la aproximación numérica con el valor exacto de la integral.

Abre el archivo anterior:

cd ~/project
nano simpson_integration.c

Actualiza el código para incluir una salida más completa:

#include <stdio.h>
#include <math.h>

// Función a integrar: f(x) = x^2
double f(double x) {
    return x * x;
}

// Cálculo de la integral exacta para f(x) = x^2 desde a hasta b
double exact_integral(double a, double b) {
    return (pow(b, 3) - pow(a, 3)) / 3.0;
}

// Implementación de la Regla de Simpson
double simpsons_rule(double a, double b, int n) {
    double h = (b - a) / n;  // Anchura de cada subintervalo
    double sum = f(a) + f(b);  // Primeros y últimos puntos

    // Calcular la suma de los puntos pares e impares
    for (int i = 1; i < n; i++) {
        double x = a + i * h;
        sum += (i % 2 == 0 ? 2 : 4) * f(x);
    }

    return (h / 3) * sum;
}

int main() {
    // Definir el intervalo de integración [a, b]
    double a = 0.0;  // Límite inferior
    double b = 1.0;  // Límite superior
    int n = 100;     // Número de subintervalos (debe ser par)

    // Calcular la aproximación y la integral exacta
    double approx_integral = simpsons_rule(a, b, n);
    double exact_value = exact_integral(a, b);
    double error = fabs(exact_value - approx_integral);

    // Imprimir resultados detallados
    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 Subintervalos: %d\n\n", n);

    printf("Aproximación (Regla de Simpson): %.6f\n", approx_integral);
    printf("Valor Exacto: %.6f\n", exact_value);
    printf("Error Absoluto: %.6f\n", error);
    printf("Error Relativo: %.4f%%\n", (error / exact_value) * 100);

    return 0;
}

Compila y ejecuta el código:

gcc simpson_integration.c -o simpson_integration -lm
./simpson_integration

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 Subintervalos: 100

Aproximación (Regla de Simpson): 0.333333
Valor Exacto: 0.333333
Error Absoluto: 0.000000
Error Relativo: 0.0000%

Adiciones clave en este paso:

Se agregó la función exact_integral() para calcular el valor real de la integral.
Se calcularon el error absoluto y relativo.
Se creó una salida formateada que muestra los resultados detallados de la integración.

Resumen

En este laboratorio, primero definimos la función a integrar, f(x) = x^2, y el intervalo de integración [a, b] = [0, 1]. Luego, implementamos el algoritmo de la Regla de Simpson para aproximar la integral definida de la función. La Regla de Simpson implica dividir el intervalo en un número par de subintervalos y calcular la suma ponderada de los valores de la función en los puntos finales y los puntos medios de estos subintervalos. Finalmente, imprimiremos el valor aproximado de la integral obtenido utilizando la Regla de Simpson.