Integrando polinomios de Lagrange con muchos nodos, redondeo

Dado un conjunto de puntos en [ - 1 , 1 ] , me gustaría calcular ∫ 1 - 1 L i ( x $\{x_j\}_{j=1}^n$$[-1, 1]$ exactamente. L i es el polinomio de Lagrange con respecto a los puntos x j con x i como nodo, es decir, L i ( x ) = ∏ j ≠ i x - x

$$\int_{-1}^{1} L_i(x)\,\text{d} x$$ $L_i$$x_j$$x_i$ Como este es un polinomio de gradon, podría usar cualquier cuadratura gaussiana de grado suficiente. Esto funciona bien sinno es demasiado grande, pero conduce a resultados defectuosos por errores de redondeo parangrande. $$L_i(x) = \prod_{j\neq i} \frac{x - x_j}{x_i - x_j}.$$ $n$$n$$n$

¿Alguna idea de cómo evitarlos?

El cálculo de

$$\int_{-1}^{1} L_k(x)\,\text{d} x$$ para los polinomios de Lagrange$L_k$ definidos en una cuadrícula arbitraria$x_k, k=0,\ldots,n$ puede realizarse mediante los dos pasos siguientes:

1. Calcule los pesos de la cuadratura de Clenshaw-Curtis $w^{\text{cc}}_k$ en la cuadrícula extrema de Chebyshev $y_k$ para $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)$$ donde$b_k := 1$para$k=n/2$, de lo contrario$b_k:=2$, y$c_k:=1$para$k=0$o$k=n$, de lo contrario$c_k:=2$. Ver el artículo de Waldvogel (2006) para más detalles.

2. Transforme los pesos $w^{\text{cc}}_k$ en la cuadrícula arbitraria $x_k, k = 0,\ldots, n$ , a través de la matriz de transformación $M$ para obtener los pesos buscados $w_k$ ,

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

$x_k$

El algoritmo parece ser bastante estable, particularmente cuando se lo compara con el enfoque de Vandermonde según lo provisto en la respuesta de @Kirill : aunque sigue las mismas ideas: generar los pesos en cuadratura de manera conocida y luego transformarlos en la nueva cuadrícula. podría esperarse ya que la transformación en términos de la matriz de Vandermonde suele estar muy mal condicionada.

---

Ejemplo: generación de pesos en cuadratura Legendre-Lobatto

$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}$

---

Ejemplo: generación de fórmulas de cuadratura de Newton-Cotes

Consideramos la generación de la fórmula de la cuadratura de Newton-Cotes en cuadrículas equidistantes. Una vez más, uno espera un mal acondicionamiento, ya que, en resumen, para la interpolación polinómica, las redes espaciadas equitativamente son malas.

$\sum_i |w_i|/N$

$n>10$$n=50$

---

Ejemplo: cuadratura de Guass-Patterson

Este ejemplo se debe a @ NicoSchlömer. No conocía estas reglas hasta ahora, así que tomé las abscisas de esta implementación y apliqué tanto el enfoque de Vandermonde como el enfoque transformado de Clenshaw-Curtis (donde, como anteriormente, el enfoque de Vandermonde está utilizando el algoritmo Björk-Pereyra).

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

A partir de esta imagen, el enfoque transformado de Clenshaw-Curtis parece mucho más eficiente que el enfoque de Vandermonde (al menos en aritmética de precisión finita). Aún así, Clenshaw-Curtis se desglosa a partir del índice 7, por lo que se deben utilizar otros métodos.

$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

Salida:

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

Si Xno es positivo como en esta prueba, parece que los errores relativos son del mismo orden que con una resolución lineal regular.

$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}$

Calcule primero los productos de los nominadores y los denominadores y luego divídalos una vez. Los dos productos deben ser del mismo orden de magnitud, por lo que no debe haber errores significativos de redondeo. También obtiene el beneficio adicional de una mayor velocidad, debido a la reducción del número de cálculos de coma flotante.