title: Cython not giving speedup
body: <p>I have been trying to test the speedup potential of using Cython as compared to the base Python code. For this purpose, I wrote two scripts 'linearAdvec_mat.py' and 'linearAdvec_mat.pyx' as follows:</p>
  <p>linearAdvec_mat.py:</p>
  <pre><code>import numpy as np
  
  def Adv_mat(N):
      A = np.zeros((N, N));
      for i in range(N):
          if i == 0:
              A[i, N - 1] = -1.0;
              A[i, i] = 0.0;
              A[i, i + 1] = 1.0;
          elif i == N - 1:
              A[i, i - 1] = -1.0;
              A[i, i] = 0.0;
              A[i, 0] = 1.0;
          else:
              A[i, i - 1] = -1.0;
              A[i, i] = 0.0;
              A[i, i + 1] = 1.0;
      return A;
  
  def Diff_mat(N):
      D = np.zeros((N, N));
      for i in range(N):
          if i == 0:
              D[i, N - 1] = 1.0;
              D[i, i] = -2.0;
              D[i, i + 1] = 1.0;
          elif i == N - 1:
              D[i, i - 1] = 1.0;
              D[i, i] = -2.0;
              D[i, 0] = 1.0;
          else:
              D[i, i - 1] = 1.0;
              D[i, i] = -2.0;
              D[i, i + 1] = 1.0;
      return D;
  
  def Compute_eigVals(N, alpha, kdt):
      A = Adv_mat(N);
      D = Diff_mat(N);
      ADt = A*(-alpha/2.0) + D*kdt;
      ldt = np.zeros(N, 'complex');
      beta = np.zeros(N);
      for m in range(N):
          beta[m] = 2*np.pi*m/N;
          if beta[m] &gt; np.pi:
              beta[m] = 2*np.pi - beta[m];
          for j in range(N):
              ldt[m] += ADt[0, j]*np.exp(1j*2.0*np.pi*j*m/N);
      return ldt;
  </code></pre>
  <p>and linearAdvec_mat.pyx:</p>
  <pre><code>import numpy as np
  cimport numpy as np
  
  DTYPE = np.float64;
  DTYPE_c = np.complex128;
  ctypedef np.float64_t DTYPE_t;
  
  cdef np.ndarray[DTYPE_t, ndim = 2] Adv_mat(int N):
      cdef np.ndarray[DTYPE_t, ndim = 2] A = np.zeros((N, N), dtype = DTYPE);
      cdef int i;
      for i in range(N):
          if i == 0:
              A[i, N - 1] = -1.0;
              A[i, i] = 0.0;
              A[i, i + 1] = 1.0;
          elif i == N - 1:
              A[i, i - 1] = -1.0;
              A[i, i] = 0.0;
              A[i, 0] = 1.0;
          else:
              A[i, i - 1] = -1.0;
              A[i, i] = 0.0;
              A[i, i + 1] = 1.0;
      return A;
  
  cdef np.ndarray[DTYPE_t, ndim = 2] Diff_mat(int N):
      cdef np.ndarray[DTYPE_t, ndim = 2] D = np.zeros((N, N), dtype = DTYPE);
      cdef int i;
      for i in range(N):
          if i == 0:
              D[i, N - 1] = 1.0;
              D[i, i] = -2.0;
              D[i, i + 1] = 1.0;
          elif i == N - 1:
              D[i, i - 1] = 1.0;
              D[i, i] = -2.0;
              D[i, 0] = 1.0;
          else:
              D[i, i - 1] = 1.0;
              D[i, i] = -2.0;
              D[i, i + 1] = 1.0;
      return D;
  
  cpdef np.ndarray[np.complex128_t, ndim = 1] Compute_eigVals(int N, double alpha, double kdt):
      cdef np.ndarray[DTYPE_t, ndim = 2] A = Adv_mat(N);
      cdef np.ndarray[DTYPE_t, ndim = 2] D = Diff_mat(N);
      cdef np.ndarray[np.complex128_t, ndim = 2] ADt = A*(-alpha/2.0) + D*kdt + 0j;
      cdef np.ndarray[np.complex128_t, ndim = 1] ldt = np.zeros(N, dtype = DTYPE_c);
      cdef np.ndarray[DTYPE_t, ndim = 1] beta = np.zeros(N, dtype = DTYPE);
      cdef int m, k;
      for m in range(N):
          beta[m] = 2*np.pi*m/N;
          if beta[m] &gt; np.pi:
              beta[m] = 2*np.pi - beta[m];
          for k in range(N):
              ldt[m] = ldt[m] + ADt[0, k]*np.exp(1j*2.0*np.pi*k*m/N);
      return ldt;
  </code></pre>
  <p>When I call the 'Compute_eigVals' function from the base python and the compiled .so file like shown below, I don't get any significant speedup from the cython script.</p>
  <pre><code>import numpy as np
  import matplotlib.pyplot as plt
  import matplotlib
  matplotlib.rcParams['mathtext.fontset'] = 'stix'
  matplotlib.rcParams['font.family'] = 'STIXGeneral'
  from libs.linearAdvec_mat import Compute_eigVals as Compute_eigVals_cy
  from linearAdvec_mat import Compute_eigVals as Compute_eigVals_py
  import time
  #%% ------------------ Inputs ---------------------
  N = 1000;
  alpha = 0.8;
  kdt = 0.05;
  
  st = time.time();
  eigs = Compute_eigVals_cy(N, alpha, kdt);
  t_cy = time.time() - st;
  print('Cython time : %0.8fs\n'%(t_cy));
  
  st = time.time();
  eigs = Compute_eigVals_py(N, alpha, kdt);
  t_py = time.time() - st;
  print('Python time : %0.8fs\n'%(t_py));
  print('Cython is %0.5f times faster'%(t_py/t_cy));
  </code></pre>
  <p>I tried to check the amount of python interaction by running</p>
  <pre><code>cython -a linearAdvec_mat.pyx
  </code></pre>
  <p>in the terminal, but I couldn't work out anything from that. Could someone please provide some insights onto why I don't get a significant amount of speedup when using cython? My first guess was that my base python script is heavily reliant on numpy as such, it is already in an optimised state, but I am fully sure and am eager to figure out what is actually going on.</p>