Neste laboratório, aprenderemos a aproximar uma integral utilizando a regra do trapézio em C. O laboratório cobre os seguintes passos: 1) definir a função f(x) e o intervalo [a, b], 2) dividir o intervalo e aplicar a fórmula do trapézio para calcular a integral aproximada, e 3) imprimir o resultado final. Este laboratório tem como objetivo fornecer uma compreensão prática de técnicas de integração numérica utilizando a linguagem de programação C.
Neste passo, definiremos a função matemática f(x) e especificaremos o intervalo [a,b] para a integração numérica utilizando a regra do trapézio em C.
Primeiro, vamos criar um novo ficheiro de origem C para implementar a nossa aproximação da integral:
cd ~/project
nano integral_approximation.cAgora, vamos escrever o código inicial para definir a nossa função e intervalo:
#include <stdio.h>
#include <math.h>
// Definir a função a integrar f(x)
double f(double x) {
// Exemplo: f(x) = x^2
return x * x;
}
int main() {
// Definir o intervalo [a, b]
double a = 0.0; // Limite inferior
double b = 1.0; // Limite superior
printf("Aproximação da Integral\n");
printf("Função: f(x) = x^2\n");
printf("Intervalo: [%.2f, %.2f]\n", a, b);
return 0;
}Vamos compilar e executar o código para verificar:
gcc -o integral_approximation integral_approximation.c -lm
./integral_approximationSaída de exemplo:
Aproximação da Integral
Função: f(x) = x^2
Intervalo: [0.00, 1.00]Neste código, definimos:
f(x) que retorna x^2A função f(x) pode ser modificada para representar qualquer função matemática que se deseje integrar.
Neste passo, modificaremos o nosso código anterior para implementar a regra do trapézio para integração numérica, dividindo o intervalo e calculando a integral aproximada.
Abra o ficheiro de origem anterior e atualize o código:
cd ~/project
nano integral_approximation.cSubstitua o conteúdo pelo seguinte:
#include <stdio.h>
#include <math.h>
// Definir a função a integrar f(x)
double f(double x) {
return x * x;
}
// Implementação da Regra do Trapézio
double trapezoidalRule(double a, double b, int n) {
double h = (b - a) / n; // Largura de cada trapézio
double sum = 0.5 * (f(a) + f(b)); // Primeiros e últimos pontos
for (int i = 1; i < n; i++) {
double x = a + i * h;
sum += f(x);
}
return sum * h;
}
int main() {
// Definir o intervalo [a, b]
double a = 0.0; // Limite inferior
double b = 1.0; // Limite superior
int n = 100; // Número de trapézios
double integralAproximada = trapezoidalRule(a, b, n);
printf("Aproximação da Integral\n");
printf("Função: f(x) = x^2\n");
printf("Intervalo: [%.2f, %.2f]\n", a, b);
printf("Número de Trapézios: %d\n", n);
printf("Integral Aproximada: %.6f\n", integralAproximada);
return 0;
}Compile e execute o código atualizado:
gcc -o integral_approximation integral_approximation.c -lm
./integral_approximationSaída de exemplo:
Aproximação da Integral
Função: f(x) = x^2
Intervalo: [0.00, 1.00]
Número de Trapézios: 100
Integral Aproximada: 0.333333Pontos chave desta implementação:
trapezoidalRule() calcula a integral aproximadah representa a largura de cada trapézion determina o número de trapézios para a aproximaçãon melhora a precisão da aproximaçãoNeste passo, melhoraremos o nosso programa de aproximação da integral, adicionando mais detalhes à saída e comparando o resultado numérico com o valor da integral exata.
Abra o ficheiro de origem anterior e atualize o código:
cd ~/project
nano integral_approximation.cModifique o código para incluir uma saída mais completa:
#include <stdio.h>
#include <math.h>
// Definir a função a integrar f(x)
double f(double x) {
return x * x;
}
// Cálculo da integral exata para x^2 de 0 a 1
double exactIntegral() {
return 1.0 / 3.0;
}
// Implementação da Regra do Trapézio
double trapezoidalRule(double a, double b, int n) {
double h = (b - a) / n; // Largura de cada trapézio
double sum = 0.5 * (f(a) + f(b)); // Primeiros e últimos pontos
for (int i = 1; i < n; i++) {
double x = a + i * h;
sum += f(x);
}
return sum * h;
}
int main() {
// Definir o intervalo [a, b]
double a = 0.0; // Limite inferior
double b = 1.0; // Limite superior
int n = 100; // Número de trapézios
double integralAproximada = trapezoidalRule(a, b, n);
double exata = exactIntegral();
double erroAbsoluto = fabs(integralAproximada - exata);
double erroPercentual = (erroAbsoluto / exata) * 100.0;
// Saída formatada com informações detalhadas
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 Trapézios: %d\n", n);
printf("\nResultados Numéricos:\n");
printf("Integral Aproximada: %.6f\n", integralAproximada);
printf("Integral Exata: %.6f\n", exata);
printf("\nAnálise de Erro:\n");
printf("Erro Absoluto: %.6f\n", erroAbsoluto);
printf("Erro Percentual: %.4f%%\n", erroPercentual);
return 0;
}Compile e execute o código atualizado:
gcc -o integral_approximation integral_approximation.c -lm
./integral_approximationSaída de exemplo:
Resultados da Aproximação da Integral
-------------------------------------
Função: f(x) = x^2
Intervalo: [0.00, 1.00]
Número de Trapézios: 100
Resultados Numéricos:
Integral Aproximada: 0.333333
Integral Exata: 0.333333
Análise de Erro:
Erro Absoluto: 0.000000
Erro Percentual: 0.0000%Melhorias chave nesta versão:
exactIntegral() para comparar o resultado numérico.Neste laboratório, aprendemos a aproximar uma integral utilizando a regra do trapézio em C. Primeiro, definimos a função matemática f(x) e o intervalo [a, b] para a integração numérica. Em seguida, implementamos a regra do trapézio dividindo o intervalo e aplicando a fórmula para calcular a integral aproximada. Finalmente, imprimimos o resultado da aproximação da integral.
Os passos-chave deste laboratório foram a definição da função e do intervalo, a divisão do intervalo e a aplicação da fórmula do trapézio para calcular a integral aproximada. Seguindo estes passos, conseguimos implementar uma técnica simples e eficaz de integração numérica em C.
