Per dati disturbati o strutturati in modo preciso, esistono quadrature migliori della regola del punto medio?

Solo le prime due sezioni di questa lunga domanda sono essenziali. Gli altri sono solo a scopo illustrativo.

sfondo

Le quadrature avanzate come Newton – Cotes composito di grado superiore, Gauß – Legendre e Romberg sembrano essere destinate principalmente ai casi in cui è possibile campionare con precisione la funzione ma non integrarsi analiticamente. Tuttavia, per le funzioni con strutture più fini dell'intervallo di campionamento (vedere l'Appendice A per un esempio) o il rumore di misurazione, non possono competere con approcci semplici come il punto medio o la regola del trapezio (vedere l'Appendice B per una dimostrazione).

Ciò è alquanto intuitivo in quanto, ad esempio, la regola composita di Simpson essenzialmente "scarta" un quarto delle informazioni assegnandole un peso inferiore. L'unica ragione per cui tali quadrature sono migliori per funzioni sufficientemente noiose è che la corretta gestione degli effetti delle frontiere supera l'effetto delle informazioni scartate. Da un altro punto di vista, mi risulta intuitivamente chiaro che per funzioni con una struttura o un rumore fini, i campioni remoti dai confini del dominio di integrazione devono essere quasi equidistanti e avere quasi lo stesso peso (per un numero elevato di campioni ). D'altra parte, la quadratura di tali funzioni può beneficiare di una migliore gestione degli effetti dei bordi (rispetto al metodo del punto medio).

Domanda

Supponiamo che desidero integrare numericamente dati unidimensionali rumorosi o ben strutturati.

Il numero di punti di campionamento è fisso (a causa della costosa valutazione delle funzioni), ma posso posizionarli liberamente. Tuttavia, I (o il metodo) non è in grado di posizionare i punti di campionamento in modo interattivo, cioè sulla base dei risultati di altri punti di campionamento. Inoltre non conosco preventivamente potenziali regioni problematiche. Quindi, qualcosa come Gauß – Legendre (punti di campionamento non equidistanti) va bene; la quadratura adattativa non è poiché richiede punti di campionamento posizionati in modo interattivo.

• Sono stati suggeriti metodi che vanno oltre il metodo del punto medio in questo caso?

• Oppure: c'è qualche prova che il metodo del punto medio sia il migliore in tali condizioni?

• Più in generale: esistono lavori su questo problema?

Appendice A: esempio specifico di una funzione strutturata con precisione

Vorrei stimare per: con e . Una funzione tipica è simile a questa:$\int_0^1f(t)\, \mathrm{d}t$

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

Ho scelto questa funzione per le seguenti proprietà:

• Può essere integrato analiticamente per un risultato di controllo.
• Ha una struttura fine a un livello che rende impossibile catturare tutto con il numero di campioni che sto usando ( ).$<10^2$
• Non è dominato dalla sua struttura fine.

Appendice B: benchmark

Per completezza, ecco un punto di riferimento in 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))

(Qui uso la mediana per ridurre l'influenza degli outlier dovuti a funzioni che hanno solo un contenuto ad alta frequenza. In media, i risultati sono simili.)

Le mediane dei relativi errori di integrazione sono:

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: dopo due mesi e una taglia senza risultato, l' ho pubblicato su MathOverflow .

Prima di tutto, penso che tu fraintenda il concetto di quadratura adattativa. La quadratura adattativa non implica "il posizionamento interattivo di punti campione". L'idea alla base della quadratura adattativa è quella di escogitare uno schema che integri una certa funzione in un certo errore (stimato) assoluto o relativo con il minor numero possibile di valutazioni delle funzioni.

Una seconda osservazione: scrivi "Il numero di punti di campionamento è fisso (a causa della costosa valutazione delle funzioni), ma posso posizionarli liberamente". Penso che l'idea dovrebbe essere che il numero di punti di campionamento (o valutazioni di funzioni nella terminologia di quadratura) dovrebbe essere il più piccolo possibile (cioè non fisso).

Allora, qual è l'idea alla base della quadratura adattativa implementata in QUADPACK, ad esempio?

1. L'ingrediente di base è una regola di quadratura "nidificata": si tratta di una combinazione di due regole di quadratura in cui una ha un ordine (o precisione) più elevato dell'altra. Perché? Sulla base della differenza tra queste regole, l'algoritmo può stimare l'errore di quadratura (ovviamente l'algoritmo utilizzerà quello più preciso come risultato di riferimento). Esempi potrebbero essere la regola trapezoidale con nodi e nodi. Nel caso di QUADPACK, le regole sono regole di Gauss-Kronrod. Queste sono regole di quadratura interpolatorie che usano una regola di quadratura di Gauss-Legendre di un certo ordine$2^{n}$$2^{n+1}$$N$e un'estensione ottimale di questa regola. Ciò significa che è possibile ottenere un ordine di quadratura superiore riutilizzando i nodi Gauss-Legendre (ovvero le costose valutazioni delle funzioni) con pesi diversi e aggiungendo un numero di nodi extra. In altre parole, la regola originale di Gauss-Legendre dell'ordine integrerà tutti i polinomi di grado proprio mentre il prolungato regola di Gauss-Kronrod integrerà alcune polinomiale di ordine superiore esattamente. Una regola classica è il G7K15 (Gauss-Legendre del 7 ° ordine con Gauss-Kronrod del 15 ° ordine). La magia è che i 7 nodi di Gauss-Legendre sono un sottoinsieme dei 15 nodi di Gauss-Kronrod, quindi con 15 valutazioni delle funzioni, ho una valutazione in quadratura insieme a una stima dell'errore!$N$$2N-1$

2. Il prossimo ingrediente è una strategia di "dividi e conquista". Supponiamo di aver lasciato perdere questo G7K15 sul tuo integrando e di osservare un errore di quadratura che secondo i tuoi gusti è troppo grande. QUADPACK suddivide quindi l'intervallo originale in due sottointervalli equidistanti. E quindi rivaluterà i due sottointegrali usando la regola di base, G7K15. Ora, l'algoritmo ha una stima dell'errore globale (che dovrebbe essere più bassa della prima) ma anche due stime dell'errore locale. Seleziona l'intervallo con l'errore più grande e lo divide in due. Vengono stimati due nuovi integrali e l'errore globale viene aggiornato. E così via fino a quando l'errore globale è inferiore all'obiettivo richiesto o non è stato superato il numero massimo di suddivisioni.

Quindi ti sfido ad aggiornare il codice sopra usando il scipy.quadmetodo. Forse nel caso di un integrando con molta "struttura fine", potrebbe essere necessario aumentare il numero massimo di suddivisioni ( limitopzione). Puoi anche giocare con i parametri epsabse / o epsrel.

Tuttavia, se hai solo dati sperimentali, vedo due possibilità.

1. Se hai l'opportunità di selezionare i punti di misurazione, cioè i valori di , li selezionerei equidistanicamente e preferibilmente come una potenza di modo da poter applicare una regola trapezoidale annidata (e trarre profitto dall'estrapolazione di Romberg).$t$$2$
2. Se non hai modo di scegliere i nodi, ovvero le misure arrivano in momenti casuali, la migliore opzione secondo me è ancora la regola del trapezio.

Non sono convinto che il tuo codice dimostri qualcosa di fondamentale riguardo alle varie regole di quadratura e quanto bene facciano contro il rumore e la struttura fine, e credo sia probabile che se tu scegliessi varie strutture diverse per le multe troverai qualcosa di diverso. Ecco il teorema:

Nessun metodo di quadratura può dare un errore assoluto o relativo basso rispetto a una funzione con variazione totale illimitata. In un sistema a virgola mobile con arrotondamento unità , abbiamo la stima$\mu$ dove è la somma in quadratura che agisce sull'implementazione numerica di .

$$\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: lascia che i nodi di quadratura siano e che i pesi di quadratura (non negativi) siano e denotano le loro approssimazioni in virgola mobile di e . Supponiamo che soddisfi dove dove è il roundoff dell'unità. Poi $\{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*}$$ modo che Questo presuppone che la somma sia calcolata senza errori; moltiplicare per per eliminare tale presupposto. $$\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 puoi anche dimostrare che il risultato è valido in aritmetica in virgola fissa.