Faster Numerical Integral implementation

I'm writing a program for finding the min of GMM. However, there is a lot of numerical integration in my GMM function and that's slowing my program down. I tried to write my own integration function using the Simpson's method. However, the values aren't very accurate compared with matlab's builtin integral function. I'm wondering what method does the builtin integral function use. Maybe there is a faster way to implement it? Thanks!

Answer 1

[Walter Roberson]

http://www.mathworks.com/help/matlab/numerical-integration-and-differentiation.html

The different routines have different strengths. For example some of them cannot infinite range and others can. Some of them cannot handle a singularity at all and others can in some conditions.

The numeric integration routines are not able to analyze the function being integrated: they can only sample the outputs at particular locations and try to make guesses from there. The symbolic integration routines (Symbolic Toolbox) are able to examine the function to better figure out where the limitations might lie.

Does the function to be integrated have a closed form integral? If so then if you have access to the symbolic toolbox, do the symbolic integration once and use matlabFunction() to convert the result to an anonymous function that can be evaluated numerically.

Some numeric integration routines can work better if they have access to the gradient, so you could pre-calculate the gradient function and supply that to integration.

[Hao]

Thanks for your reply! Unfortunately I don't think the integrand has a closed form integral. However, I think the gradient can be easily computed. How exactly would I use the gradient to help compute the numerical integration?

It's only a single integral with one variable. But I'm trying to find the min and therefore would have to iterate it many times (on orders of 10,000) with different parameter values. And then repeat this process for 100 or 1000 times as it's a monte carlo study.

Answer 2

[Meysam Mahooti]

You can use my Runge-Kutta_Fehlberg(RKF78) implementation which is faster and more accurate than MATLAB ODE45 function.

https://www.mathworks.com/matlabcentral/fileexchange/61130-runge-kutta-fehlberg-rkf78

Moreover, you can use my Radau||A implementation for fast and precise numerical integration.

https://www.mathworks.com/matlabcentral/fileexchange/56162-radau-iia

options = rdpset('RelTol',1e-13,'AbsTol',1e-16);

% options: numerical error tolerance

[t,yout] = radau(@Accel,(0:Step:N_Step*Step),Y0,options);

% @Accel: function handle

% (0:Step:N_Step*Step): time span of integration

% Y0: Initial Values