In [1]:

    

import numpy as np
import numpy.random as npr
import numba


    

In [2]:

    

def dot(a,b):
    ans=0.0
    for i in range(len(a)):
        ans+=a[i]*b[i]
    return ans


    

In [3]:

    

from numba import jit, autojit, double, float64, float32, void, int32


    

In [4]:

    

dot_jit = jit(double(double[:],double[:]))(dot)


    

In [5]:

    

a = npr.randn(3)
b = npr.randn(3)


    

In [6]:

    

%timeit dot(a,b)


    

    




100000 loops, best of 3: 3.36 µs per loop

In [7]:

    

%timeit dot_jit(a,b)


    

    




1000000 loops, best of 3: 335 ns per loop

In [8]:

    

%timeit a.dot(b)


    

    




1000000 loops, best of 3: 1.2 µs per loop

In [9]:

    

from numpy.linalg import det

def BC_jittable(X,Y):
    xty = det(np.dot(X.T,Y))
    xtx = det(np.dot(X.T,X))
    yty = det(np.dot(Y.T,Y))
    return xty / np.sqrt(xtx*yty)

BC_jit = jit(double(double[:,:],double[:,:]))(BC_jittable)


    

In [10]:

    

X = npr.randn(100,3)
Y = npr.randn(100,3)


    

In [12]:

    

from numpy.linalg import det
BC = lambda X,Y: det(X.T.dot(Y))/ np.sqrt(det(X.T.dot(X)) * det(Y.T.dot(Y)))


    

In [13]:

    

%timeit BC(X,Y)


    

    




10000 loops, best of 3: 45.9 µs per loop

In [14]:

    

%timeit BC_jittable(X,Y)


    

    




10000 loops, best of 3: 45.2 µs per loop

In [15]:

    

%timeit BC_jit(X,Y)


    

    




10000 loops, best of 3: 45.4 µs per loop

In [32]:

    

@jit
def pairwise_BC(X):
    pbc=np.zeros((len(X),len(X)))
    for i in range(len(X)):
        for j in range(len(X)):
            pbc[i,j] = BC_jit(X[i],X[j])
    return pbc


    

In [20]:

    

pbc_jit = jit(double[:,:](double[:,:,:]))(pairwise_BC)


    

In [18]:

    

X_tensor = npr.randn(100,100,3)


    

In [19]:

    

%timeit pairwise_BC(X_tensor)


    

    




1 loops, best of 3: 480 ms per loop

In [27]:

    

pbc=np.zeros((len(X_tensor),len(X_tensor)))


    

In [31]:

    

%timeit pairwise_BC(X_tensor,pbc)


    

    




1 loops, best of 3: 466 ms per loop

In [33]:

    

%timeit pairwise_BC(X_tensor)


    

    




1 loops, best of 3: 480 ms per loop

In [21]:

    

%timeit pbc_jit(X_tensor)


    

    




1 loops, best of 3: 475 ms per loop

In [ ]:

    

bc_jit =


    

In [ ]:

    

dot_jit = jit(double(double[:],double[:]))(dot)