# Bad performance of Integrate (and WolframAlpha) for an Integral of Bessel function of the first kind: Version 11 edit

Version 11 Edit

The issue still remains:

Integrate[BesselJ[0, x], {x, 0, ∞}] // Timing
(* {29.8125, 1} *)

\$Version


## (* "11.3.0 for Microsoft Windows (64-bit) (March 7, 2018)" *)

Original post

The following returns unevaluated in WolframAlpha. Also in my machine Mathematica needs quite a lot of time to compute it.

In[720]:= Integrate[BesselJ[0, x], {x, 0, \[Infinity]}] // Timing
Out[720]= {26.520170, 1}


I am puzzled because I thought such integrals are well tabulated in Mathematica.

At least the numerical integration is performed very quickly.

In[721]:= NIntegrate[BesselJ[0, x], {x, 0, \[Infinity]}] // Timing
Out[721]= {0.826805, 1.}


EDIT

As J. M. is back suggested the following gives the result almost immediately

In[734]:= LaplaceTransform[BesselJ[0, t], t, s] /. s -> 0 // Timing
Out[734]= {0., 1}


For me the poor behavior of Integrate here still remains. What is even worse are the differences between the result of Mathematica and WolframAlpha.

In[761]:= LaplaceTransform[BesselJ[0, t], t, s]
Out[761]= 1/Sqrt[1 + s^2]


whereas WolframAlpha returns

1/(sqrt(1+1/s^2) s)


So you have to type

Limit[1/(sqrt(1+1/s^2) s),s->0]


in order to get finally 1.

EDIT 2

In[2]:= Quit[]

In[1]:= Integrate[BesselJ[0, x], {x, 0, \[Infinity]},
GenerateConditions -> False] // Timing
Out[1]= {26.301769, 1}

In[2]:= Quit[]

In[1]:= Integrate[BesselJ[n, x], {x, 0, \[Infinity]},
GenerateConditions -> False] // Timing
Out[1]= {0.109201, 1}

In[2]:= Quit[]

In[1]:= Integrate[BesselJ[n, x], {x, 0, \[Infinity]},
GenerateConditions -> True] // Timing
Out[1]= {8.049652, ConditionalExpression[1, Re[n] > -1]}


Compare the times 8.049652 (with n and GenerateConditions->True !) and 26.301769 (with n=0).

Rather funny:-)!

EDIT 3 Even more weird...

In[2]:= Quit[]

In[1]:= Integrate[BesselJ[n, x], {x, 0, \[Infinity]},
Assumptions -> n > 0] // Timing
Out[1]= {22.417344, 1}


Compare the times of Assumptions and GenerateConditions->True.

EDIT 4

Apparently something goes very wrong. With a clear kernel I got

Table[Timing[Integrate[BesselJ[0, x], {x, 0, Infinity}]], {i, 1, 10}]
Table[Timing[Integrate[BesselJ[1, x], {x, 0, Infinity}]], {i, 1, 10}]
Table[Timing[Integrate[BesselJ[2, x], {x, 0, Infinity}]], {i, 1, 10}]
Table[Timing[Integrate[BesselJ[3, x], {x, 0, Infinity}]], {i, 1, 10}]


For m >= 4 Mathematica gives the 1 for m odd (same behavior as for m=3). For m even also gives 1 in all cases but needs more than 20 sec per average to evaluate the integral.

I cannot find a reason to explain this behavior which other more experienced users have called it buggy. I think Mathematica makes use of this reference. So apparently something is treated differently for n even.

EDIT 5 I_Mariusz pointed out a workaround. I added here in order to show its performance (if any) in Timing (and since on one hand our comments had misprints and on the other I did not know that Integrate can be compiled).

With a clear kernel I got:

int = Compile[{{x, _Real}},
Integrate[BesselJ[0, x], {x, 0, Infinity},
GenerateConditions -> False]];

Table[int[x] // Quiet // Timing, {10}]


{{26.254968, 1}, {24.897760, 1}, {24.897760, 1}, {20.046128, 1}, {0.046800, 1}, {0.046800, 1}, {0.062400, 1}, {0.062400, 1}, {0.062400, 1}, {0.062400, 1}}

At least now we get 1's in the whole loop!

• As a side remark SageMath returns a rather complicated expression with limits and other special functions while Maple online returns 1 almost immediately maplecloud.maplesoft.com/application.jsp?appId=15195116. Commented Oct 15, 2015 at 9:36
• If you want it quick: LaplaceTransform[BesselJ[0, t], t, s] /. s -> 0 Commented Oct 15, 2015 at 10:09
• Version 5.2 takes 1.9 seconds; version 7, 0.5 seconds; version 8, 2.1 seconds; version 9, 5.1 seconds. After the result is produced for the first time, it is cached and appears instantaneously on subsequent requests. If the situation is much worse in Mathematica 10, I believe you ought to file this with WRI as a performance regression bug. Commented Oct 15, 2015 at 11:17
• Aside from timing, the second attempt at evaluating the integral fails: i.sstatic.net/dWBPV.png -- that strikes me as a bug. Commented Oct 15, 2015 at 17:49
• In any case it is amazing. I did not know for this usage of Compile. Integrate can be compiled? I do not see it here (I think so) mathematica.stackexchange.com/questions/1096/… Commented Oct 16, 2015 at 11:05

I think this is not a answer but can serve as a summary of the useful workarounds. Still we do not have a rigorous explanation of the buggy (?) behavior.

Since

Integrate[BesselJ[0, x], {x, 0, \[Infinity]}] // Timing
(*{27.112974, 1}*)


J. M. is back suggested the following which gives the result almost immediately.

LaplaceTransform[BesselJ[0, t], t, s] /. s -> 0 // Timing
(*{0., 1}*)


In WolframAlpha we will get 1/(sqrt(1+1/s^2) s) from the LaplaceTransform so we need in addition Limit[1/(sqrt(1+1/s^2) s),s->0].

Integration with generic n gives the correct result but still the time is very large.

Integrate[BesselJ[n, x], {x, 0, \[Infinity]}] // Timing
(*{11.731275, ConditionalExpression[1, Re[n] > -1]}*)

Integrate[BesselJ[n, x], {x, 0, \[Infinity]},
Assumptions -> n \[Element] Reals] // Timing
(*{29.780591, ConditionalExpression[1, n > -1]}*)


As a workaround we can ignore the conditions

ClearSystemCache[]
Integrate[BesselJ[n, x], {x, 0, \[Infinity]},
GenerateConditions -> False] // Timing
(*{0.093601, 1}*)


or more rigorous (after B. Hanlon)

 Simplify[Integrate[BesselJ[n, x], {x, 0, \[Infinity]}, GenerateConditions -> True], n > -1] // Timing
(*{11.778075, 1}*)


Another interesting workaround is by I_Mariusz

int = Compile[{{x, _Real}},
Integrate[BesselJ[0, x], {x, 0, Infinity},
GenerateConditions -> False]];

Table[int[x] // Quiet // Timing, {10}]


{{26.254968, 1}, {24.897760, 1}, {24.897760, 1}, {20.046128, 1}, {0.046800, 1}, {0.046800, 1}, {0.062400, 1}, {0.062400, 1}, {0.062400,1}, {0.062400, 1}}

Notice that

Table[Timing[Integrate[BesselJ[0, x], {x, 0, Infinity}]], {i, 1, 10}]


returns only the first three iterations corrected.

• The Laplace route can be used for arbitrary order. Commented Oct 16, 2015 at 14:28
• Of course! I should have added it! Commented Oct 16, 2015 at 14:32