How to get rid of the error message when evaluating a highly oscillatory numerical integral?

Question

I have a simple numerical integral with a highly oscillatory integrand:

In[256]:= Integrate[Exp[-x^2] Cos[100 x], {x, -10, 10}] // N

Out[256]= 5.11136*10^-46 + 0. I

Using numerical integration, I used the method "LevinRule" and increased the WorkingPrecision to 50. I got the right result, but it came with an error message:

In[273]:= NIntegrate[Exp[-x^2] Cos[100 x], {x, -10, 10}, 
  Method -> {"LevinRule"}, WorkingPrecision -> 50]

Out[273]= 5.1113608752199056046419863980883842786372578322323*10^-46

The error message says that the integral failed to converge, which makes me worry if I don't know the exact answer in advance.

During evaluation of In[273]:= NIntegrate::slwcon: Numerical integration converging too
slowly; suspect one of the following: singularity, value of the integration is 0,
highly oscillatory integrand, or WorkingPrecision too small. >>

During evaluation of In[273]:= NIntegrate::ncvb: NIntegrate failed to converge to
prescribed accuracy after 9 recursive bisections in x near
{x} = {0.06347548783822353791148881980667872878998059126103862089665838701205185579592695769871303841009927124}.
NIntegrate obtained 5.111360875219905604641986398088384278637257832232254321100441868877978318265582017097113446297596528`100.*^-46
and 2.115650450746176575259758050321352748848126918694539847444939975975907083592875723586821709970659407`100.*^-59
for the integral and error estimates. >>

How do I get rid of this error message, without suppressing it?

Answer 1

You can try setting the AccuracyGoal lower than WorkingPrecision, which yields the correct result without a reported warning.

NIntegrate[Exp[-x^2] Cos[100 x], {x, -10, 10}, 
 Method -> {"LevinRule"}, WorkingPrecision -> 50, AccuracyGoal -> 35]

5.1113608752199120138254477520179596033660767259737*10^-46

NIntegrate[Exp[-x^2] Cos[100 x], {x, -10, 10}, 
 Method -> {"LevinRule"}, WorkingPrecision -> 100, AccuracyGoal -> 90]

5.11136087521990299641307044175882379310640009556142432636206474874790\ 3858004996545055056958734154112*10^-46

Reference.

When you give a setting for WorkingPrecision, this typically defines an upper limit on the precision of the results from a computation. But within this constraint you can tell the Wolfram Language how much precision and accuracy you want it to try to get.

In a highly oscillatory function, the last few digits of precision may not converge and/or take extended time.

Answer 2

The shortest and best way between two truths of the real domain often passes through the imaginary one.

— Jacques Hadamard

By taking a complex path, I get the answer without any complaints from Mathematica.

parabolic[a_, x_] = Simplify[InterpolatingPolynomial[{{-10, 0}, {0, a}, {10, 0}}, x]]

With[{a = 1}, 
     Re[NIntegrate[With[{x = x + I parabolic[a, x]}, 
                        Exp[-x^2 + 100 I x]] (1 + I Derivative[0, 1][parabolic][a, x]),
                   {x, -10, 10}, WorkingPrecision -> 20]]]
   5.1113608752199029964*10^-46

If you want further reading, see this or this.

Answer 3

When in doubt, use brute force.

-- Ken Thompson

AbsoluteTiming[
 NIntegrate[Exp[-x^2] Cos[100 x], {x, -10, 10}, 
  Method -> {"LocalAdaptive", "SymbolicProcessing" -> 0, "SingularityHandler" -> None}, 
  MaxRecursion -> 100, 
  AccuracyGoal -> 90, WorkingPrecision -> 100]
]

(* {100.201, 
 5.111360875219902996413070441758823793106400095561424326362063281173449212599595171095728154857298543*10^-46} *)

Answer 4

Another brute-force approach, but quick:

NIntegrate[Exp[-x^2] Cos[100 x], 
   Evaluate@Flatten@{x, Range[-10., 10, 2 Pi/100], 10.}, 
   Method -> {"GaussKronrodRule", "Points" -> 31}, MaxRecursion -> 0, 
   PrecisionGoal -> 25, WorkingPrecision -> 100] // 
  N[#, 50] & // AbsoluteTiming

(*  {0.231645, 5.1113608752199029964130704417588237931064000955614*10^-46}  *)