高振荡积分的数值评估

在这一高级课程中，复杂函数理论在一次练习中的应用是高度振荡的

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

对于大的$\lambda$值，必须使用鞍点法在复平面中进行近似。

由于其高度振荡的性质，使用大多数其他方法很难评估该积分。这是$\lambda = 10$时不同比例的积分图的两个片段：

前导渐近逼近为

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

进一步（小得多）的改进增加了术语

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

近似值与$\lambda$如下：

现在是我的问题：为了直观地看到近似值，我想将其与积分的“实际值”进行比较，或更准确地说，是使用独立算法将其与相同积分的近似值进行比较。由于次要修正的规模很小，我希望这确实很接近。

我尝试使用其他算法评估某些$\lambda$的积分，但收效甚微：使用默认数值积分器的Mathematica和Matlab未能产生有意义的值（并明确报告此值），而mpmath则同时使用了双指数$\tanh(\sinh)$替换和Gauss-Legendre方法产生非常嘈杂的结果，尽管它确实有轻微的趋势围绕鞍点方法给出的值振荡，如下图所示：

最终，我使用实现的重要性样本与蒙特卡洛积分器进行了碰碰运气，但我也未能获得任何稳定的结果。

有谁知道如何对λ > 1的任何固定值独立地求积分$\lambda > 1$左右的？

利用 Plancherel定理评估该积分。

基本思想是，对于两个函数$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)$）。Plancherel定理上述方法也适用于傅里叶级数与积分域$[0,2\pi]$上的最后一个积分。

评估振荡积分的关键是在正确的位置截断积分。对于此示例，您需要选择表格的上限

$$\pi\mathbb{N}+\frac{\pi}{2}$$ 在解释为什么它应该起作用之前，首先让我表明它实际上产生了良好的效果。

渐近性

很容易猜想，渐近级数的形式为

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

作为输出，您会得到一个很好的正弦，与您上面导出的正弦一致。

如果要查找以下系数，则需要一些更复杂的代码。以下代码的想法是采用几个较高的上限值并将其结果“平均”。

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

说明

简单的例子

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

你的问题

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

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

Ooura的傅里叶正弦积分方法在这里有效，请参见：

Ooura，Takuy​​a和Masatake Mori，傅立叶型积分的鲁棒双指数公式。计算与应用数学学报112.1-2（1999）：229-241。

我编写了该算法的实现，但从未投入工作以使其快速（通过缓存节点/权重），但是尽管如此，我在浮动精度之外的所有方面都得到了一致的结果：

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

这是代码：

#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";
}

$\lambda\to 0$