Mathematica Stack Exchange is a question and answer site for users of Mathematica. Join them; it only takes a minute:

Sign up
Here's how it works:
  1. Anybody can ask a question
  2. Anybody can answer
  3. The best answers are voted up and rise to the top

NDSolve has an interface for repeatedly solving an equation with different initial conditions without having to analyze the equation and set up the solving algorithm each time. This can improve performance dramatically. For example,

In[1]:= nd = First@NDSolve`ProcessEquations[{y'[t] == -y[t], y[0] == 1}, {y}, t]

Out[1]= NDSolve`StateData[<0.>] 

In[2]:= solve[y0_] := Module[{}, nd = First@NDSolve`Reinitialize[nd, y[0] == y0]; 
                       NDSolve`Iterate[nd, 1]; NDSolve`ProcessSolutions[nd]]

In[3]:= Timing[NDSolve[{y'[t] == -y[t], y[0] == #}, {y}, {t, 0, 1}] & /@Range[0.001, 1, 0.001]] // First

Out[3]= 0.527396

In[4]:= Timing[solve /@ Range[0.001, 1, 0.001]] // First

Out[4]= 0.250309

Is there an analogous interface to NIntegrate that would allow me to process the integral once, then do integrations using the same integration method (as chosen by NIntegrate) repeatedly using different constants in the integrand and/or different limits of integration?

share|improve this question
This is very cool. I need to add this to one of the answers I put up yesterday. The second part inherently requires symbolic integration. – Mike Bailey Jan 18 '12 at 18:49
up vote 16 down vote accepted

NIntegrate performs a certain symbolic processing of the integrand to detect discontinuities, singularities, to determine the method to choose and so on.

If you know the integrand pretty well, the way to reduce the overhead is to set the method explicitly, set its SymbolicProcessing suboption to 0 (to allow to time spent on the preprocessing), and to add points of discontinuities to the path explicitly.

This can make a significant difference in timing:

In[66]:= Do[
  NIntegrate[Piecewise[{{x^2, x <= 1}}, 1/1 + x], {x, 0, 1, 2}, 
   Method -> {"GaussKronrodRule", 
     "SymbolicProcessing" -> 0}], {10^3}] // AbsoluteTiming

Out[66]= {1.542154, Null}

In[67]:= Do[
   Piecewise[{{x^2, x <= 1}}, 1/1 + x], {x, 0, 
    2}], {10^3}] // AbsoluteTiming

Out[67]= {15.063506, Null}
share|improve this answer
As there haven't been any other answers to the contrary, I shall conclude that the answer is "no". – JxB Jan 30 '12 at 23:30
@jXB Yes, to the best of my knowledge, the answer is "no". – Sasha Jan 30 '12 at 23:54

Your Answer


By posting your answer, you agree to the privacy policy and terms of service.

Not the answer you're looking for? Browse other questions tagged or ask your own question.