Rundung von Lagrange-Polynomen mit vielen Knoten abrunden

Bei einer Menge von Punkten in möchte ich berechnen genau. ist das Lagrange-Polynom in Bezug auf die Punkte mit als Knoten, dh Da dies ein Polynom vom Grad , könnte ich jede alte Gaußsche Quadratur von ausreichendem Grad verwenden. Dies funktioniert gut, wenn nicht zu groß ist, führt jedoch zu Ergebnissen, die durch Rundungsfehler für großes fehlerhaft sind . [ - 1 , 1 ] ∫ 1 - 1 L i ( x $\{x_j\}_{j=1}^n$$[-1, 1]$L i x j x i L i ( x ) = ∏ j ≠ i x - x

$$\int_{-1}^{1} L_i(x)\,\text{d} x$$ $L_i$$x_j$$x_i$nn $$L_i(x) = \prod_{j\neq i} \frac{x - x_j}{x_i - x_j}.$$ $n$$n$$n$

Irgendeine Idee, wie man diese vermeidet?

Die Berechnung von für die Lagrange-Polynome die auf einem beliebigen Gitter kann von der durchgeführt werden folgende zwei Schritte:

$$\int_{-1}^{1} L_k(x)\,\text{d} x$$ $L_k$$x_k, k=0,\ldots,n$

1. Berechnen Sie die Clenshaw-Curtis-Quadraturgewichte auf dem Chebyshev-Extrema-Gitter für : wobei für , andernfalls und für oder , andernfalls . Siehe das Papier von Waldvogel (2006) für weitere Details.$w^{\text{cc}}_k$$y_k$$k=0,\ldots,n$

   $$y_k = \cos\left(\frac{k\pi}{n}\right)\\ w^{\text{cc}}_k = \frac{c_k}{n }\Bigg(1-\sum_{j=1}^{\lfloor{n/2}\rfloor} \frac{b_j}{4j^2-1} \cos\left(\frac{2\pi \,j \, k}{n}\right)\Bigg)$$ $b_k := 1$$k=n/2$$b_k:=2$$c_k:=1$$k=0$$k=n$$c_k:=2$

2. Transformiere die Gewichte über die Transformationsmatrix in das beliebige Gitter , um die gesuchten Gewichte , wobei $w^{\text{cc}}_k$$x_k, k = 0,\ldots, n$$M$$w_k$

   $$w_k = \sum_{j} M_{kj} w_j^{\text{cc}}$$ $$M_{jk} \ = \ L_j(y_k)\,.$$

Im Prinzip ist dies nur eine Clenshaw-Curtis-Quadratur mit Funktionswerten auf dem beliebigen Gitter , die jedoch durch Basistransformation erhalten wird (für eine allgemeine Referenz zu Clenshaw-Curtis siehe z. B. das Trefethen-Papier).$x_k$

Der Algorithmus scheint ziemlich stabil zu sein, insbesondere im Vergleich zum Vandermonde-Ansatz, wie er in der Antwort von @Kirill angegeben ist : Obwohl er denselben Vorstellungen folgt - generieren Sie die Quadraturgewichte auf bekannter Basis und transformieren Sie sie dann in das neue Gitter - dies hätte erwartet werden können, da die Transformation in Bezug auf die Vandermonde-Matrix normalerweise stark schlecht konditioniert ist.

---

Beispiel: Erzeugung von Legendre-Lobatto-Quadraturgewichten

Wir betrachten das Beispiel der Legendere-Lobatto-Quadraturregel und vergleichen die Genauigkeit mit dem monomialen Ansatz. Als Referenz verwenden wir die Quadraturgewichte die vom Golub-Welsch-Algorithmus für verschiedene und berechnen den kumulierten Fehler Hier ist das Ergebnis: Man stellt fest, dass die Clenshaw-Curtis-Quadraturgewichte über den betrachteten Bereich von Gitterpunkten perfekt stabil sind und die Legendre-Gewichte bis zur Maschinengenauigkeit ( reproduzieren ).$w_k^{\text{Leg}}$$n$

$$\epsilon_n = \sum_{k=1}^n \Big(w_k - w_k^{\text{Leg}}\Big)^2$$ $\sqrt{\epsilon} \sim 10^{15}$

---

Beispiel: Erzeugung von Newton-Cotes-Quadraturformeln

Wir betrachten die Erzeugung der Newton-Cotes-Quadraturformel auf gleich beabstandeten Gittern. Wiederum erwartet man eine schlechte Konditionierung, da kurz gesagt für die Polynominterpolation Gitter mit gleichem Abstand baaad sind.

Im folgenden Bild habe ich die absolute Summe der Gewichte berechnet . $\sum_i |w_i|/N$

Bis zu beispielsweise 50 Gitterpunkte stimmen die Ergebnisse des Monomial- und des Clenshaw-Curtis-Ansatzes überein. Danach wird Clenshaw-Curtis besser - für das, was es wert ist. Eine direkte Interpretation ist, dass das gleichmäßig verteilte Gitter alles für beispielsweise ruiniert . Bei etwa schlägt der Zustand der Vandermonde-Matrix jedoch zurück und führt zu einem noch schlechteren Ergebnis.$n>10$$n=50$

---

Beispiel: Guass-Patterson-Quadratur

Dieses Beispiel ist @ NicoSchlömer zu verdanken. Ich kannte diese Regeln bisher nicht, also habe ich die Abszissen aus dieser Implementierung genommen und sowohl den Vandermonde- als auch den transformierten Clenshaw-Curtis-Ansatz angewendet (wobei der Vandermonde-Ansatz wie oben den Björk-Pereyra-Algorithmus verwendet).

Wie im Kommentar vorgeschlagen, berechnete ich dann den Fehler der Integration einer konstanten Funktion durch mit dem folgendes Ergebnis:

$$\epsilon = \frac{1}{n}\Bigg|2-\sum_{i=1}^n w_i\Bigg|\,,$$

Aus diesem Bild geht hervor, dass der transformierte Clenshaw-Curtis-Ansatz weitaus effizienter ist als der Vandermonde-Ansatz (zumindest in der Arithmetik mit endlicher Genauigkeit). Trotzdem bricht Clenshaw-Curtis ab Index 7 zusammen, daher sollten andere Methoden angewendet werden.

Sie können dies mit dem Björck-Pereyra-Algorithmus zur Lösung von Vandermonde-Systemen bewerten, da Sie bewerten$b^\top V^{-1}$$b=(2,0,\frac23,0,\frac25,0,\ldots)$

$0\leq x_1<x_2<\cdots <x_n$$V$$b$$0\leq x_1$$O(n^2)$$L_i$$x\mapsto \frac12(x+1)$

$O(\epsilon_{\mathrm{mach}})$

module VandermondeInverse

using SpecialMatrices

function main(n=8)
  X = Rational{BigInt}[k//(n-1) for k=0:n-1]
  # X = convert(Vector{Rational{BigInt}}, linspace(-1, 1, n))
  x = convert(Vector{Float64}, X)

  A = convert(Matrix{Rational{BigInt}}, Vandermonde(X))
  b = [i%2==0 ? 2//(i+1) : 0 for i=0:n-1]
  println("Norm: ", norm(A, Inf))
  println("Norm of inverse: ", norm(inv(A), Inf))
  println("Condition number: ", cond(convert(Matrix{Float64}, A)))
  ans = A'\b
  println("True answer: ", ans)

  B = convert(Matrix{Float64}, A)
  c = convert(Vector{Float64}, b)

  println("Linear solve: ", norm((B'\c - ans)./ans, Inf))

  d = vec(c')
  for k=1:n, l=n:-1:k+1
    d[l] -= x[k]*d[l-1]
  end

  for k=n-1:-1:1, l=k:n
    if l > k
      d[l] /= x[l]-x[l-k]
    end
    if l < n
      d[l] -= d[l+1]/(x[l+1] - x[l-k+1])
    end
  end
  println("Neville elimination: ", norm((d-ans)./ans, Inf))

  nothing
end

end

V = VandermondeInverse

Ausgabe:

julia> V.main(14)
Norm: 14.0
Norm of inverse: 1.4285962612120493e10
Condition number: 5.2214922998851654e10
True answer: Rational{Int64}[3202439130233//2916000,-688553801328731//52390800,19139253128382829//261954000,-196146528919726853//785862000,6800579086408939//11642400,-43149880138884259//43659000,32567483200938127//26195400,-7339312362348889//6237000,48767438804485271//58212000,-69618881108680969//157172400,44275410625421677//261954000,-2308743351566483//52390800,11057243346333379//1571724000,-209920276397//404250]
Linear solve: 1.5714609387747318e-8
Neville elimination: 1.3238218572356314e-15

Wenn dies Xnicht wie in diesem Test positiv ist, scheinen die relativen Fehler in der gleichen Größenordnung zu liegen wie bei einer regulären linearen Lösung.

$b^\top V^{-1}$$L_i$$L_i(x_j)=\delta_{ij}$$\alpha_{jk}$$L_k$

$$L_k(x) = \sum_{j,k} \alpha_{j,k}x^j = (1,x,x^2,\ldots,x^n)^\top (\alpha_{0k},\ldots,\alpha_{nk}),$$ $L$ $$L = \begin{pmatrix} \alpha_{00}& \cdots & \alpha_{0n}\\\vdots &&\vdots\\ \alpha_{n0}&\cdots&\alpha_{nn} \end{pmatrix}.$$ $L_k$$L$$(1,x,\ldots,x^n)$ $$(1,x,x^2,\ldots,x^n)L = (L_0(x),L_1(x),\ldots,L_n(x)).$$ $L_k(x_j)=\delta_{jk}$ $$\begin{pmatrix} 1&x_0&x_0^2&\cdots&x_0^n\\ \vdots\\ 1&x_n&x_n^2&\cdots&x_n^n \end{pmatrix} L = I,$$ $L = V^{-1}$$V$$x_j$

$\int_{-1}^{1}x^k\,\mathrm{d}x = \frac{1+(-1)^k}{k+1}$

$$\int_{-1}^{1}L_k(x)\,\mathrm{d}x = \sum_j \alpha_{jk}\frac{1+(-1)^k}{k+1} = (2,0,\tfrac23,0,\tfrac25,0,\ldots)^\top (\alpha_{0k},\ldots,\alpha_{nk}).$$ $n+1$$k=0\ldots n$$(2,0,\tfrac23,0,\ldots)^\top L$$L=V^{-1}$

Berechnen Sie zuerst die Produkte der Nominatoren und Nenner und teilen Sie sie dann einmal. Die beiden Produkte sollten in der gleichen Größenordnung liegen, damit keine signifikanten Rundungsfehler auftreten. Durch die geringere Anzahl von Gleitkommaberechnungen erhalten Sie außerdem den zusätzlichen Vorteil einer höheren Geschwindigkeit.