def doCompute():
    inlFactor = xa.SI['zstep'] / xa.SI['inldist'] * xa.SI['dipFactor']
    crlFactor = xa.SI['zstep'] / xa.SI['crldist'] * xa.SI['dipFactor']
    zw = xa.params['ZSampMargin']['Value'][1] - xa.params['ZSampMargin'][
        'Value'][0] + 1
    filt = xa.params['Select']['Selection']
    filtFunc = autojit(xl.vecmean) if filt == 0 else autojit(
        xl.vmf_l1) if filt == 1 else autojit(xl.vmf_l2)
    while True:
        xa.doInput()

        dx = -xa.Input['Inl_dip'] / inlFactor
        dy = -xa.Input['Crl_dip'] / crlFactor
        dz = np.ones(dx.shape)
        s = np.sqrt(dx * dx + dy * dy + dz * dz)
        #
        #	Apply the Vector Filter
        out = np.empty((3, xa.TI['nrsamp']))
        xl.vecFilter(np.array([dx / s, dy / s, dz / s]), zw, filtFunc, out)
        #
        #	Get the output
        xa.Output['Crl_dip'] = -out[1, :] / out[2, :] * crlFactor
        xa.Output['Inl_dip'] = -out[0, :] / out[2, :] * inlFactor
        xa.Output['True Dip'] = np.sqrt(
            xa.Output['Crl_dip'] * xa.Output['Crl_dip'] +
            xa.Output['Inl_dip'] * xa.Output['Inl_dip'])
        xa.Output['Dip Azimuth'] = np.degrees(
            np.arctan2(xa.Output['Inl_dip'], xa.Output['Crl_dip']))
        xa.doOutput()
Example #2
0
 def compiled(self):
     # Compile it if this is the first time.
     if (not hasattr(self, '_compiled')) and NUMBA_AVAILABLE:
         if self.autojit_kw is not None:
             self._compiled = numba.autojit(**self.autojit_kw)(self.func)
         else:
             self._compiled = numba.autojit(self.func)
     return self._compiled
Example #3
0
    def test_autojit(self):
        with warnings.catch_warnings(record=True) as w:
            warnings.simplefilter("always")

            def dummy():
                pass
            autojit(dummy)
            self.assertEqual(len(w), 1)
Example #4
0
 def compiled(self):
     # Compile it if this is the first time.
     if (not hasattr(self, '_compiled')) and NUMBA_AVAILABLE:
         if self.autojit_kw is not None:
             self._compiled = numba.autojit(**self.autojit_kw)(self.func)
         else:
             self._compiled = numba.autojit(self.func)
     return self._compiled
Example #5
0
    def test_autojit(self):
        with warnings.catch_warnings(record=True) as w:
            warnings.simplefilter("always")

            def dummy():
                pass

            autojit(dummy)
            self.assertEqual(len(w), 1)
Example #6
0
def doCompute():
	xs = xa.SI['nrinl']
	ys = xa.SI['nrcrl']
	zs = xa.params['ZSampMargin']['Value'][1] - xa.params['ZSampMargin']['Value'][0] + 1
	filt = xa.params['Select']['Selection']
	filtFunc = autojit(xl.vecmean) if filt==0 else  autojit(xl.vmf_l1) if filt==1 else autojit(xl.vmf_l2)
	inlFactor = xa.SI['zstep']/xa.SI['inldist'] * xa.SI['dipFactor']
	crlFactor = xa.SI['zstep']/xa.SI['crldist'] * xa.SI['dipFactor']
	band = xa.params['Par_1']['Value']
	zw = min(2*int(xa.params['Par_0']['Value'])+1,3)
	N = xa.params['ZSampMargin']['Value'][1]
	kernel = xl.hilbert_kernel(N, band)
	while True:
		xa.doInput()

		indata = xa.Input['Input']
#
#	Analytic Signal
#
		ansig = np.apply_along_axis(np.convolve,-1, indata, kernel, mode="same")
		sr = np.real(ansig)
		si = np.imag(ansig)
#
#	Compute partial derivatives
		sx = xl.kroon3( sr, axis=0 )
		sy = xl.kroon3( sr, axis=1 )
		sz = xl.kroon3( sr, axis=2 )
		shx = xl.kroon3( si, axis=0 )
		shy = xl.kroon3( si, axis=1 )
		shz = xl.kroon3( si, axis=2 )
		
		px = sr[1:xs-1,1:ys-1,:] * shx[1:xs-1,1:ys-1,:] - si[1:xs-1,1:ys-1,:] * sx[1:xs-1,1:ys-1,:]
		py = sr[1:xs-1,1:ys-1,:] * shy[1:xs-1,1:ys-1,:] - si[1:xs-1,1:ys-1,:] * sy[1:xs-1,1:ys-1,:]
		pz = sr[1:xs-1,1:ys-1,:] * shz[1:xs-1,1:ys-1,:] - si[1:xs-1,1:ys-1,:] * sz[1:xs-1,1:ys-1,:]
#
#	Normalise the gradients so Z component is positive
		p = np.sign(pz)/np.sqrt(px*px+py*py+pz*pz)
		px *= p
		py *= p
		pz *= p
#
#	Filter
		out = np.empty((3,xa.TI['nrsamp']))
		xl.vecFilter(np.array([px,py,pz]), zw, filtFunc, out)
#
#	Get the output
		xa.Output['Crl_dip'] = -out[1,:]/out[2,:]*crlFactor
		xa.Output['Inl_dip'] = -out[0,:]/out[2,:]*inlFactor
		xa.Output['True Dip'] = np.sqrt(xa.Output['Crl_dip']*xa.Output['Crl_dip']+xa.Output['Inl_dip']*xa.Output['Inl_dip'])
		xa.Output['Dip Azimuth'] = np.degrees(np.arctan2(xa.Output['Inl_dip'],xa.Output['Crl_dip']))

		xa.doOutput()
Example #7
0
def compare_perf(fn, args, numba= True, cpython = True):
  
  parakeet_fn = jit(fn)
  name = fn.__name__
  parakeet_result = None
  numba_result = None 
  cpython_result = None 

  with timer('Parakeet #1 -- %s' % name):
    parakeet_result = parakeet_fn(*args)

  with timer('Parakeet #2 -- %s' % name):
    parakeet_result = parakeet_fn(*args)

  if numba:
    numba_fn = autojit(fn)

    with timer('Numba #1 -- %s' % name):
      numba_result = numba_fn(*args)

    with timer('Numba #2 -- %s' % name):
      numba_result = numba_fn(*args)
  
  if parakeet_result is not None and numba_result is not None:  
    assert np.allclose(parakeet_result, numba_result)  
  
  if cpython:
    with timer('Python -- %s' % name):
      python_result = fn(*args)

  if cpython_result is not None and parakeet_result is not None:
    assert np.allclose(parakeet_result, python_result)  
Example #8
0
def create_numba_funcs(scalar_type=SCALAR_TYPE):
    this = sys.modules[__name__]

    pixel_type = scalar_type[:]
    image_type = scalar_type[:, :, :]
    state_type = scalar_type[:, :, :]

    this._numba_window_floor = jit(nopython=True,
                                   argtypes=[size_t, size_t],
                                   restype=size_t)(_py_window_floor)

    this._numba_window_ceil = jit(nopython=True,
                                  argtypes=[size_t, size_t, size_t],
                                  restype=size_t)(_py_window_ceil)

    this._numba_distance = jit(nopython=True,
                               argtypes=[image_type,
                                         size_t, size_t, size_t, size_t],
                               restype=scalar_type)(_py_distance)

    this._numba_np_distance = jit(nopython=False,
                                  argtypes=[pixel_type, pixel_type],
                                  restype=scalar_type)(_py_np_distance)

    this._numba_g = jit(nopython=True,
                        argtypes=[scalar_type],
                        restype=scalar_type)(_py_g)

    this._numba_np_g = jit(nopython=False,
                           argtypes=[pixel_type, pixel_type],
                           restype=scalar_type)(_py_np_g)

    this._numba_kernel = autojit(nopython=True)(_py_kernel)
Example #9
0
def sqr_dists_loops(X,Y):
    xs = X.shape[0]
    ys = Y.shape[0]
    D = np.zeros((xs, ys), dtype=X.dtype)
    for i in range(xs):
        for j in range(ys):
            D[i,j] = np.sqrt(np.sum((X[i,:] - Y[j,:])**2))
    return D
    
    ndims = 3000
    nsamples = 1e5
    nclusters = 1
    X = np.random.randn(nsamples, ndims)
    Y = np.random.randn(nclusters, ndims)
    
    # scipy cdist - 20.83 secs
    start = datetime.now()
    dsci = cdist(X,Y, 'minkowski', p=2)
    stop = datetime.now()
    print("\n\n\t\tScript Running Time: %s"%str(stop - start))
    
    ## Numba - 0.54 secs
    numba_dists = numba.autojit(sqr_dists_loops)
    
    start = datetime.now()
    dnumba = numba_dists(X,Y)
    stop = datetime.now()
    print("\n\n\t\tScript Running Time: %s"%str(stop - start))
    
Example #10
0
def create_numba_funcs(scalar_type=SCALAR_TYPE):
    this = sys.modules[__name__]

    pixel_type = scalar_type[:]
    image_type = scalar_type[:, :, :]
    state_type = scalar_type[:, :, :]

    this._numba_window_floor = jit(nopython=True,
                                   argtypes=[size_t, size_t],
                                   restype=size_t)(_py_window_floor)

    this._numba_window_ceil = jit(nopython=True,
                                  argtypes=[size_t, size_t, size_t],
                                  restype=size_t)(_py_window_ceil)

    this._numba_distance = jit(
        nopython=True,
        argtypes=[image_type, size_t, size_t, size_t, size_t],
        restype=scalar_type)(_py_distance)

    this._numba_np_distance = jit(nopython=False,
                                  argtypes=[pixel_type, pixel_type],
                                  restype=scalar_type)(_py_np_distance)

    this._numba_g = jit(nopython=True,
                        argtypes=[scalar_type],
                        restype=scalar_type)(_py_g)

    this._numba_np_g = jit(nopython=False,
                           argtypes=[pixel_type, pixel_type],
                           restype=scalar_type)(_py_np_g)

    this._numba_kernel = autojit(nopython=True)(_py_kernel)
Example #11
0
def compare_perf(fn, args, numba= True, cpython = True):
  
  parakeet_fn = jit(fn)
  
  with timer('Parakeet #1'):
    parakeet_result = parakeet_fn(*args)

  with timer('Parakeet #2'):
    parakeet_result = parakeet_fn(*args)

  if numba:
    numba_fn = autojit(fn)

    with timer('Numba #1'):
      numba_result = numba_fn(*args)

    with timer('Numba #2'):
      numba_result = numba_fn(*args)
  
    assert np.allclose(parakeet_result, numba_result)  
  
  if cpython:
    with timer('Python'):
      python_result = fn(*args)
    assert np.allclose(parakeet_result, python_result)  
 def __init__(self, x, y, z, spatial_resolution, spectrum):
     
     self.x = x
     """
     Size of field in x-direction.
     """
     self.y = y
     """
     Size of field in y-direction.
     """
     self.z = z
     """
     Size of field in z-direction.
     """
     self.spatial_resolution = spatial_resolution
     """
     Spatial resolution.
     """
     self.spectrum = spectrum
     """
     Spectrum.
     """
     
     try:
         self._generate = numba.autojit(_generate)
     except NameError:
         self._generate = _generate
def doCompute():
	xs = xa.SI['nrinl']
	ys = xa.SI['nrcrl']
	zs = xa.params['ZSampMargin']['Value'][1] - xa.params['ZSampMargin']['Value'][0] + 1
	zw = zs-2
	filt = xa.params['Select']['Selection']
	filtFunc = autojit(xl.vecmean) if filt==0 else  autojit(xl.vmf_l1) if filt==1 else autojit(xl.vmf_l2)
	inlFactor = xa.SI['zstep']/xa.SI['inldist'] * xa.SI['dipFactor']
	crlFactor = xa.SI['zstep']/xa.SI['crldist'] * xa.SI['dipFactor']
	while True:
		xa.doInput()

		s = xa.Input['Input']
		sh = np.imag( hilbert(s) ) 
#
#	Compute partial derivatives
		sx = xl.kroon3( s, axis=0 )
		sy = xl.kroon3( s, axis=1 )
		sz = xl.kroon3( s, axis=2 )
		shx = xl.kroon3( sh, axis=0 )
		shy = xl.kroon3( sh, axis=1 )
		shz = xl.kroon3( sh, axis=2 )
		
		px = s[1:xs-1,1:ys-1,:] * shx[1:xs-1,1:ys-1,:] - sh[1:xs-1,1:ys-1,:] * sx[1:xs-1,1:ys-1,:]
		py = s[1:xs-1,1:ys-1,:] * shy[1:xs-1,1:ys-1,:] - sh[1:xs-1,1:ys-1,:] * sy[1:xs-1,1:ys-1,:]
		pz = s[1:xs-1,1:ys-1,:] * shz[1:xs-1,1:ys-1,:] - sh[1:xs-1,1:ys-1,:] * sz[1:xs-1,1:ys-1,:]
#
#	Normalise the gradients so Z component is positive
		p = np.sign(pz)/np.sqrt(px*px+py*py+pz*pz)
		px *= p
		py *= p
		pz *= p
#
#	Filter
		out = np.empty((3,xa.TI['nrsamp']))
		xl.vecFilter(np.array([px,py,pz]), zw, filtFunc, out)
#
#	Get the output
		xa.Output['Crl_dip'] = -out[1,:]/out[2,:]*crlFactor
		xa.Output['Inl_dip'] = -out[0,:]/out[2,:]*inlFactor
		xa.Output['True Dip'] = np.sqrt(xa.Output['Crl_dip']*xa.Output['Crl_dip']+xa.Output['Inl_dip']*xa.Output['Inl_dip'])
		xa.Output['Dip Azimuth'] = np.degrees(np.arctan2(xa.Output['Inl_dip'],xa.Output['Crl_dip']))

		xa.doOutput()
Example #14
0
def test(test_n=0):
    entries=100
    if entries == -1 or entries > fee.shape[0]:
        entries = fee.shape[0]

    res_tmp = {}
    #res_tmp["entries"] = [entries]
    
    if test_n==0:
        start_t = time()
        sase_map = dset_loop_chunk(fee, entries)
        print "Numpy chunked loop: %s" % (time() - start_t)
        res_tmp["np chunk"] = [time() - start_t,]
    
    elif test_n==1:   
        start_t = time()
        sase_map = dset_loop_chunk_loop(fee, entries)
        print "Numpy chunked loop loop: %s" % (time() - start_t)
        res_tmp["np chunk loop"] = [time() - start_t,]
    
    elif test_n==2:    
        start_t = time()
        sase_map = dset_loop_chunk_numba(fee, entries)
        print "Numba chunked loop: %s" % (time() - start_t)
        res_tmp["numba chunk"] = [time() - start_t,]

    # very slow!
    #if fee[0].shape[0] < 2000:
    elif test_n==3:
        
        dset_loop_numba = autojit(dset_loop)
        start_t = time()
        sase_map = dset_loop_numba(fee, entries)
        print "Numba loop: %s" % (time() - start_t)
        res_tmp["numba loop"] = [time() - start_t]
    
        # very slow!
    elif test_n==4:
        start_t = time()
        sase_map = dset_loop(fee, entries)
        print "Python loop: %s" % (time() - start_t)
        res_tmp["python loop"] = [time() - start_t]

    elif test_n==5:
        try:
            start_t = time()
            sase_map = fee[:entries].sum(axis=2)
            print "Numpy: %s" % (time() - start_t)
            res_tmp["np"] = [time() - start_t,]
        except:
            res_tmp["np"] = [np.nan]
    #except:
    #    pass

    return res_tmp
Example #15
0
def doCompute():
    xs = xa.SI['nrinl']
    ys = xa.SI['nrcrl']
    zs = xa.params['ZSampMargin']['Value'][1] - xa.params['ZSampMargin'][
        'Value'][0] + 1
    zw = zs - 2
    filt = xa.params['Select']['Selection']
    filtFunc = autojit(xl.vecmean) if filt == 0 else autojit(
        xl.vmf_l1) if filt == 1 else autojit(
            xl.vmf_l2) if filt == 2 else autojit(xl.vmf_x3)
    inlFactor = xa.SI['zstep'] / xa.SI['inldist'] * xa.SI['dipFactor']
    crlFactor = xa.SI['zstep'] / xa.SI['crldist'] * xa.SI['dipFactor']
    while True:
        xa.doInput()

        p = xa.Input['Input']
        #
        #	Compute partial derivatives
        px = xl.kroon3(p, axis=0)[1:xs - 1, 1:ys - 1, :]
        py = xl.kroon3(p, axis=1)[1:xs - 1, 1:ys - 1, :]
        pz = xl.kroon3(p, axis=2)[1:xs - 1, 1:ys - 1, :]
        #
        #	Normalise the gradients so Z component is positive
        p = np.sign(pz) / np.sqrt(px * px + py * py + pz * pz)
        px *= p
        py *= p
        pz *= p
        #
        #	Filter
        out = np.empty((3, xa.TI['nrsamp']))
        xl.vecFilter(np.array([px, py, pz]), zw, filtFunc, out)
        #
        #	Get the output
        xa.Output['Crl_dip'] = -out[1, :] / out[2, :] * crlFactor
        xa.Output['Inl_dip'] = -out[0, :] / out[2, :] * inlFactor
        xa.Output['True Dip'] = np.sqrt(
            xa.Output['Crl_dip'] * xa.Output['Crl_dip'] +
            xa.Output['Inl_dip'] * xa.Output['Inl_dip'])
        xa.Output['Dip Azimuth'] = np.degrees(
            np.arctan2(xa.Output['Inl_dip'], xa.Output['Crl_dip']))

        xa.doOutput()
def doCompute():
	inlFactor = xa.SI['zstep']/xa.SI['inldist'] * xa.SI['dipFactor']
	crlFactor = xa.SI['zstep']/xa.SI['crldist'] * xa.SI['dipFactor']
	zw = xa.params['ZSampMargin']['Value'][1] - xa.params['ZSampMargin']['Value'][0] + 1
	filt = xa.params['Select']['Selection']
	filtFunc = autojit(xl.vecmean) if filt==0 else  autojit(xl.vmf_l1) if filt==1 else autojit(xl.vmf_l2)
	while True:
		xa.doInput()

		dx = -xa.Input['Inl_dip']/inlFactor
		dy = -xa.Input['Crl_dip']/crlFactor
		dz = np.ones(dx.shape)
		s = np.sqrt(dx*dx+dy*dy+dz*dz)
#
#	Apply the Vector Filter
		out = np.empty((3,xa.TI['nrsamp']))
		xl.vecFilter(np.array([dx/s,dy/s,dz/s]), zw, filtFunc, out)
#
#	Get the output
		xa.Output['Crl_dip'] = -out[1,:]/out[2,:]*crlFactor
		xa.Output['Inl_dip'] = -out[0,:]/out[2,:]*inlFactor
		xa.Output['True Dip'] = np.sqrt(xa.Output['Crl_dip']*xa.Output['Crl_dip']+xa.Output['Inl_dip']*xa.Output['Inl_dip'])
		xa.Output['Dip Azimuth'] = np.degrees(np.arctan2(xa.Output['Inl_dip'],xa.Output['Crl_dip']))
		xa.doOutput()
Example #17
0
def main():
    if len(sys.argv) > 1:
        N = int(sys.argv[1])
    else:
        N = 10000

    for name in [
        'sqrt',
        'log',
        'exp',
    ]:
        print '%s python: ' % name,
        func = globals()[name + '_test']
        t = time.time()
        func(N)
        print time.time() - t

        print '%s numba: ' % name,
        func = autojit(func)
        t = time.time()
        func(N)
        print time.time() - t
Example #18
0
def test_valid_compare():
    array_nb = autojit(array)
    a = np.random.rand(1e6)
    assert np.allclose(array(a), array_nb(a))
# Authors: Olivier Grisel
# License: MIT

from pairwise import pairwise_python
from numba import autojit

benchmarks = (("pairwise_numba_nested_for_loops",
               autojit(pairwise_python.pairwise_python_nested_for_loops)), )
Example #20
0
####################
## TEST FUNCTIONS ##
####################

### TRIPLE FOR

def triplefor(taille):
    count = 0
    for i in xrange(taille):
        for j in xrange(taille):
            for k in xrange(taille):
                count += i * j + k
    return count / taille


tripleforN = autojit(triplefor)


#######################
## TIMINGS FUNCTIONS ##
#######################


def timings(nb_tries, start=1, stop=200, step=10):

    values = range(start, stop, step)

    setup = {
        'triplefor': ('triplefor(%s)', 'from __main__ import triplefor'),
        'tripleforN': ('tripleforN(%s)', 'from __main__ import tripleforN'),
        'tripleforC': ('cython_test(%s)', 'from __main__ import cython_test'),
def arma(parameters,data,p=0,q=0):
    T = data.size
    errors = np.zeros_like(data)
    for t in xrange(T):
        errors[t] = data[t] - parameters[0]
        for i in xrange(p):
            if (t-i) >= 0:
                errors[t] -= parameters[i+1] * data[t-i]
        for i in xrange(q):
            if (t-i) >= 0:
                errors[t] -= parameters[i+p+1] * errors[t-i]
    return errors


arma_autojit = autojit(arma)

arma_jit = jit(double[:](double[:],double[:],int32,int32))(arma)


parameters = np.zeros((3))
data = np.random.randn(10000)
p = 1
q = 1



if __name__=='__main__':
    arma(parameters,data,p,q)
    arma_autojit(parameters,data,p,q)
    arma_jit(parameters,data,p,q)
Example #22
0
      arg.start + self.plus,
      arg.stop  + self.plus
    )
  def __rsub__(self, arg):
    return type(arg)(
      arg.start - self.mnus,
      arg.stop  - self.mnus
    )

one = Shift(1,1)
sl = slice(2,5)
print sl+one

try:
    from numba import autojit, jit, double
    fast_f = autojit(f)
    #fast_f = jit(restype=double[:],argtypes=[double[:], double[:], double[:]])(f)
    t0 = time.time()
    output = fast_f(Psi_l, Psi_r, CC)
    print "time: numba", time.time() - t0
    print "output numba", output
except ImportError:
    print "Not using Numba nor Numbapro"

t1 = time.time()
output = f(Psi_l, Psi_r, CC)
print "time: numpy", time.time() - t1
print "output numpy", output


Example #23
0

# ______________________________________________________________________


def _for_loop_fn_3(stop):
    acc = 0
    for i in range(stop):
        for j in range(stop):
            for k in range(stop):
                for l in range(stop):
                    acc += 1
    return acc


for_loop_fn_0 = autojit(backend='ast')(_for_loop_fn_0)
for_loop_fn_1 = autojit(backend='ast')(_for_loop_fn_1)
for_loop_fn_2 = autojit(backend='ast')(_for_loop_fn_2)
for_loop_fn_3 = autojit(backend='ast')(_for_loop_fn_3)

# ______________________________________________________________________


class TestForLoop(unittest.TestCase):
    #    @unittest.skipUnless(__debug__, "Requires implementation of iteration "
    #                         "over arrays.")
    def test_compiled_for_loop_fn_0(self):
        for dtype in (np.float32, np.float64, np.int32, np.int64):
            test_data = np.arange(10, dtype=dtype)
            result = for_loop_fn_0(test_data)
            self.assertEqual(result, 45)
Example #24
0
def test_valid_compare():
    array_nb = autojit(array)
    a = np.random.rand(1e6)
    assert np.allclose(array(a), array_nb(a))
Example #25
0
def tdo_fft(inputfile, outputfile):
    ''' Perform Fourier transform and return frequency evolution '''
    comp_expf = autojit(comp_exp)

    # Input parameters
    fourier_le = 1024  # Fourier length
    time_le = 1024  # timewindow
    dfmin = 100  # Frequency resolution
    dt = 2e-8  # timestep of acquisition

    # Lecture du fichier
    fid = open(inputfile, 'rb')
    fid.seek(512)  # Skip useless header
    V = fromfile(fid, int16, -1, '')
    fid.close()

    pstart = 1  # First timewindow
    pend = int(floor((len(V) - fourier_le) / time_le))  # Last timewindow

    V = V - mean(V)  # Remove zero frequency contribution to FT
    t = arange(0, fourier_le) * dt

    # Approximation of main frequency
    Vf = abs(real(fft(V[0:fourier_le])))
    tf = fftfreq(fourier_le, dt)
    fmax = zeros((pend + 1 - pstart, 3))
    fmax[0, 1] = tf[argmax(Vf[0:int(fourier_le / 2)])]
    fmax[0, 0] = time_le * dt / 2

    # Calculation of constants
    expon = -2j * pi * t
    deltaf0 = tf[1] / 1000

    # Windowing (uncomment desired window function)
    # Rectangular
    window = ones(fourier_le)
    # Cosinus
    #window  =  arange(0,fourier_le)
    #window  =  1-cos(window*2*pi/(fourier_le-1))
    # Kaiser-Bessel
    #window  =  arange(0,fourier_le)
    #window  =  0.402-0.498*cos(window*2*pi/(fourier_le-1))+0.098*cos(window*4*pi/(fourier_le-1))+0.001*cos(window*6*pi/(fourier_le-1))

    # Precise determination of oscillating frequency via DFT
    for i in xrange(pstart, pend):
        # Utilisation de la dernière valeur comme point de depart
        a = fmax[i - 1, 1]
        V_temp = window * V[i * time_le:i * time_le + fourier_le]

        # Previous frequency spectral weight
        # Complex exponential time consuming ! Need a smarter way to perform this calculations
        deltaf = deltaf0
        essaimax = abs(local_trapz(V_temp * comp_expf(expon * a)))

        # Calculation of local derivative of Fourier transform
        # If derivative positive, then search for frequency in growing direction
        if abs(local_trapz(V_temp * comp_expf(expon *
                                              (a + deltaf)))) > essaimax:
            while abs(deltaf) > dfmin:
                F = abs(local_trapz(V_temp * comp_expf(expon * (a + deltaf))))
                if F > essaimax:
                    essaimax = F
                    a += deltaf
                else:
                    deltaf = -deltaf / 5

            # Store frequency
            fmax[i, 0:2] = [(i * time_le + fourier_le / 2) * dt,
                            a - 2.5 * deltaf]
        # Lower frequency otherwise
        else:
            while abs(deltaf) > dfmin:
                F = abs(local_trapz(V_temp * comp_expf(expon * (a - deltaf))))
                if F > essaimax:
                    essaimax = F
                    a -= deltaf
                else:
                    deltaf = -deltaf / 5

            # Store frequency
            fmax[i, 0:2] = [(i * time_le + fourier_le / 2) * dt,
                            a + 2.5 * deltaf]

    # Save calculation in file
    fmax[:, 2] = smooth(fmax[:, 1])[5:-5]
    savetxt(outputfile, fmax)
from growcut import growcut_python
from numba import autojit


benchmarks = (
    ("growcut_numba",
     autojit(growcut_python.growcut_python)),
)
Example #27
0

def primes(limit):
    # Keep only odd numbers in sieve, mapping from index to number is
    # num = 2 * idx + 3
    # The square of the number corresponding to idx then corresponds to:
    # idx2 = 2*idx*idx + 6*idx + 3
    sieve = [True] * (limit // 2)
    prime_numbers = set([2])
    for j in range(len(sieve)):
        if sieve[j]:
            new_prime = 2 * j + 3
            prime_numbers.add(new_prime)
            for k in range((2 * j + 6) * j + 3, len(sieve), new_prime):
                sieve[k] = False
    return list(prime_numbers)


numba_primes = autojit(primes)

start = time()
numba_primes(LIMIT)
end = time()
print("Numba: Time Taken : ", end - start)

start = time()
primes(LIMIT)
end = time()
print("Python: Time Taken : ", end - start)

import d2q9_nsnxny_loop as d2q9
from numba import double, jit, autojit

# m2f = jit('void(f8[:, :, :], f8[:, :, :])')(d2q9.m2f)
# f2m = jit('void(f8[:, :, :], f8[:, :, :])')(d2q9.f2m)
# transport = jit('void(f8[:, :, :])')(d2q9.transport)
# relaxation = jit('void(f8[:, :, :])')(d2q9.relaxation)
# periodic_bc = jit('void(f8[:, :, :])')(d2q9.periodic_bc)

m2f = autojit(d2q9.m2f)
f2m = autojit(d2q9.f2m)
transport = autojit(d2q9.transport)
relaxation = autojit(d2q9.relaxation)
periodic_bc = autojit(d2q9.periodic_bc)

@autojit
def one_time_step(f, m):
    periodic_bc(f)
    transport(f)
    f2m(f, m)
    relaxation(m)
    m2f(m, f)
    

Example #29
0
def compare_perf(fn,
                 args,
                 numba=True,
                 cpython=True,
                 extra={},
                 backends=('c', 'openmp', 'cuda'),
                 suppress_output=False,
                 propagate_exceptions=False):

    parakeet_fn = jit(fn)
    name = fn.__name__
    parakeet_result = None
    numba_result = None
    cpython_result = None
    kwargs = {
        'suppress_stdout': suppress_output,
        'suppress_stderr': suppress_output,
        'propagate_exceptions': propagate_exceptions
    }
    backend = None
    for backend in backends:
        with timer('Parakeet (backend = %s) #1 -- %s' % (backend, name),
                   **kwargs):
            parakeet_result = parakeet_fn(*args, _backend=backend)

        with timer('Parakeet (backend = %s) #2 -- %s' % (backend, name),
                   **kwargs):
            parakeet_result = parakeet_fn(*args, _backend=backend)

    if numba:
        from numba import autojit, config
        numba_fn = autojit(fn)
        with timer('Numba #1 -- %s' % name, **kwargs):
            numba_result = numba_fn(*args)

        with timer('Numba #2 -- %s' % name, **kwargs):
            numba_result = numba_fn(*args)

    if cpython:
        with timer('Python -- %s' % name, **kwargs):
            cpython_result = fn(*args)

    for name, impl in extra.iteritems():
        with timer("%s #1" % name, **kwargs):
            impl(*args)
        with timer("%s #2" % name, **kwargs):
            extra_result = impl(*args)

        if python_result is not None:
            diffs = np.abs(parakeet_result - extra_result)
            assert np.allclose(parakeet_result, extra_result, atol = atol, rtol = rtol), \
              "Max elt difference between Parakeet and %s = %s (median = %s, min = %s)" % \
              (name, np.max(diffs), np.median(diffs), np.min(diffs))

    rtol = 0.0001
    if backend in ('cuda', 'gpu'):
        atol = 0.001
    else:
        atol = 0.00001
    if parakeet_result is not None and cpython_result is not None:
        diffs = np.abs(cpython_result - parakeet_result)
        assert np.allclose(cpython_result, parakeet_result, atol = atol, rtol = rtol), \
          "Max elt difference between Parakeet and CPython = %s (median = %s, min = %s)" % \
          (np.max(diffs), np.median(diffs), np.min(diffs))

    if numba_result is not None and cpython_result is not None:
        diffs = np.abs(cpython_result - numba_result)
        assert np.allclose(cpython_result, numba_result, atol = atol, rtol = rtol), \
          "Max elt difference between Numba and CPython = %s (median = %s, min = %s)" % \
          (np.max(diffs), np.median(diffs), np.min(diffs))
Example #30
0
    julia = np.empty((N, N), dtype=np.uint32)
    grid_x = np.linspace(-bound, bound, N)
    for i, x in enumerate(grid_x):
        for j, y in enumerate(grid_x):
            julia[i,j] = kernel(x, y, cr, ci, lim, cutoff=cutoff)
    return julia

def julia(cr, ci, N, bound=1.5, lim=1000., cutoff=1e6):
   grid_x = np.linspace(-bound, bound, N)
   return np.array([[kernel(x,y,cr,ci,lim,cutoff=cutoff) 
                     for x in grid_x] 
                     for y in grid_x])
                    
from compare_perf import compare_perf 
cr=0.285
ci=0.01
N=1200
bound = 1.5 
lim = 1000
cutoff = 1e6 

extra = {}
try:
  from numba import autojit 
  extra['numba'] = autojit(julia_loops)
except:
  print "Failed to import Numba" 

compare_perf(julia, [cr, ci, N, bound, lim, cutoff], numba = False, extra = extra)

Example #31
0
# function to check if the point is on the polygon
EPSILON = 2


def pointOnPolygon(point, poly):
    for i in range(len(poly)):
        [a, b] = poly[i - 1], poly[i]
        if abs(
                vincenty(a, point, miles=False) +
                vincenty(b, point, miles=False) -
                vincenty(a, b, miles=False)) < EPSILON:
            return True
    return False


pointOnPolygon = autojit(pointOnPolygon)

# compute list of channels that are not available; chan_NA is the list of list of channels not available for the center node

df = pd.read_csv('Columbus_TVData_GradeB_SepDis.csv')
cols_to_use = df.columns
cols_to_use = []
for degree in range(1, 360, 2):
    cols_to_use.append("Latitude." + str(degree))
    cols_to_use.append("Longitude." + str(degree))
dfa = df[cols_to_use]
fr = dfa
fr.values.shape
poly_overall = fr.values.reshape((len(dfa), 180, 2))
path_overall = []
for row in range(0, len(dfa)):
Example #32
0
# Authors: Yuancheng Peng
# License: MIT

from arc_distance import arc_distance_python as adp
from numba import autojit

benchmarks = (("arc_distance_numba_for_loops",
               autojit(adp.arc_distance_python_nested_for_loops)), )
Example #33
0
                break
            ## Bin to the left
            elif xr <= xnewl:
                pass
            ## This condition should not happen
            else:
                pass
            i += 1
        ## Add the sum to ynew
        if weight != 0:
            ynew[ii] = val/weight
        ii += 1
    return ynew

if 'numba' in sys.modules:
    Interp_integrate = autojit(Interp_integrate)

def Resample_linlog(xold):
    """Resample_linlog(xold)
    Resample a linear wavelength vector to a log space and
    returns the new vector and the Doppler shift z.
    
    The resampling is done such that the largest wavelength interval
    is conserved in order to preserve the spectral resolution.
    
    The Doppler shift is:
        1+z = lambda_1 / lambda_0

    In the non-relativistic limit:
        z = v/c
    
import time


def f(n):
    t0 = time.time()
    result = 0.0
    for i in range(n):
        for j in range(n * i):
            result += sin(pi / 2)
    return int(result), time.time() - t0

    n = 250


res_py = f(n)

print "Number of Loops        %8d" % res_py[0]
print "Time in Sec for Python %8.3f" % res_py[1]

import numba as nb

f_nb = nb.autojit(f)

res_nb = f_nb(n)

print "Number of Loops        %8d" % res_nb[0]
print "Time in Sec for Python %8.3f" % res_nb[1]

print "Number of Loops        %8d" % res_py[0]
print "Speed-up of Numba      %8d" % (res_py[1] / res_nb[1])
Example #35
0
def tdo_fft(inputfile, outputfile):
    ''' Perform Fourier transform and return frequency evolution '''
    comp_expf=autojit(comp_exp)    
    
    # Input parameters
    fourier_le = 1024   # Fourier length
    time_le    = 1024   # timewindow
    dfmin      = 100      # Frequency resolution
    dt         = 2e-8   # timestep of acquisition
    
    # Lecture du fichier
    fid = open(inputfile, 'rb')
    fid.seek(512)   # Skip useless header
    V = fromfile(fid, int16, -1, '')  
    fid.close()
    
    pstart     = 1      # First timewindow
    pend       = int(floor((len(V)-fourier_le)/time_le)) # Last timewindow
    
    V = V-mean(V)  # Remove zero frequency contribution to FT
    t = arange(0, fourier_le)*dt
    
    # Approximation of main frequency
    Vf         = abs(real(fft(V[0:fourier_le])))
    tf         = fftfreq(fourier_le, dt)
    fmax       = zeros((pend+1-pstart, 3))
    fmax[0, 1] = tf[argmax(Vf[0:int(fourier_le/2)])]
    fmax[0, 0] = time_le*dt/2
    
    # Calculation of constants
    expon   = -2j*pi*t
    deltaf0 =  tf[1]/1000
    
    # Windowing (uncomment desired window function)
    # Rectangular    
    window  =  ones(fourier_le)    
    # Cosinus    
    #window  =  arange(0,fourier_le)
    #window  =  1-cos(window*2*pi/(fourier_le-1))
    # Kaiser-Bessel    
    #window  =  arange(0,fourier_le)
    #window  =  0.402-0.498*cos(window*2*pi/(fourier_le-1))+0.098*cos(window*4*pi/(fourier_le-1))+0.001*cos(window*6*pi/(fourier_le-1))    
    
    
    # Precise determination of oscillating frequency via DFT    
    for i in xrange(pstart, pend):
        # Utilisation de la dernière valeur comme point de depart
        a = fmax[i-1, 1]
        V_temp = window*V[i*time_le:i*time_le+fourier_le]
        
        # Previous frequency spectral weight
        # Complex exponential time consuming ! Need a smarter way to perform this calculations
        deltaf = deltaf0
        essaimax=abs(local_trapz(V_temp*comp_expf(expon*a)))
        
        # Calculation of local derivative of Fourier transform
        # If derivative positive, then search for frequency in growing direction
        if abs(local_trapz(V_temp*comp_expf(expon*(a+deltaf)))) > essaimax:
            while abs(deltaf)>dfmin:
                F = abs(local_trapz(V_temp*comp_expf(expon*(a+deltaf))))
                if F > essaimax:
                    essaimax = F
                    a += deltaf
                else:
                    deltaf = -deltaf/5
                    
            # Store frequency
            fmax[i, 0:2] = [(i*time_le+fourier_le/2)*dt, a-2.5*deltaf]
        # Lower frequency otherwise
        else:        
            while abs(deltaf)>dfmin:
                F = abs(local_trapz(V_temp*comp_expf(expon*(a-deltaf))))
                if F > essaimax:
                    essaimax = F
                    a -= deltaf
                else:
                    deltaf = -deltaf/5
        
            # Store frequency
            fmax[i, 0:2] = [(i*time_le+fourier_le/2)*dt, a+2.5*deltaf]
        
    # Save calculation in file
    fmax[:,2] = smooth(fmax[:,1])[5:-5]
    savetxt(outputfile, fmax)
Example #36
0

def regridx(Variable):
    '''Regrids Xp1 to X (Time averaged)
       Future : check if 4 dimentions for 
       non timeaveraged?
    '''
    if len(np.shape(Variable)) == 4:
        Vc = (Variable[:, :, :, 0:-1] + Variable[:, :, :, 1::]) / 2
    else:
        Vc = (Variable[:, :, 0:-1] + Variable[:, :, 1::]) / 2
    return Vc


# Numba them
numba_regridy = autojit()(regridy)
numba_regridy.func_name = "numba_regridy"
numba_regridz = autojit()(regridz)
numba_regridz.func_name = "numba_regridz"
numba_regridx = autojit()(regridx)
numba_regridx.func_name = "numba_regridx"


def maxmag(var):
    m1 = np.max(var, axis=0)
    m2 = np.min(var, axis=0)
    if m1 < abs(m2):
        val = m2
    else:
        val = m1
Example #37
0
with timer('Python (comprehensions)'):
    sqr_dists(X, Y)

with timer('Python (loops)'):
    sqr_dists_loops(X, Y)

#
# Numba
#

import numba

#
# Numba's @autojit just like Parakeet's @jit
#
numba_dists = numba.autojit(sqr_dists)

with timer('Numba (comprehensions) #1'):
    numba_dists(X, Y)

with timer('Numba (comprehensions) #2'):
    numba_dists(X, Y)

numba_dists_loops = numba.autojit(sqr_dists_loops)

with timer('Numba (loops) #1'):
    numba_dists_loops(X, Y)

with timer('Numba (loops) #2'):
    numba_dists_loops(X, Y)
Example #38
0
with timer('Python (loops)'):
  sqr_dists_loops(X,Y)



#
# Numba 
#

import numba

#
# Numba's @autojit just like Parakeet's @jit
#
numba_dists = numba.autojit(sqr_dists)

with timer('Numba (comprehensions) #1'):
  numba_dists(X,Y)

with timer('Numba (comprehensions) #2'):
  numba_dists(X,Y)

numba_dists_loops = numba.autojit(sqr_dists_loops)

with timer('Numba (loops) #1'):
  numba_dists_loops(X,Y)

with timer('Numba (loops) #2'):
  numba_dists_loops(X,Y)
    for t in range(1, 1501):
        train_sum = np.zeros(x_train.shape[0])
        test_sum = np.zeros(x_test.shape[0])
        for i in range(t):
            train_sum += alphas[i] * linearPred(x_train, ls_w_arr[i])
            test_sum += alphas[i] * linearPred(x_test, ls_w_arr[i])
        train_err_arr[t - 1] = np.sum(
            y_train != np.sign(train_sum)) / y_train.shape[0]
        test_err_arr[t -
                     1] = np.sum(y_test != np.sign(test_sum)) / y_test.shape[0]
    return train_err_arr, test_err_arr


# In[105]:

autojit(linearPred)
autojit(train_test_errors)

# In[106]:

train_err_arr, test_err_arr = train_test_errors(bd.x_train, bd.x_test,
                                                bd.y_train, bd.y_test, alphas,
                                                ls_w_arr)

# In[107]:

plt.figure()
sb.axes_style("darkgrid")
plt.plot(range(1, 1501), train_err_arr, 'g', label="training error")
plt.plot(range(1, 1501), test_err_arr, 'r', label="testing error")
plt.xlabel("Iteratons t")
Example #40
0
def compare_perf(fn, args, numba= True, cpython = True, 
                 extra = {}, 
                 backends = ('c', 'openmp', 'cuda'), 
                 suppress_output = False,
                 propagate_exceptions = False):

  
  parakeet_fn = jit(fn)
  name = fn.__name__
  parakeet_result = None
  numba_result = None 
  cpython_result = None 
  kwargs = {'suppress_stdout': suppress_output, 
            'suppress_stderr':suppress_output,
            'propagate_exceptions' : propagate_exceptions
           }
  backend = None 
  for backend in backends:
    with timer('Parakeet (backend = %s) #1 -- %s' % (backend, name), **kwargs):
      parakeet_result = parakeet_fn(*args, _backend = backend)

    with timer('Parakeet (backend = %s) #2 -- %s' % (backend, name), **kwargs):
      parakeet_result = parakeet_fn(*args, _backend = backend)

  if numba:
    from numba import autojit, config 
    numba_fn = autojit(fn)
    with timer('Numba #1 -- %s' % name, **kwargs):
      numba_result = numba_fn(*args)

    with timer('Numba #2 -- %s' % name, **kwargs):
      numba_result = numba_fn(*args)

  if cpython:
    with timer('Python -- %s' % name, **kwargs):
      cpython_result = fn(*args)
  
  
  for name, impl in extra.iteritems():
    with timer("%s #1" % name, **kwargs):
      impl(*args)
    with timer("%s #2" % name, **kwargs):
      extra_result = impl(*args)


    if python_result is not None:
      diffs = np.abs(parakeet_result - extra_result)
      assert np.allclose(parakeet_result, extra_result, atol = atol, rtol = rtol), \
        "Max elt difference between Parakeet and %s = %s (median = %s, min = %s)" % \
        (name, np.max(diffs), np.median(diffs), np.min(diffs))

  rtol = 0.0001
  if backend in ('cuda', 'gpu'):
    atol = 0.001
  else:
    atol = 0.00001
  if parakeet_result is not None and cpython_result is not None:
      diffs = np.abs(cpython_result - parakeet_result)
      assert np.allclose(cpython_result, parakeet_result, atol = atol, rtol = rtol), \
        "Max elt difference between Parakeet and CPython = %s (median = %s, min = %s)" % \
        (np.max(diffs), np.median(diffs), np.min(diffs))
  
  if numba_result is not None and cpython_result is not None:
      diffs = np.abs(cpython_result - numba_result)
      assert np.allclose(cpython_result, numba_result, atol = atol, rtol = rtol), \
        "Max elt difference between Numba and CPython = %s (median = %s, min = %s)" % \
        (np.max(diffs), np.median(diffs), np.min(diffs))
# Authors: Olivier Grisel
# License: MIT

from pairwise import pairwise_python
from numba import autojit


benchmarks = (
    ("pairwise_numba_nested_for_loops",
     autojit(pairwise_python.pairwise_python_nested_for_loops)),
)
Example #42
0
                         ii] = np.apply_along_axis(interp, 0, ZFF, Z[::-1],
                                                   Vc[tt, ::-1, jj, ii])
                    for kk in range(len(ZFF)):
                        Tpff[tt, kk, jj,
                             ii] = find_nearest(Rho, Tpff[tt, kk, jj, ii])
        Vprime = Vpff - VTavff
        Tprime = Tpff[:] - TTavffbin[:]
        VTprime = Vprime * Tprime
        VTprimetav = np.mean(VTprime, axis=0)
        VTprimetav20 = (VTprimetav20 + VTprimetav / (6 * total))
        VTbar = np.mean(Vpff * Tpff, axis=0)
        VTbar20 = VTbar20 + VTbar / (6 * total)
    return VTprimetav20, VTbar20


numba_eddyfluxbin = autojit()(eddyfluxbin)
numba_eddyfluxbin.func_name = "eddyfluxbin"
# Here we go...
print 'Setup done... starting flux calc'
for file in lists:
    print file  # Where am i?
    #VTprimetav20, VTbar20 = numba_eddyfluxbin(file, VTprimetav20,
    #                                          VTbar20, 'VVEL')
    file2 = netCDF4.Dataset(file, 'r')
    Temp = file2.variables['THETA'][:]
    V = file2.variables['VVEL'][:]
    Vc = numba_regridy(V)
    for yr in range((6)):
        yr1 = 100 * yr
        yr2 = yr1 + 100
        Vc = Vc[yr1:yr2]
Example #43
0
 def test():
     f_ = autojit(f)
     for v in range(-10,10):
         assert f_(v)==f(v)
         assert f_(float(v))==f(float(v))
from julia import julia_python
from numba import autojit

benchmarks = (("julia_numba_for_loops",
               autojit(julia_python.julia_python_for_loops)), )
# Authors: Yuancheng Peng
# License: MIT

from arc_distance import arc_distance_python
from numba import autojit

benchmarks = (
        ("arc_distance_numba_for_loops",
        autojit(arc_distance_python.arc_distance_python_nested_for_loops)),
)
Example #46
0
 def test_ifexp():
     f_ = autojit(f)
     for args in product(range(3), range(3)):
         assert f_(*args) == f(*args)
Example #47
0
 def test_ifexp():
     f_ = autojit(f)
     for args in product(range(3), range(3)):
         assert f_(*args)==f(*args)
Example #48
0
            num = 0.0
            for ii in range(Mf):
                for jj in range(Nf):
                    num += (filt[Mf - 1 - ii, Nf - 1 - jj] *
                            image[i - Mf2 + ii, j - Nf2 + jj])
            result[i, j] = num
    return result


# This kind of quadruply-nested for-loop is going to be quite slow.
# Using Numba we can compile this code to LLVM which then gets
# compiled to machine code:
# Now fastfilter_2d runs at speeds as if you had first translated
# it to C, compiled the code and wrapped it with Python
fastfilter_2d = jit(double[:, :](double[:, :], double[:, :]))(filter2d)
autofilter_2d = autojit(filter2d)

# Use utool to time this
imports = ut.codeblock(r'''
    # STARTBLOCK
    import numpy as np
    from numba import double, jit, autojit
    # ENDBLOCK
    ''')

datas = ut.codeblock(r'''
    # STARTBLOCK
    fastfilter_2d = jit(double[:, :](double[:, :], double[:, :]))(filter2d)
    autofilter_2d = autojit(filter2d)
    rng = np.random.RandomState(0)
    image = rng.rand(100, 100)
Example #49
0
from __future__ import print_function, division, absolute_import

import numpy as np
from numba import autojit


def test(a, b):
    r = np.empty(3, dtype=bool)
    for i in range(len(a)):
        r[i] = a[i] != b[i]
    return r


test_nb = autojit(test)

a = np.arange(3, dtype=complex)
b = np.arange(3, dtype=complex)
b[1] += 1j

assert np.array_equal(test(a, b), test_nb(a, b))
Example #50
0
    A_r = 255 - A_r + 0.001   #Prevent division by zero
    out = np.empty_like(img, dtype=np.float32)
    row, col = img.shape[:2]
    for x in xrange(row):
        for y in xrange(col):
            x_init = max(x-1, 0)
            x_final = min(x+2, row-1)
            y_init = max(y-1,0)
            y_final = min(y+2, col-1)
            out[x,y,0] = np.min(img[x_init:x_final, y_init:y_final,0])/A_b
            out[x,y,1] = np.min(img[x_init:x_final, y_init:y_final,1])/A_g
            out[x,y,2] = np.min(255 - img[x_init:x_final, y_init:y_final,2])/A_r
    out =  np.max(1 - np.min(out, axis=2), 0.1) #0.1 is the minimum transmission map value
    return out

tMap = autojit(calcTransmissionMap)

def waterlight_estimation(img):
    """Estimate brighest pixel in the image"""
    img = np.float32(img)
    b,g,r = cv2.split(np.float32(img))
    minval,maxval,minloc,maxloc = cv2.minMaxLoc(r)
    waterlight = img[maxloc[1], maxloc[0]]
    return waterlight

def redchannelprior(img):
    airlight = waterlight_estimation(img)
    t = tMap(img, airlight)
    return img

def minkowski_norm(grayimg, p):
Example #51
0
    def __init__(self, plus, mnus):
        self.plus = plus
        self.mnus = mnus

    def __radd__(self, arg):
        return type(arg)(arg.start + self.plus, arg.stop + self.plus)

    def __rsub__(self, arg):
        return type(arg)(arg.start - self.mnus, arg.stop - self.mnus)


one = Shift(1, 1)
sl = slice(2, 5)
print sl + one

try:
    from numba import autojit, jit, double
    fast_f = autojit(f)
    #fast_f = jit(restype=double[:],argtypes=[double[:], double[:], double[:]])(f)
    t0 = time.time()
    output = fast_f(Psi_l, Psi_r, CC)
    print "time: numba", time.time() - t0
    print "output numba", output
except ImportError:
    print "Not using Numba nor Numbapro"

t1 = time.time()
output = f(Psi_l, Psi_r, CC)
print "time: numpy", time.time() - t1
print "output numpy", output
Example #52
0
@parakeet.jit 
def parakeet_local_maxima(data, wsize, mode=wrap):
  def is_max(pos):
    def is_smaller_neighbor(offset):
      neighbor_idx = tuple(mode(p, o-w/2, w) for (p, o, w) in zip(pos, offset, wsize))
      return data[neighbor_idx] <= data[pos]
    return np.all(parakeet.imap(is_smaller_neighbor, wsize))
  return parakeet.imap(is_max, data.shape)
  

###
# Numba fails no matter what I do with the code, giving up for now
#
import numba
numba_local_maxima = numba.autojit(python_local_maxima)

if __name__  == '__main__':
  from timer import timer 
  shape = (30,10,10,12)
  x = np.random.randn(*shape)
  wsize = (3,3,3,3)
  with timer("Parakeet (first run)"):
    parakeet_result  = parakeet_local_maxima(x, wsize)
  with timer("Parakeet (second run)"):
    parakeet_result  = parakeet_local_maxima(x, wsize)
  with timer("Numba (first run)"):
    numba_result  = numba_local_maxima(x, wsize, wrap)
  with timer("Numba (second run)"):
    numba_result  = numba_local_maxima(x, wsize, wrap)
  with timer("Python"):
Example #53
0
    grid_x = np.linspace(-bound, bound, N)
    for i, x in enumerate(grid_x):
        for j, y in enumerate(grid_x):
            julia[i, j] = kernel(x, y, cr, ci, lim, cutoff=cutoff)
    return julia


def julia(cr, ci, N, bound=1.5, lim=1000., cutoff=1e6):
    grid_x = np.linspace(-bound, bound, N)
    return np.array(
        [[kernel(x, y, cr, ci, lim, cutoff=cutoff) for x in grid_x]
         for y in grid_x])


from compare_perf import compare_perf
cr = 0.285
ci = 0.01
N = 1200
bound = 1.5
lim = 1000
cutoff = 1e6

extra = {}
try:
    from numba import autojit
    extra['numba'] = autojit(julia_loops)
except:
    print "Failed to import Numba"

compare_perf(julia, [cr, ci, N, bound, lim, cutoff], numba=False, extra=extra)
Example #54
0
    X, Y = np.meshgrid(x, y)
    w = np.exp(-(X**2 + Y**2) / 2 / 17.5**2)
    # Conversion to nanoseconds... 'D' is nanoseconds
    Z = raster[:, :] - np.max(raster[:, :])
    D = (abs(Z) / 0.15) + 10  # Start all recordings after 10 ns
    for i in range(200):
        for j in range(200):
            ibin = np.int(D[i, j])  #finding ibin
            #add power within pixel (i,j)-which is w(i,j) to the returned
            #power in the bin number ibin
            if ibin < 544:
                cumpowr[ibin] = cumpowr[ibin] + w[i, j]
    return cumpowr


wave_numba = autojit(waveformC)

folder = "/Users/sgrigsby/Desktop/April_21st_tile_output/"

idx = []
for i, filename in enumerate(os.listdir(folder)):
    fn, ext = os.path.splitext(filename)
    # source = gdal.Open(folder + filename)
    # (source.RasterYSize & source.RasterXSize) == 200
    idx.append(fn)

#April_20th_wf_no_conv = pd.DataFrame(index=idx,columns=np.r_[0:544:1])
space = np.zeros((len(idx), 544), dtype=float)

for i, filename in enumerate(tqdm(os.listdir(folder))):
    #fn, ext = os.path.splitext(filename)
from growcut import growcut_python
from numba import autojit

benchmarks = (("growcut_numba", autojit(growcut_python.growcut_python)), )
Example #56
0
            ## Bin to the left
            elif xr <= xnewl:
                pass
            ## This condition should not happen
            else:
                pass
            i += 1
        ## Add the sum to ynew
        if weight != 0:
            ynew[ii] = val / weight
        ii += 1
    return ynew


if 'numba' in sys.modules:
    Interp_integrate = autojit(Interp_integrate)


def Resample_linlog(xold):
    """Resample_linlog(xold)
    Resample a linear wavelength vector to a log space and
    returns the new vector and the Doppler shift z.

    The resampling is done such that the largest wavelength interval
    is conserved in order to preserve the spectral resolution.

    The Doppler shift is:
        1+z = lambda_1 / lambda_0

    In the non-relativistic limit:
        z = v/c
Example #57
0
from julia import julia_python
from numba import autojit


benchmarks = (
    ("julia_numba_for_loops",
     autojit(julia_python.julia_python_for_loops)),
)
Example #58
0
                break
            ## Bin to the left
            elif xr <= xnewl:
                pass
            ## This condition should not happen
            else:
                pass
            i += 1
        ## Add the sum to ynew
        if weight != 0:
            ynew[ii] = val/weight
        ii += 1
    return ynew

if 'numba' in sys.modules:
    Interp_linear_integrate = autojit(Interp_linear_integrate)

def Resample_linlog(xold):
    """
    Resample a linear wavelength vector to a log space and
    returns the new vector and the Doppler shift z.

    The resampling is done such that the largest wavelength interval
    is conserved in order to preserve the spectral resolution.

    The Doppler shift is:
        1+z = lambda_1 / lambda_0

    In the non-relativistic limit:
        z = v/c