Método para la integración numérica de la integral oscilatoria difícil.

Necesito evaluar numéricamente la integral a continuación:

donde $E(r) = r^4 (\lambda\sqrt{\kappa^2+r^2})^{-\nu-5/2} K_{-\nu-5/2}(\lambda\sqrt{\kappa^2+r^2})$,$x \in \mathbb{R}_+$y$\lambda, \kappa, \nu >0$. Aquí$K$es la función Bessel modificada del segundo tipo. En mi caso particular tengo$\lambda = 0.00313$,$\kappa = 0.00825$y$\nu = 0.33$.

Estoy usando MATLAB, y he probado las funciones integradas integraly quadgk, lo que me da muchos errores (ver más abajo). Naturalmente, también he intentado muchas otras cosas, como la integración por partes y la suma de integrales de a ( k + 1 ) x π .$kx\pi$$(k+1)x\pi$

Entonces, ¿tiene alguna sugerencia sobre qué método debería probar a continuación?

ACTUALIZACIÓN (preguntas adicionales)
Leí el documento al que se vinculó @Pedro, y no creo que fuera demasiado difícil de entender. Sin embargo, tengo algunas preguntas:

• ¿Estaría bien usar como elementos básicos ψ k , en el método univariado de Levin descrito?$x^k$$\psi_k$
• ¿Podría usar un método Filon, ya que la frecuencia de las oscilaciones es fija?

Código de ejemplo
>> integral(@(r) sin(x*r).*sqrt(E(r)),0,Inf)
Warning: Reached the limit on the maximum number of intervals in use. Approximate
bound on error is 1.6e+07. The integral may not exist, or it may be difficult to
approximate numerically to the requested accuracy.
> In funfun\private\integralCalc>iterateScalarValued at 372
In funfun\private\integralCalc>vadapt at 133
In funfun\private\integralCalc at 84
In integral at 89

ans =

3.3197e+06

He escrito mi propio integrador, quadccque maneja sustancialmente mejor que los integradores de Matlab con singularidades, y proporciona una estimación de error más confiable.

Para usarlo para su problema, hice lo siguiente:

>> lambda = 0.00313; kappa = 0.00825; nu = 0.33;
>> x = 10;
>> E = @(r) r.^4.*(lambda*sqrt(kappa^2 + r.^2)).^(-nu-5/2) .* besselk(-nu-5/2,lambda*sqrt(kappa^2 + r.^2));
>> sincp = @(x) cos(x)./x - sin(x)./x.^2;
>> f = @(r) sincp(x*r) .* r .* sqrt( E(r) );

La función fahora es tu integrando. Tenga en cuenta que acabo de asignar cualquier valor anterior a x.

Para integrar en un dominio infinito, aplico una sustitución de variables:

>> g = @(x) f ( tan ( pi / 2 * x ) ) .* ( 1 + tan ( pi * x / 2 ).^2 ) * pi / 2;

es decir, integrar gde 0 a 1 debería ser lo mismo que integrar fde 0 a . Diferentes transformaciones pueden producir resultados de diferente calidad: matemáticamente todas las transformaciones deberían dar el mismo resultado, pero diferentes transformaciones pueden producir s más suaves o más fácilmente integrables .$\infty$g

Luego llamo a mi propio integrador, quadccque puede manejar el NaNs en ambos extremos:

>> [ int , err , npoints ] = quadcc( g , 0 , 1 , 1e-6 )
int =
  -1.9552e+06
err =
   1.6933e+07
npoints =
       20761

Tenga en cuenta que la estimación del error es enorme, es decir quadcc, no tiene mucha confianza en los resultados. Sin embargo, al observar la función, esto no es sorprendente, ya que oscila en valores de tres órdenes de magnitud por encima de la integral real. Nuevamente, usar una transformación de intervalo diferente puede producir mejores resultados.

También es posible que desee ver métodos más específicos como este . Es un poco más complicado, pero definitivamente es el método correcto para este tipo de problema.

Como señala Pedro, los métodos de tipo Levin son los mejores métodos establecidos para este tipo de problemas.

¿Tienes acceso a Mathematica? Para este problema, Mathematica los detectará y usará por defecto:

In[1]:= e[r_] := 
 r^4 (l Sqrt[k^2 + r^2])^(-v - 5/2) BesselK[-v - 5/2, l Sqrt[k^2 + r^2]]

In[2]:= {l, k, v} = {0.00313, 0.00825, 0.33};

In[3]:= Block[{x = 10}, 
 NIntegrate[Sinc'[x r] r Sqrt[e[r]], {r, 0, \[Infinity]}, 
  PrecisionGoal -> 3]]

Out[3]= -112494.

Aquí hay una gráfica sobre un rango de valores de x:

In[4]:= ListLinePlot[
 Table[NIntegrate[Sinc'[x r] r Sqrt[e[r]], {r, 0, \[Infinity]}, 
   PrecisionGoal -> 3], {x, .5, 10, 0.1}]]

También puede especificar manualmente el método particular de tipo Levin para aplicar, que en este caso puede producir una ligera mejora en el rendimiento:

In[5]:= method = {"LevinRule", "Kernel" -> {Cos[r x], Sin[r x]}, 
   "DifferentialMatrix" -> {{0, -x}, {x, 0}}, 
   "Amplitude" -> {(
     3497.878840962873` Sqrt[(
      r^4 BesselK[-2.17`, 
        0.00313` Sqrt[
         0.00006806250000000001` + r^2]])/(0.00006806250000000001` + 
        r^2)^1.415`])/
     x, -((3497.878840962873` Sqrt[(
       r^4 BesselK[-2.17`, 
         0.00313` Sqrt[
          0.00006806250000000001` + r^2]])/(0.00006806250000000001` + 
         r^2)^1.415`])/(r x^2))}, "AdditiveTerm" -> 0};

In[6]:= Block[{x = 10}, 
 NIntegrate[Sinc'[x r] r Sqrt[e[r]], {r, 0, \[Infinity]}, 
  PrecisionGoal -> 3, Method -> method]]

Out[6]= -112495.

Consulte la documentación para obtener detalles sobre los métodos de tipo Levin en Mathematica .

Si no tiene acceso a Mathematica, podría escribir un método de tipo Levin (u otro oscilatorio especializado) en Matlab como sugiere Pedro.

¿Utiliza la biblioteca chebfun para Matlab? Me acabo de enterar que contiene una implementación de un método básico de tipo Levin aquí . La implementación está escrita por Olver (uno de los expertos en el campo de la cuadratura oscilatoria). No trata con singularidades, subdivisión adaptativa, etc., pero puede ser justo lo que necesita para comenzar.

La transformación recomendada por Pedro es una gran idea. ¿Has intentado jugar con los parámetros en la función "quadgk" de Matlab? Por ejemplo, usando la transformación de Pedro, puede hacer lo siguiente:
quadgk(f, 0.0+eps, 1.0-eps, 'AbsTol', eps, 'MaxIntervalCount', 100000)
Usar esto me da una solución de:
-2184689.50220729
y solo toma 0.8 segundos (usando los valores mencionados anteriormente: x = 10)
Walter Gander y Walter Gautschi tienen un documento sobre la cuadratura adaptativa con Matlab código que puede usar también (enlace aquí )