as the 80/20 rule: 80% of the runtime is spent in
20% of the source code. This means that a little
bit of annotation in the right spot can go a long
way.
This leads to an extremely productive workflow in
Cython: users can simply develop with Python,
and if they find that a significant amount of time
is being spent paying Python overheads, they can
compile parts or all of their project with Cython,
possibly providing some annotations to speed up
the critical parts of the code.
For code that
spends almost all of its execution time in libraries
doing things like FFTs, matrix multiplication, or
linear system solving, Cython fills the same rapid
development role as Python. However, as you ex-
tend the code with new functionality and algo-
rithms, you can do this directly in Cython – and
just by providing a little extra type information,
you can get all the speed of C without all the
headaches.
A simple example
As an introductory example, consider naive nu-
merical integration of the Gamma function. A
fast C implementation of the Gamma function is
available e.g. in the GNU Scientific Library, and
can easily be made available to Cython through
some C declarations in Cython code (double
refers to the double precision floating point type
in C):
cdef extern from "gsl/gsl_sf.h":
double gsl_sf_gamma(double x)
double GSL_SF_GAMMA_XMAX
One can then write a Cython function, callable
from Python, to approximate the definite integral:
def integrate_gamma(double a, double b,
int n=10000):
if (min(a, b) <= 0 or
max(a, b) >= GSL_SF_GAMMA_XMAX):
raise ValueError(’Limits out ’
’of range (0, \%f)’ %
GSL_SF_GAMMA_XMAX)
cdef int i
cdef double dx = (b - a) / n, result = 0
for i in range(n):
result += gsl_sf_gamma(a + i * dx) * dx
return result
This is pure Python code except that C types
(int, double) are statically declared for some
variables, using Cython-specific syntax. The cdef
keyword is a Cython extension to the language, as
is prepending the type in the argument list. In ef-
fect, Cython provides a mixture of C and Python
programming. The above code is 30 times faster
than the corresponding Python loop, and much
more memory efficient (although not any faster)
than the corresponding NumPy expression:
import numpy as np
y = scipy.special.gamma(
np.linspace(a, b, n, endpoint=False))
y *= ((b - a) / n)
result = np.sum(y)
Cython especially shines in more complicated ex-
amples where for loops are the most natural or
only viable solution. Examples are given below.
