Python double integral taking too long to compute

Question

I am trying to compute the fresnel integral over a grid of coordinates using dblquad . But its taking very long and finally it's not giving any result.

Below is my code. In this code I integrated only over a 10 x 10 grid but I need to integrate at least over a 500 x 500 grid.

import time
st = time.time()
import pylab
import scipy.integrate as inte
import numpy as np
print 'imhere 0'
def sinIntegrand(y,x, X , Y):
    a = 0.0001
    R = 2e-3
    z = 10e-3
    Lambda = 0.5e-6
    alpha = 0.01
    k  = np.pi * 2 / Lambda
    return  np.cos(k * (((x-R)**2)*a + (R-(x**2 + y**2)) * np.tan(np.radians(alpha)) + ((x - X)**2 + (y - Y)**2) / (2 * z)))
print 'im here 1'
def cosIntegrand(y,x,X,Y):
    a = 0.0001
    R = 2e-3
    z = 10e-3
    Lambda = 0.5e-6
    alpha = 0.01
    k  = np.pi * 2 / Lambda
    return  np.sin(k * (((x-R)**2)*a + (R-(x**2 + y**2)) * np.tan(np.radians(alpha)) + ((x - X)**2 + (y - Y)**2) / (2 * z)))
def y1(x,R = 2e-3):
    return (R**2 - x**2)**0.5
def y2(x, R = 2e-3):
   return -1*(R**2 - x**2)**0.5
points = np.linspace(-1e-3,1e-3,10)
points2 = np.linspace(1e-3,-1e-3,10)
yv,xv = np.meshgrid(points , points2)
#def integrate_on_grid(func, lo, hi,y1,y2):
#    """Returns a callable that can be evaluated on a grid."""
#    return np.vectorize(lambda n,m: dblquad(func, lo, hi,y1,y2,(n,m))[0])
#
#intensity = abs(integrate_on_grid(sinIntegrand,-1e-3 ,1e-3,y1, y2)(yv,xv))**2 + abs(integrate_on_grid(cosIntegrand,-1e-3 ,1e-3,y1, y2)(yv,xv))**2
Intensity = []
print 'im here2'
for i in points:
    row = []
    for j in points2:
        print 'im here'
        intensity = abs(inte.dblquad(sinIntegrand,-1e-3 ,1e-3,y1, y2,(i,j))[0])**2 + abs(inte.dblquad(cosIntegrand,-1e-3 ,1e-3,y1, y2,(i,j))[0])**2
        row.append(intensity)
    Intensity.append(row)
Intensity = np.asarray(Intensity)
pylab.imshow(Intensity,cmap = 'gray')
pylab.show()
print str(time.time() - st)

I would really appreciate if you could tell any better way of doing this.

Answer 1

Using a scipy.integrate.dblquad to calculate every pixel of your image is going to be slow in any case.

You should try rewriting your mathematical problem so you can use some classical function in scipy.special instead. For instance, scipy.special.fresnel might work, although it is 1D and your problem seems to be in 2D. Otherwise, that there is a relationship between the Fresnel integral and the incomplete Gamma function ( scipy.special.gammainc ), if that helps.

If none of this work, as a last resort you can spend time optimizing your code and adapting it to Cython. This it will probably give a speed up of a factor of 10 to 100 (see this answer ). Though this wouldn't be sufficient to go from a grid 10x10 to a grid 500x500 .