Como Aproximar uma Integral Usando a Regra de Simpson em C

Introdução

Neste laboratório, aprenderá a aproximar uma integral usando a Regra de Simpson em C. O laboratório cobre o processo passo a passo de definir a função a integrar, o intervalo de integração e, em seguida, implementar o algoritmo da Regra de Simpson para calcular a integral aproximada. No final deste laboratório, terá um programa C funcional que pode integrar numericamente uma função dada num intervalo especificado usando o método da Regra de Simpson.

O laboratório consiste em duas etapas principais: definir a função e o intervalo e, em seguida, usar a Regra de Simpson com subintervalos pares para calcular a integral aproximada. Este exercício prático ajudará a ganhar experiência prática na aplicação de técnicas de integração numérica na programação em C.

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

Nesta etapa, configuraremos os componentes fundamentais para implementar a Regra de Simpson para integração numérica em C. Definiremos a função a integrar e especificaremos o intervalo de integração.

Primeiro, crie um novo arquivo C no diretório ~/project:

cd ~/project
nano simpson_integration.c

Agora, vamos escrever o código inicial para definir nossa função e intervalo:

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

// Função a integrar: f(x) = x^2
double f(double x) {
    return x * x;
}

int main() {
    // Definir o intervalo de integração [a, b]
    double a = 0.0;  // Limite inferior
    double b = 1.0;  // Limite superior

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

    return 0;
}

Vamos analisar o código:

Incluímos os cabeçalhos necessários: stdio.h para entrada/saída e math.h para funções matemáticas.
f(x) é definida como uma função quadrática simples x^2, que integraremos.
Em main(), definimos o intervalo de integração de 0 a 1.
Imprimimos o intervalo para maior clareza.

Compile e execute o código para verificar:

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

Saída de exemplo:

Integrando f(x) = x^2 de 0.000000 a 1.000000

Usar a Regra de Simpson com Subintervalos Pares

Nesta etapa, implementaremos o algoritmo da Regra de Simpson para aproximar a integral definida da nossa função. Adicionaremos a função de integração ao nosso programa C existente.

Abra o arquivo anterior:

cd ~/project
nano simpson_integration.c

Atualize o código para incluir a implementação da Regra de Simpson:

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

// Função a integrar: f(x) = x^2
double f(double x) {
    return x * x;
}

// Implementação da Regra de Simpson
double simpsons_rule(double a, double b, int n) {
    double h = (b - a) / n;  // Largura de cada subintervalo
    double sum = f(a) + f(b);  // Primeiro e último pontos

    // Calcula a soma dos pontos pares e ímpares
    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 o intervalo de integração [a, b]
    double a = 0.0;  // Limite inferior
    double b = 1.0;  // Limite superior
    int n = 100;     // Número de subintervalos (deve ser par)

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

    printf("Integral de f(x) = x^2 de %f a %f\n", a, b);
    printf("Aproximação usando a Regra de Simpson com %d subintervalos: %f\n", n, integral);

    return 0;
}

Compile e execute o código:

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

Saída de exemplo:

Integral de f(x) = x^2 de 0.000000 a 1.000000
Aproximação usando a Regra de Simpson com 100 subintervalos: 0.333333

Vamos analisar a implementação da Regra de Simpson:

simpsons_rule() recebe os limites do intervalo e o número de subintervalos.
h calcula a largura de cada subintervalo.
Iniciamos com o primeiro e o último ponto do intervalo.
O loop adiciona contribuições ponderadas dos pontos intermediários.
Pontos pares são multiplicados por 2, pontos ímpares por 4.
O resultado final é escalado por h/3.

Imprimir a Integral Aproximada

Nesta etapa final, aprimoraremos a implementação da Regra de Simpson adicionando um resultado mais detalhado e comparando a aproximação numérica com o valor exato da integral.

Abra o arquivo anterior:

cd ~/project
nano simpson_integration.c

Atualize o código para incluir um resultado mais abrangente:

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

// Função a integrar: f(x) = x^2
double f(double x) {
    return x * x;
}

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

// Implementação da Regra de Simpson
double simpsons_rule(double a, double b, int n) {
    double h = (b - a) / n;  // Largura de cada subintervalo
    double sum = f(a) + f(b);  // Primeiro e último pontos

    // Calcula a soma dos pontos pares e ímpares
    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 o intervalo de integração [a, b]
    double a = 0.0;  // Limite inferior
    double b = 1.0;  // Limite superior
    int n = 100;     // Número de subintervalos (deve ser par)

    // Calcular a aproximação e a integral exata
    double approx_integral = simpsons_rule(a, b, n);
    double exact_value = exact_integral(a, b);
    double error = fabs(exact_value - approx_integral);

    // Imprimir resultados detalhados
    printf("Resultados da Aproximação da Integral:\n");
    printf("------------------------------\n");
    printf("Função: f(x) = x^2\n");
    printf("Intervalo: [%.2f, %.2f]\n", a, b);
    printf("Número de Subintervalos: %d\n\n", n);

    printf("Aproximação (Regra de Simpson): %.6f\n", approx_integral);
    printf("Valor Exato: %.6f\n", exact_value);
    printf("Erro Absoluto: %.6f\n", error);
    printf("Erro Relativo: %.4f%%\n", (error / exact_value) * 100);

    return 0;
}

Compile e execute o código:

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

Saída de exemplo:

Resultados da Aproximação da Integral:
------------------------------
Função: f(x) = x^2
Intervalo: [0.00, 1.00]
Número de Subintervalos: 100

Aproximação (Regra de Simpson): 0.333333
Valor Exato: 0.333333
Erro Absoluto: 0.000000
Erro Relativo: 0.0000%

Adições-chave nesta etapa:

Adicionada a função exact_integral() para calcular o valor verdadeiro da integral.
Calculado o erro absoluto e relativo.
Criado um resultado formatado mostrando os resultados detalhados da integração.

Resumo

Neste laboratório, definimos inicialmente a função a integrar, f(x) = x^2, e o intervalo de integração [a, b] = [0, 1]. Em seguida, implementamos o algoritmo da Regra de Simpson para aproximar a integral definida da função. A Regra de Simpson envolve dividir o intervalo em um número par de subintervalos e calcular a soma ponderada dos valores da função nos pontos finais e pontos médios desses subintervalos. Finalmente, imprimiremos o valor aproximado da integral obtido usando a Regra de Simpson.