Python para Integrais

Neste capítulo, o Python será usado para calcular valores de funções em pontos igualmente espaçados, montar pesos das regras numéricas e somar os termos das fórmulas de integração. Como a introdução ao Python já apresentou funções, listas e NumPy, aqui o foco será estruturar malhas, validar regras e escrever fórmulas compostas de forma reutilizável.

Definindo a função integranda

A função integranda deve ser escrita de forma compatível com o tipo de cálculo que será usado. Se quisermos avaliar vários pontos ao mesmo tempo com NumPy, usamos operações e funções vetorizadas:

import numpy as np

def f(x):
    return x**2 + 3*x - 2

print(f(np.array([1.0, 1.5, 2.0])))

Quando a expressão usa raiz, exponencial ou funções trigonométricas e será aplicada a vetores, use as funções de NumPy:

def f(x):
    return -np.sqrt(x / np.cos(x)) + 5

Cálculo do passo

Nas regras compostas, dividimos o intervalo \([a,b]\) em subintervalos. O passo é calculado por:

a = 1
b = 3
n = 4

h = (b - a) / n
print(h)

Gerando os pontos

Depois de calcular \(h\), podemos gerar os pontos \(x_i\) com np.linspace. Para \(n\) subintervalos, precisamos de \(n+1\) pontos:

x = np.linspace(a, b, n + 1)
y = f(x)

print(x)
print(y)

Essa forma reduz o risco de erro no último ponto do intervalo e deixa o cálculo dos valores de \(f(x_i)\) concentrado em uma única linha.

Somatórios com pesos

As regras dos Trapézios e de Simpson usam pesos diferentes para cada ponto. Podemos guardar os pesos em um vetor e multiplicar todos os termos de uma vez:

pesos = np.array([1, 2, 2, 2, 1], dtype=float)
produto = np.sum(pesos * y)

integral = h/2 * produto
print(integral)

Para a primeira regra de Simpson, os pesos alternam entre 4 e 2 nos pontos internos:

pesos = np.ones(n + 1)
pesos[1:n:2] = 4
pesos[2:n:2] = 2

A primeira regra de Simpson exige que \(n\) seja par. Essa condição pode ser verificada antes do cálculo:

if n % 2 != 0:
    raise ValueError("A primeira regra de Simpson exige n par")

Funções reutilizáveis para regras compostas

Para evitar repetir a mesma estrutura em vários exemplos, podemos criar uma função para a regra dos Trapézios composta:

def trapezios_composta(f, a, b, n):
    x = np.linspace(a, b, n + 1)
    y = f(x)
    h = (b - a) / n

    pesos = np.ones(n + 1)
    pesos[1:n] = 2

    return h/2 * np.sum(pesos * y)

Atividade

Para \(a=0\), \(b=2\) e \(n=4\), gere os pontos com np.linspace, calcule os valores de \(f(x)=x^2+1\), monte os pesos da regra dos Trapézios e calcule a aproximação da integral.