Para dados ruidosos ou com estrutura fina, existem quadraturas melhores que a regra do ponto médio?

Apenas as duas primeiras seções desta longa questão são essenciais. Os outros são apenas para ilustração.

fundo

Quadraturas avançadas, como Newton-Cotes, Gauß-Legendre e Romberg, parecem ser principalmente destinadas a casos em que é possível provar a função com precisão, mas não integrar analiticamente. No entanto, para funções com estruturas mais finas que o intervalo de amostragem (consulte o Apêndice A, por exemplo) ou ruído de medição, elas não podem competir com abordagens simples, como a regra do ponto médio ou trapézio (consulte o Apêndice B para uma demonstração).

Isso é um pouco intuitivo, pois, por exemplo, a regra composta de Simpson essencialmente "descarta" um quarto da informação, atribuindo-lhe um peso menor. A única razão pela qual essas quadraturas são melhores para funções suficientemente chatas é que o manuseio adequado dos efeitos de borda supera o efeito das informações descartadas. De outro ponto de vista, é intuitivamente claro para mim que, para funções com uma estrutura ou ruído fino, as amostras que estão distantes das fronteiras do domínio de integração devem ser quase equidistantes e ter quase o mesmo peso (para um grande número de amostras). ) Por outro lado, a quadratura de tais funções pode se beneficiar de uma melhor manipulação dos efeitos de borda (do que no método do ponto médio).

Questão

Suponha que eu desejo integrar numericamente dados unidimensionais ruidosos ou bem estruturados.

O número de pontos de amostragem é fixo (devido à avaliação da função ser cara), mas posso colocá-los livremente. No entanto, eu (ou o método) não posso colocar pontos de amostragem interativamente, ou seja, com base nos resultados de outros pontos de amostragem. Também não conheço regiões com problemas em potencial de antemão. Então, algo como Gauß – Legendre (pontos de amostragem não equidistantes) está bem; A quadratura adaptativa não é uma vez que requer pontos de amostragem colocados interativamente.

• Algum método além do método do ponto médio foi sugerido para esse caso?

• Ou: Existe alguma prova de que o método do ponto médio é melhor nessas condições?

• De maneira mais geral: existe algum trabalho existente sobre esse problema?

Apêndice A: Exemplo específico de uma função bem estruturada

Desejo estimar para: come. Uma função típica é assim:$\int_0^1f(t)\, \mathrm{d}t$

$$f(t) = \sum_{i=1}^{k} \frac{\sin(ω_i t-φ_i)}{ω_i},$$ log ω i ∈[1,1000$φ_i∈ [0,2π]$$\log{ω_i} ∈ [1,1000]$

Eu escolhi essa função para as seguintes propriedades:

• Pode ser integrado analiticamente para obter um resultado de controle.
• Ele possui uma estrutura fina em um nível que torna impossível capturar tudo isso com o número de amostras que estou usando ( ).$<10^2$
• Não é dominado por sua estrutura fina.

Apêndice B: Referência

Para completar, eis uma referência no Python:

import numpy as np
from numpy.random import uniform
from scipy.integrate import simps, trapz, romb, fixed_quad

begin = 0
end   = 1

def generate_f(k,low_freq,high_freq):
    ω = 2**uniform(np.log2(low_freq),np.log2(high_freq),k)
    φ = uniform(0,2*np.pi,k)
    g = lambda t,ω,φ: np.sin(ω*t-φ)/ω
    G = lambda t,ω,φ: np.cos(ω*t-φ)/ω**2
    f = lambda t: sum( g(t,ω[i],φ[i]) for i in range(k) )
    control = sum( G(begin,ω[i],φ[i])-G(end,ω[i],φ[i]) for i in range(k) )
    return control,f

def midpoint(f,n):
    midpoints = np.linspace(begin,end,2*n+1)[1::2]
    assert len(midpoints)==n
    return np.mean(f(midpoints))*(n-1)

def evaluate(n,control,f):
    """
    returns the relative errors when integrating f with n evaluations
    for several numerical integration methods.
    """
    times = np.linspace(begin,end,n)
    values = f(times)
    results = [
            midpoint(f,n),
            trapz(values),
            simps(values),
            romb (values),
            fixed_quad(f,begin,end,n=n)[0]*(n-1),
        ]

    return [
            abs((result/(n-1)-control)/control)
            for result in results
        ]

method_names = ["midpoint","trapezoid","Simpson","Romberg","Gauß–Legendre"]

def med(data):
    medians = np.median(np.vstack(data),axis=0)
    for median,name in zip(medians,method_names):
        print(f"{median:.3e}   {name}")

print("superimposed sines")
med(evaluate(33,*generate_f(10,1,1000)) for _ in range(100000))

print("superimposed low-frequency sines (control)")
med(evaluate(33,*generate_f(10,0.5,1.5)) for _ in range(100000))

(Utilizo aqui a mediana para reduzir a influência de valores discrepantes devido a funções que possuem apenas conteúdo de alta frequência. Para a média, os resultados são semelhantes.)

As medianas dos erros relativos de integração são:

superimposed sines
6.301e-04   midpoint
8.984e-04   trapezoid
1.158e-03   Simpson
1.537e-03   Romberg
1.862e-03   Gauß–Legendre

superimposed low-frequency sines (control)
2.790e-05   midpoint
5.933e-05   trapezoid
5.107e-09   Simpson
3.573e-16   Romberg
3.659e-16   Gauß–Legendre

Nota: Após dois meses e uma recompensa sem resultado, publiquei isso no MathOverflow .

Primeiro de tudo, acho que você não entende o conceito de quadratura adaptativa. A quadratura adaptativa não implica em "colocar pontos de amostra interativamente". A idéia por trás da quadratura adaptativa é conceber um esquema que integre uma determinada função a um determinado erro absoluto ou relativo (estimado) com o mínimo possível de avaliações de funções.

Uma segunda observação: você escreve "O número de pontos de amostragem é fixo (devido à avaliação da função ser cara), mas eu posso colocá-los livremente". Penso que a ideia deve ser que o número de pontos de amostragem (ou avaliações de funções na terminologia em quadratura) seja o menor possível (isto é, não fixo).

Então, qual é a idéia por trás da quadratura adaptativa, conforme implementada no QUADPACK, por exemplo?

1. O ingrediente básico é uma regra de quadratura "aninhada": é uma combinação de duas regras de quadratura em que uma tem uma ordem (ou precisão) mais alta que a outra. Por quê? Com base na diferença entre essas regras, o algoritmo pode estimar o erro de quadratura (é claro, o algoritmo usará o mais preciso como resultado de referência). Exemplos podem ser a regra trapezoidal com nós e nós. No caso do QUADPACK, as regras são regras de Gauss-Kronrod. Essas são regras de quadratura interpolatória que usam uma regra de quadratura de Gauss-Legendre de uma determinada ordem 2 n + 1 N N 2 N - $2^{n}$$2^{n+1}$$N$e uma extensão ideal desta regra. Isso significa que uma ordem de quadratura mais alta pode ser obtida reutilizando os nós de Gauss-Legendre (ou seja, as avaliações de funções caras) com pesos diferentes e adicionando vários nós extras. Em outras palavras, a regra de ordem original de Gauss-Legendre integrará todos os polinômios de grau exatamente enquanto a regra estendida de Gauss-Kronrod integrará exatamente algum polinômio de ordem superior. Uma regra clássica é o G7K15 (Gauss-Legendre de 7ª ordem com Gauss-Kronrod de 15ª ordem). A mágica é que os 7 nós do Gauss-Legendre são um subconjunto dos 15 nós do Gauss-Kronrod, portanto, com 15 avaliações de funções, eu tenho uma avaliação em quadratura juntamente com uma estimativa de erro!$N$$2N-1$

2. O próximo ingrediente é uma estratégia de "dividir e conquistar". Suponha que você solte esse G7K15 em seu integrando e observe um erro de quadratura que seja muito grande para o seu gosto. O QUADPACK subdividirá o intervalo original em dois subintervalos igualmente espaçados. E então reavaliará os dois subintegrais usando a regra básica, G7K15. Agora, o algoritmo possui uma estimativa de erro global (que deve ser menor que a primeira), mas também duas estimativas de erro local. Ele escolhe o intervalo com o maior erro e divide este em dois. Duas novas integrais são estimadas e o erro global é atualizado. E assim por diante até que o erro global esteja abaixo do destino solicitado ou que o número máximo de subdivisões seja ultrapassado.

Então, eu desafio você a atualizar seu código acima usando o scipy.quadmétodo Talvez no caso de um integrando com muita "estrutura fina", você precise aumentar o número máximo de subdivisões (a limitopção). Você também pode jogar com os parâmetros epsabse / ou epsrel.

No entanto, se você tiver apenas dados experimentais, vejo duas possibilidades.

1. Se você tiver a oportunidade de selecionar os pontos de medição, ou seja, valores de , eu os selecionaria equidistanamente e de preferência como potência para que você possa aplicar uma regra trapezoidal aninhada (e lucrar com a extrapolação de Romberg).$t$$2$
2. Se você não tem como escolher os nós, ou seja, as medições ocorrem em momentos aleatórios, a melhor opção na minha opinião ainda é a regra do trapézio.

Não estou convencido de que seu código demonstre algo fundamental sobre as várias regras de quadratura e quão bem elas são contra barulho e estrutura fina, e acredito que, se você escolher várias estruturas de multas diferentes, encontrará algo diferente. Aqui está o teorema:

Nenhum método de quadratura pode gerar um erro absoluto ou relativo baixo em relação a uma função com variação total ilimitada. Em um sistema de ponto flutuante com arredondamento de unidades , temos a estimativa$\mu$ onde é a soma da quadratura que atua na implementação numérica de .

$$\left| \int_{a}^{b} f \, \mathrm{d}x - \hat{Q}[\hat{f}] \right| \le \left| \int_{a}^{b} f \, \mathrm{d}x - Q[f] \right| + \mu\left[ 4\int_{a}^{b} |f| \, \mathrm{d}x + \int_{a}^{b} |xf'| \, \mathrm{d}x \right]$$ $\hat{Q}$$\hat{f}$$f$

Prova: Deixe os nós da quadratura serem e os pesos da quadratura (não negativos) sejam e denote suas aproximações de ponto flutuante por e . Suponha que satisfaça onde onde é o arredondamento da unidade. Então $\{x_i\}_{i=0}^{n-1}$$\{w_i\}_{i=0}^{n-1}$$\hat{w}_{i}$$\hat{x}_i$$\hat{f}$$\hat{f}(x) = f(x)(1+2\delta)$$|\delta| \le \mu$$\mu$

$$\begin{align*} \hat{Q}[\hat{f}] &= \sum_{i=0}^{n-1} \hat{w}_i \otimes \hat{f}(\hat{x}_i) \\ &= \sum_{i=0}^{n-1} w_i (1+\delta^w_i)f(x_i + \delta_i^x x_i)(1+2\delta_i^{f})(1+\delta_i^{*}) \\ &\approx \sum_{i=0}^{n-1} w_i \left[f(x_i)+ \delta_i^x x_i f'(x_i) \right] (1+\delta^w_i + 2\delta_i^{f} + \delta_i^*) \\ &\approx \sum_{i=0}^{n-1} w_i f(x_i) + \sum_{i=0}^{n-1}\delta_i^x w_i x_i f'(x_i) + w_i f(x_i) (\delta^w_i + 2\delta_i^{f} + \delta_i^*) \\ \end{align*}$$ para que Isso pressupõe que a soma seja calculada sem erros; multiplique por para descartar essa suposição. $$\begin{align*} |\hat{Q}[\hat{f}] - Q[f]| &\le \mu \sum_{i=0}^{n-1}w_i(|x_i f'(x_i)| + 4|f(x_i)|) \\ &\approx 4\mu \int |f| \, \mathrm{d}x + \mu \int |xf'| \, \mathrm{d}x \end{align*}$$ $n$

Mutatis mutandis, você também pode mostrar que o resultado se aplica à aritmética de ponto fixo.