Evaluación numérica de integral altamente oscilatoria

En este curso avanzado sobre aplicaciones de la teoría de funciones complejas en un punto de un ejercicio, la integral altamente oscilatoria

$$I(\lambda)=\int_{-\infty}^{\infty} \cos (\lambda \cos x) \frac{\sin x}{x} d x$$

tiene que aproximarse para valores grandes de $\lambda$ utilizando el método del punto de silla de montar en el plano complejo.

Debido a su naturaleza altamente oscilatoria, esta integral es muy difícil de evaluar utilizando la mayoría de los otros métodos. Estos son dos fragmentos de la gráfica del integrando para $\lambda = 10$ a diferentes escalas:

Una aproximación asintótica de orden principal es

$$I_{1}(\lambda) = \cos \left(\lambda-\frac{1}{4} \pi\right) \sqrt{\frac{2 \pi}{\lambda}}$$

y un refinamiento adicional (mucho más pequeño) agrega el término

$$I_2(\lambda)=\frac{1}{8} \sin \left(\lambda-\frac{1}{4} \pi\right) \sqrt{\frac{2 \pi}{\lambda^{3}}}$$

Un gráfico de los valores aproximados en función de $\lambda$ ve de la siguiente manera:

Ahora viene mi pregunta: para ver visualmente qué tan buena es la aproximación, me gustaría compararla con el "valor real" de la integral, o más precisamente con una buena aproximación a la misma integral usando un algoritmo independiente. Debido a lo pequeño de la corrección de subtítulos, esperaría que esto sea muy cercano.

$\lambda$$\tanh(\sinh)$

Finalmente probé suerte con un integrador de Montecarlo usando una muestra de importancia que implementé, pero tampoco pude obtener resultados estables.

$\lambda > 1$

Use el teorema de Plancherel para evaluar esta integral.

$f,g$

$$I=\int_{-\infty}^{\infty} f(x) g^*(x)dx = \int_{-\infty}^{\infty} F(k) G^*(k) dk$$

$F,G$$f,g$$\sin x / x \rightarrow \text{rect}(k)$$\cos(\lambda\cos x)$$\lambda$$|J_n(x)|$$n>|x|$

$\pi J_0(\lambda)$$[0,2\pi]$

$$\pi\mathbb{N}+\frac{\pi}{2}$$

Asintóticas

$$I(\lambda) \sim \sqrt{\frac{2\pi}{\lambda}}\left[\cos\left(\lambda-\frac{\pi}{4}\right) + c_1 \frac{\sin\left(\lambda-\frac{\pi}{4}\right)}{\lambda} + c_2 \frac{\cos\left(\lambda-\frac{\pi}{4}\right)}{\lambda^2} + c_3 \frac{\sin\left(\lambda-\frac{\pi}{4}\right)}{\lambda^3} + \dots \right]$$ $c_1 = \frac{1}{8}$

int := NIntegrate[Cos[l*Cos[x]]*Sinc[x], {x, 0, 20.5*Pi}]; 
Plot[{l*(Sqrt[2*l/Pi]*int - Cos[l-Pi/4]), Sin[l-Pi/4]/8}, {l, Pi/4, 20}]

Como resultado, obtienes un seno bastante agradable que coincide con el que obtuviste anteriormente.

Si desea encontrar los siguientes coeficientes, un código un poco más sofisticado si es necesario. La idea del siguiente código es tomar varios valores límite superiores altos y "promediar" sus resultados.

J[l_?NumericQ] := Block[{n=500},
  f[k_] := NIntegrate[Cos[l*Cos[x]]*Sinc[x], {x,0,(n+k)*Pi+Pi/2},
  Method->{"DoubleExponential"}, AccuracyGoal->14, MaxRecursion->100];
  1/2*((f[0]+f[1])/2+(f[1]+f[2])/2)
]
t = Table[{l, l^2*(Sqrt[2*l/Pi]*J[l] - Cos[l-Pi/4] - 1/8*Sin[l-Pi/4]/l)}, 
    {l, 4*Pi+Pi/4, 12*Pi+Pi/4, Pi/36}];
Fit[t, Table[Cos[l-Pi/4+Pi/2*n]/l^n, {n, 0, 10}], l]

$$\boxed{ \boxed{ c_2 = -\frac{9}{128}, \qquad c_3 = -\frac{75}{1024}, \qquad c_4 = \frac{3675}{32768}, \quad\dots }}$$

Explicación

Ejemplo simple

$$S(x) = \int_{0}^x \frac{\sin(y)}{y} dy.$$ $S(\infty)=\frac{\pi}{2}$

$S(x)$

$$S_N = \sum_{n=1}^N \frac{(-1)^n}{n}.$$ $$S \approx S_N + \frac{1}{2}\frac{(-1)^{N+1}}{N+1}.$$ $$S(x) \approx \int_0^{\pi\mathbb{N}+\frac{\pi}{2}} \frac{\sin x}{x}dx$$ $\max |S'(x)|$

Tu problema

Volviendo a la integral del curso de Konstantin y Yaroslav, puede ver que se comporta exactamente de la misma manera que el seno: integral en función del límite superior. Eso significa que solo necesita calcular los valores con . A continuación se muestra la gráfica de varios de estos valores con .

$$I_{x_0}(\lambda) = 2\int_{0}^{x_0}\cos\left(\lambda\cos(x)\right)\operatorname{sinc}(x)dx$$ $x_0 = \pi\mathbb{N}+\frac{\pi}{2}$$\lambda = 12\pi$

tab = Table[{x0, 2*NIntegrate[Cos[12*Pi*Cos[x]]*Sinc[x], {x, 0, x0}, 
     Method->{"DoubleExponential"}, AccuracyGoal->12, MaxRecursion->100]},
    {x0, 10*Pi+Pi/2, 30*Pi+Pi/2, Pi}];
tab1 = Table[(tab[[i]] + tab[[i+1]])/2, {i,1,Length[tab]-1}];
ListPlot[{tab, tab1}]

Aquí puede ver el resultado de otro método de aceleración. sumas parciales de la siguiente manera y nueva secuencia que converge mucho más rápido. Ese truco también resulta útil si desea evaluar integral con alta precisión.

$$S_N' = \frac{1}{2}(S_N+S_{N+1})$$ $S_N'$

El método de Ooura para las integrales seno de Fourier funciona aquí, ver:

Ooura, Takuya y Masatake Mori, una robusta fórmula doble exponencial para integrales de tipo Fourier. Revista de matemática computacional y aplicada 112.1-2 (1999): 229-241.

Escribí una implementación de este algoritmo, pero nunca me puse a trabajar para hacerlo rápido (por ejemplo, nodos de almacenamiento en caché / pesos), pero no obstante, obtengo resultados consistentes en todo más allá de la precisión de flotación:

float     = 0.0154244
double    = 0.943661538060268
long dbl  = 0.943661538066058702
quad      = 0.943661538066060288748574485677942
oct       = 0.943661538066060288748574485680878906503533004997613278231689169604876
asymptotic= 0.944029734

Aquí está el código:

#include <iostream>
#include <boost/math/quadrature/ooura_fourier_integrals.hpp>
#include <boost/math/constants/constants.hpp>
#include <boost/multiprecision/float128.hpp>
#include <boost/multiprecision/cpp_bin_float.hpp>

template<class Real>
Real asymptotic(Real lambda) {
    using std::sin;
    using std::cos;
    using boost::math::constants::pi;
    Real I1 = cos(lambda - pi<Real>()/4)*sqrt(2*pi<Real>()/lambda);
    Real I2 = sin(lambda - pi<Real>()/4)*sqrt(2*pi<Real>()/(lambda*lambda*lambda))/8;
    return I1 + I2;
}

template<class Real>
Real osc(Real lambda) {
    using std::cos;
    using boost::math::quadrature::ooura_fourier_sin;
    auto f = [&lambda](Real x)->Real { return cos(lambda*cos(x))/x; };
    Real omega = 1;
    Real Is = ooura_fourier_sin<decltype(f), Real>(f, omega);
    return 2*Is;
}

template<class Real>
void print(Real val) {
   std::cout << std::defaultfloat;
   std::cout << std::setprecision(std::numeric_limits<Real>::digits10);
   std::cout <<  val <<  " = " << std::hexfloat << val;
}

int main() {
    using boost::multiprecision::float128;
    float128  s = 7;
    std::cout << "Asymptotic = " << std::setprecision(std::numeric_limits<float128>::digits10) << asymptotic(s) << "\n";
    std::cout << "float precision = ";
    print(osc(7.0f));
    std::cout << "\n";
    std::cout << "double precision= ";
    print(osc(7.0));
    std::cout << "\n";
    std::cout << "long double     = ";
    print(osc(7.0L));
    std::cout << "\n";
    print(osc(s));

    print(osc(boost::multiprecision::cpp_bin_float_oct(7)));
    std::cout << "\n";
}

Realmente no se puede ver la diferencia entre la cuadratura y el asintótico porque se encuentran uno encima del otro, excepto como : $\lambda\to 0$