title: Why is numba faster than numpy here?
body: <p>I can't figure out why numba is beating numpy here (over 3x).  Did I make some fundamental error in how I am benchmarking here?  Seems like the perfect situation for numpy, no?  Note that as a check, I also ran a variation combining numba and numpy (not shown), which as expected was the same as running numpy without numba.</p>
  
  <p>(btw this is a followup question to: <a href="https://stackoverflow.com/questions/25915541/fastest-way-to-numerically-process-2d-array-dataframe-vs-series-vs-array-vs-num">Fastest way to numerically process 2d-array: dataframe vs series vs array vs numba</a> )</p>
  
  <pre><code>import numpy as np
  from numba import jit
  nobs = 10000 
  
  def proc_numpy(x,y,z):
  
     x = x*2 - ( y * 55 )      # these 4 lines represent use cases
     y = x + y*2               # where the processing time is mostly
     z = x + y + 99            # a function of, say, 50 to 200 lines
     z = z * ( z - .88 )       # of fairly simple numerical operations
  
     return z
  
  @jit
  def proc_numba(xx,yy,zz):
     for j in range(nobs):     # as pointed out by Llopis, this for loop 
        x, y = xx[j], yy[j]    # is not needed here.  it is here by 
                               # accident because in the original benchmarks 
        x = x*2 - ( y * 55 )   # I was doing data creation inside the function 
        y = x + y*2            # instead of passing it in as an array
        z = x + y + 99         # in any case, this redundant code seems to 
        z = z * ( z - .88 )    # have something to do with the code running
                               # faster.  without the redundant code, the 
        zz[j] = z              # numba and numpy functions are exactly the same.
     return zz
  
  x = np.random.randn(nobs)
  y = np.random.randn(nobs)
  z = np.zeros(nobs)
  res_numpy = proc_numpy(x,y,z)
  
  z = np.zeros(nobs)
  res_numba = proc_numba(x,y,z)
  </code></pre>
  
  <p>results:</p>
  
  <pre><code>In [356]: np.all( res_numpy == res_numba )
  Out[356]: True
  
  In [357]: %timeit proc_numpy(x,y,z)
  10000 loops, best of 3: 105 µs per loop
  
  In [358]: %timeit proc_numba(x,y,z)
  10000 loops, best of 3: 28.6 µs per loop
  </code></pre>
  
  <p>I ran this on a 2012 macbook air (13.3), standard anaconda distribution.  I can provide more detail on my setup if it's relevant.</p>