Author: Alex Rubinsteyn



Parakeet is a runtime accelerator for an array-oriented subset of
Python. If you're doing a lot of number crunching in Python, Parakeet
may be able to significantly speed up your code.

To accelerate a function, wrap it with Parakeet's **@jit** decorator:


    import numpy as np 
    from parakeet import jit 

    x = np.array([1,2,3])
    y = np.tanh(x * alpha) + beta

    def fast(x, alpha = 0.5, beta = 0.3):
      return np.tanh(x * alpha) + beta 

    def loopy(x, alpha = 0.5, beta = 0.3):
      y = np.empty_like(x, dtype = float)
      for i in xrange(len(x)):
        y[i] = np.tanh(x[i] * alpha) + beta
      return y

    def comprehension(x, alpha = 0.5, beta = 0.3):
      return np.array([np.tanh(xi*alpha) + beta for xi in x])

    assert np.allclose(fast(x), y)
    assert np.allclose(loopy(x), y)
    assert np.allclose(comprehension(x), y)


You should be able to install Parakeet from its `PyPI
package <>`_ by running:


    pip install parakeet


Parakeet is written for Python 2.7 (sorry internet) and depends on:

-  `dsltools <>`_
-  `nose <>`_ for unit tests
-  `NumPy <>`_

The default backend (which uses OpenMP) requires ``gcc`` 4.4+.

*Windows*: If you have a 32-bit Windows install, your compiler should
come from `Cygwin <>`_ or
`MinGW <>`_. Getting Parakeet working on 64-bit
Windows is non-trivial and seems to require `colossal
hacks <>`_.

*Mac OS X*: By default, your machine probably either has only
`clang <>`_ or an outdated version of ``gcc``. You
can get a more recent version using
`HomeBrew <>`_

If you want to use the CUDA backend, you need to have an NVIDIA graphics
card and install both the `CUDA
Toolkit <>`_ and
`PyCUDA <>`_.

How does it work?

Your untyped function gets used as a template from which multiple *type
specializations* are generated (for each distinct set of input types).
These typed functions are then churned through many optimizations before
finally getting translated into native code.

More information

-  Read more about Parakeet on the `project
   website <>`_
-  Ask questions on the `discussion
   group <!forum/parakeet-python>`_
-  Watch the `Parakeet presentation <>`_ from
   this year's `PyData Boston <>`_, look at the
   slides <>`_
   from last year
-  Contact the `main developer <>`_ directly

Supported language features

Parakeet cannot accelerate arbitrary Python code, it only supports a
limited subset of the language:

-  Scalar operations (i.e. ``x + 3 * y``)
-  Control flow (if-statements, loops, etc...)
-  Nested functions and lambdas
-  Tuples
-  Slices
-  NumPy array expressions (i.e. ``x[1:, :] + 2 * y[:-1, ::2]``)
-  Some NumPy library functions like ``np.ones`` and ``np.sin`` (look at
   `mappings <>`_
   module for a full list)
-  List literals (interpreted as array construction)
-  List comprehensions (interpreted as array comprehensions)
-  Parakeet's higher order array operations like ``parakeet.imap``,
   ``parakeet.scan``, and ``parakeet.allpairs``


Parakeet currently supports compilation to sequential C, multi-core C
with OpenMP (default), or LLVM (deprecated). To switch between these
options change ``parakee