From 1e14663a463136b4e6f9c10ced38f8afe56fada1 Mon Sep 17 00:00:00 2001 From: Minh Van Nguyen Date: Sat, 3 Oct 2009 01:30:33 +1000 Subject: [PATCH] move reference guide and SciPy tutorial to separate dirs under sr/ --- index.rst | 26 +- src/reference/Makefile | 68 ++++ src/{ => reference}/compilation.rst | 0 src/{ => reference}/extension_types.rst | 0 src/reference/index.rst | 22 ++ .../interfacing_with_other_code.rst | 0 src/{ => reference}/language_basics.rst | 0 src/{ => reference}/limitations.rst | 0 src/{ => reference}/overview.rst | 0 src/{ => reference}/special_mention.rst | 0 src/tutorial/appendix.rst | 29 ++ src/tutorial/build.rst | 58 +++ src/tutorial/caveats.rst | 18 + src/tutorial/cdef_classes.rst | 141 +++++++ src/tutorial/cdef_functions.rst | 41 ++ src/tutorial/clibraries.rst | 370 ++++++++++++++++++ src/tutorial/cythonize.rst | 44 +++ src/tutorial/data.py | 40 ++ src/tutorial/datatypes.rst | 24 ++ src/tutorial/external.rst | 52 +++ src/tutorial/htmlreport.png | Bin 0 -> 51573 bytes src/tutorial/index.rst | 33 ++ src/tutorial/install.rst | 52 +++ src/tutorial/numpy.rst | 106 +++++ src/tutorial/overview.rst | 54 +++ src/tutorial/pxd_files.rst | 41 ++ src/tutorial/queue_example/cqueue.pxd | 17 + src/tutorial/queue_example/queue.pyx | 95 +++++ src/tutorial/readings.rst | 26 ++ src/tutorial/references.rst | 32 ++ src/tutorial/related_work.rst | 49 +++ src/tutorial/sage.png | Bin 0 -> 78281 bytes src/tutorial/strings.rst | 125 ++++++ 33 files changed, 1542 insertions(+), 21 deletions(-) create mode 100644 src/reference/Makefile rename src/{ => reference}/compilation.rst (100%) rename src/{ => reference}/extension_types.rst (100%) create mode 100644 src/reference/index.rst rename src/{ => reference}/interfacing_with_other_code.rst (100%) rename src/{ => reference}/language_basics.rst (100%) rename src/{ => reference}/limitations.rst (100%) rename src/{ => reference}/overview.rst (100%) rename src/{ => reference}/special_mention.rst (100%) create mode 100644 src/tutorial/appendix.rst create mode 100644 src/tutorial/build.rst create mode 100644 src/tutorial/caveats.rst create mode 100644 src/tutorial/cdef_classes.rst create mode 100644 src/tutorial/cdef_functions.rst create mode 100644 src/tutorial/clibraries.rst create mode 100644 src/tutorial/cythonize.rst create mode 100644 src/tutorial/data.py create mode 100644 src/tutorial/datatypes.rst create mode 100644 src/tutorial/external.rst create mode 100644 src/tutorial/htmlreport.png create mode 100644 src/tutorial/index.rst create mode 100644 src/tutorial/install.rst create mode 100644 src/tutorial/numpy.rst create mode 100644 src/tutorial/overview.rst create mode 100644 src/tutorial/pxd_files.rst create mode 100644 src/tutorial/queue_example/cqueue.pxd create mode 100644 src/tutorial/queue_example/queue.pyx create mode 100644 src/tutorial/readings.rst create mode 100644 src/tutorial/references.rst create mode 100644 src/tutorial/related_work.rst create mode 100644 src/tutorial/sage.png create mode 100644 src/tutorial/strings.rst diff --git a/index.rst b/index.rst index c5186638..a67db73d 100644 --- a/index.rst +++ b/index.rst @@ -1,27 +1,11 @@ -Welcome to Cython's Reference Guide -=================================== +Welcome to Cython's Documentation +================================= Contents: - -.. toctree:: - :maxdepth: 2 - - src/overview - src/language_basics - src/compilation - src/extension_types - src/interfacing_with_other_code - src/special_mention - src/limitations - -Indices and tables -================== - -* :ref:`genindex` -* :ref:`modindex` -* :ref:`search` - .. toctree:: + :maxdepth: 1 + src/reference/index + src/tutorial/index diff --git a/src/reference/Makefile b/src/reference/Makefile new file mode 100644 index 00000000..70a45cba --- /dev/null +++ b/src/reference/Makefile @@ -0,0 +1,68 @@ +# Makefile for Sphinx documentation +# + +# You can set these variables from the command line. +SPHINXOPTS = +SPHINXBUILD = sphinx-build +PAPER = + +# Internal variables. +PAPEROPT_a4 = -D latex_paper_size=a4 +PAPEROPT_letter = -D latex_paper_size=letter +ALLSPHINXOPTS = -d build/doctrees $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) . + +.PHONY: help clean html web htmlhelp latex changes linkcheck + +help: + @echo "Please use \`make ' where is one of" + @echo " html to make standalone HTML files" + @echo " web to make files usable by Sphinx.web" + @echo " htmlhelp to make HTML files and a HTML help project" + @echo " latex to make LaTeX files, you can set PAPER=a4 or PAPER=letter" + @echo " changes to make an overview over all changed/added/deprecated items" + @echo " linkcheck to check all external links for integrity" + +clean: + -rm -rf build/* + +html: + mkdir -p build/html build/doctrees + $(SPHINXBUILD) -b html $(ALLSPHINXOPTS) build/html + @echo + @echo "Build finished. The HTML pages are in build/html." + +web: + mkdir -p build/web build/doctrees + $(SPHINXBUILD) -b web $(ALLSPHINXOPTS) build/web + @echo + @echo "Build finished; now you can run" + @echo " python -m sphinx.web build/web" + @echo "to start the server." + +htmlhelp: + mkdir -p build/htmlhelp build/doctrees + $(SPHINXBUILD) -b htmlhelp $(ALLSPHINXOPTS) build/htmlhelp + @echo + @echo "Build finished; now you can run HTML Help Workshop with the" \ + ".hhp project file in build/htmlhelp." + +latex: + mkdir -p build/latex build/doctrees + $(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) build/latex + @echo + @echo "Build finished; the LaTeX files are in build/latex." + @echo "Run \`make all-pdf' or \`make all-ps' in that directory to" \ + "run these through (pdf)latex." + +changes: + mkdir -p build/changes build/doctrees + $(SPHINXBUILD) -b changes $(ALLSPHINXOPTS) build/changes + @echo + @echo "The overview file is in build/changes." + +linkcheck: + mkdir -p build/linkcheck build/doctrees + $(SPHINXBUILD) -b linkcheck $(ALLSPHINXOPTS) build/linkcheck + @echo + @echo "Link check complete; look for any errors in the above output " \ + "or in build/linkcheck/output.txt." diff --git a/src/compilation.rst b/src/reference/compilation.rst similarity index 100% rename from src/compilation.rst rename to src/reference/compilation.rst diff --git a/src/extension_types.rst b/src/reference/extension_types.rst similarity index 100% rename from src/extension_types.rst rename to src/reference/extension_types.rst diff --git a/src/reference/index.rst b/src/reference/index.rst new file mode 100644 index 00000000..5943f509 --- /dev/null +++ b/src/reference/index.rst @@ -0,0 +1,22 @@ +Reference Guide +=============== + +Contents: + +.. toctree:: + :maxdepth: 2 + + overview + language_basics + compilation + extension_types + interfacing_with_other_code + special_mention + limitations + +Indices and tables +================== + +* :ref:`genindex` +* :ref:`modindex` +* :ref:`search` diff --git a/src/interfacing_with_other_code.rst b/src/reference/interfacing_with_other_code.rst similarity index 100% rename from src/interfacing_with_other_code.rst rename to src/reference/interfacing_with_other_code.rst diff --git a/src/language_basics.rst b/src/reference/language_basics.rst similarity index 100% rename from src/language_basics.rst rename to src/reference/language_basics.rst diff --git a/src/limitations.rst b/src/reference/limitations.rst similarity index 100% rename from src/limitations.rst rename to src/reference/limitations.rst diff --git a/src/overview.rst b/src/reference/overview.rst similarity index 100% rename from src/overview.rst rename to src/reference/overview.rst diff --git a/src/special_mention.rst b/src/reference/special_mention.rst similarity index 100% rename from src/special_mention.rst rename to src/reference/special_mention.rst diff --git a/src/tutorial/appendix.rst b/src/tutorial/appendix.rst new file mode 100644 index 00000000..f8650170 --- /dev/null +++ b/src/tutorial/appendix.rst @@ -0,0 +1,29 @@ +Appendix: Installing MinGW on Windows +===================================== + + 1. Download the MinGW installer from http://mingw.org. (As of this + writing, the download link is a bit difficult to find; it's under + "About" in the menu on the left-hand side). You want the file + entitled "Automated MinGW Installer" (currently version 5.1.4). + 2. Run it and install MinGW. Only the basic package is strictly + needed for Cython, although you might want to grab at least the + C++ compiler as well. + 3. You need to set up Windows' "PATH" environment variable so that + includes e.g. "c:\\mingw\\bin" (if you installed MinGW to + "c:\\mingw"). The following web-page describes the procedure + in Windows XP (the Vista procedure is similar): + http://support.microsoft.com/kb/310519 + 4. Finally, tell Python to use MinGW as the default compiler + (otherwise it will try for Visual C). If Python is installed to + "c:\\Python26", create a file named + "c:\\Python26\\Lib\\distutils\\distutils.cfg" containing:: + + [build] + compiler = mingw32 + +The [WinInst]_ wiki page contains updated information about this +procedure. Any contributions towards making the Windows install +process smoother is welcomed; it is an unfortunate fact that none of +the regular Cython developers have convenient access to Windows. + +.. [WinInst] http://wiki.cython.org/InstallingOnWindows diff --git a/src/tutorial/build.rst b/src/tutorial/build.rst new file mode 100644 index 00000000..783d2987 --- /dev/null +++ b/src/tutorial/build.rst @@ -0,0 +1,58 @@ +Building Cython code +==================== + +Cython code must, unlike Python, be compiled. This happens in two stages: + + - A ``.pyx`` file is compiled by Cython to a ``.c`` file, containing + the code of a Python extension module + - The ``.c`` file is compiled by a C compiler to + a ``.so`` file (or ``.pyd`` on Windows) which can be + ``import``-ed directly into a Python session. + +There are several ways to build Cython code: + + - Write a distutils ``setup.py``. + - Use ``pyximport``, importing Cython ``.pyx`` files as if they + were ``.py`` files (using distutils to compile and build the background). + - Run the ``cython`` command-line utility manually to produce the ``.c`` file + from the ``.pyx`` file, then manually compiling the ``.c`` file into a shared + object library or ``.dll`` suitable for import from Python. + (This is mostly for debugging and experimentation.) + - Use the [Sage]_ notebook which allows Cython code inline. + +Currently, distutils is the most common way Cython files are built and distributed. + +Building a Cython module using distutils +---------------------------------------- + +Imagine a simple "hello world" script in a file ``hello.pyx``:: + + def say_hello_to(name): + print(Hello %s!" % name) + +The following could be a corresponding ``setup.py`` script:: + + from distutils.core import setup + from distutils.extension import Extension + from Cython.Distutils import build_ext + + ext_modules = [Extension("hello", ["hello.pyx"])] + + setup( + name = 'Hello world app', + cmdclass = {'build_ext': build_ext}, + ext_modules = ext_modules + ) + +To build, run ``python setup.py build_ext --inplace``. Then simply +start a Python session and do ``from hello import say_hello_to`` and +use the imported function as you see fit. + +.. figure:: sage.png + + The Sage notebook allows transparently editing and compiling Cython + code simply by typing ``%cython`` at the top of a cell and evaluate + it. Variables and functions defined in a Cython cell imported into + the running session. + +.. [Sage] W. Stein et al., Sage Mathematics Software, http://sagemath.org diff --git a/src/tutorial/caveats.rst b/src/tutorial/caveats.rst new file mode 100644 index 00000000..5895c80d --- /dev/null +++ b/src/tutorial/caveats.rst @@ -0,0 +1,18 @@ +Caveats +======= + +Since Cython mixes C and Python semantics, some things may be a bit +surprising or unintuitive. Work always goes on to make Cython more natural +for Python users, so this list may change in the future. + + - ``10**-2 == 0``, instead of ``0.01`` like in Python. + - Given two typed ``int`` variables ``a`` and ``b``, ``a % b`` has the + same sign as the first argument (following C semantics) rather then + having the same sign as the second (as in Python). This will change + in Cython 0.12. + - Care is needed with unsigned types. ``cdef unsigned n = 10; + print(range(-n, n))`` will print an empty list, since ``-n`` wraps + around to a large positive integer prior to being passed to the + ``range`` function. + - Python's ``float`` type actually wraps C ``double`` values, and + Python's ``int`` type wraps C ``long`` values. diff --git a/src/tutorial/cdef_classes.rst b/src/tutorial/cdef_classes.rst new file mode 100644 index 00000000..5a4aff1c --- /dev/null +++ b/src/tutorial/cdef_classes.rst @@ -0,0 +1,141 @@ +Extension types (aka. cdef classes) +=================================== + +To support object-oriented programming, Cython supports writing normal +Python classes exactly as in Python:: + + class MathFunction(object): + def __init__(self, name, operator): + self.name = name + self.operator = operator + + def __call__(self, *operands): + return self.operator(*operands) + +Based on what Python calls a "built-in type", however, Cython supports +a second kind of class: *extension types*, sometimes referred to as +"cdef classes" due to the keywords used for their declaration. They +are somewhat restricted compared to Python classes, but are generally +more memory efficient and faster than generic Python classes. The +main difference is that they use a C struct to store their fields and methods +instead of a Python dict. This allows them to store arbitrary C types +in their fields without requiring a Python wrapper for them, and to +access fields and methods directly at the C level without passing +through a Python dictionary lookup. + +Normal Python classes can inherit from cdef classes, but not the other +way around. Cython requires to know the complete inheritance +hierarchy in order to lay out their C structs, and restricts it to +single inheritance. Normal Python classes, on the other hand, can +inherit from any number of Python classes and extension types, both in +Cython code and pure Python code. + +So far our integration example has not been very useful as it only +integrates a single hard-coded function. In order to remedy this, +without sacrificing speed, we will use a cdef class to represent a +function on floating point numbers:: + + cdef class Function: + cpdef double evaluate(self, double x) except *: + return 0 + +Like before, cpdef makes two versions of the method available; one +fast for use from Cython and one slower for use from Python. Then:: + + cdef class SinOfSquareFunction(Function): + cpdef double evaluate(self, double x) except *: + return sin(x**2) + +Using this, we can now change our integration example:: + + def integrate(Function f, double a, double b, int N): + cdef int i + cdef double s, dx + if f is None: + raise ValueError("f cannot be None") + s = 0 + dx = (b-a)/N + for i in range(N): + s += f.evaluate(a+i*dx) + return s * dx + + print(integrate(SinOfSquareFunction(), 0, 1, 10000)) + +This is almost as fast as the previous code, however it is much more flexible +as the function to integrate can be changed. It is even possible to pass +in a new function defined in Python-space:: + + >>> import integrate + >>> class MyPolynomial(integrate.Function): + ... def evaluate(self, x): + ... return 2*x*x + 3*x - 10 + ... + >>> integrate(MyPolynomial(), 0, 1, 10000) + -7.8335833300000077 + +This is about 20 times slower, but still about 10 times faster than +the original Python-only integration code. This shows how large the +speed-ups can easily be when whole loops are moved from Python code +into a Cython module. + +Some notes on our new implementation of ``evaluate``: + + - The fast method dispatch here only works because ``evaluate`` was + declared in ``Function``. Had ``evaluate`` been introduced in + ``SinOfSquareFunction``, the code would still work, but Cython + would have used the slower Python method dispatch mechanism + instead. + + - In the same way, had the argument ``f`` not been typed, but only + been passed as a Python object, the slower Python dispatch would + be used. + + - Since the argument is typed, we need to check whether it is + ``None``. In Python, this would have resulted in an ``AttributeError`` + when the ``evaluate`` method was looked up, but Cython would instead + try to access the (incompatible) internal structure of ``None`` as if + it were a ``Function``, leading to a crash or data corruption. + +There is a *compiler directive* ``nonecheck`` which turns on checks +for this, at the cost of decreased speed. Here's how compiler directives +are used to dynamically switch on or off ``nonecheck``:: + + #cython: nonecheck=True + # ^^^ Turns on nonecheck globally + + import cython + + # Turn off nonecheck locally for the function + @cython.nonecheck(False) + def func(): + cdef MyClass obj = None + try: + # Turn nonecheck on again for a block + with cython.nonecheck(True): + print obj.myfunc() # Raises exception + except AttributeError: + pass + print obj.myfunc() # Hope for a crash! + + + +Attributes in cdef classes behave differently from attributes in regular classes: + + - All attributes must be pre-declared at compile-time + - Attributes are by default only accessible from Cython (typed access) + - Properties can be declared to expose dynamic attributes to Python-space + +:: + + cdef class WaveFunction(Function): + # Not available in Python-space: + cdef double offset + # Available in Python-space: + cdef public double freq + # Available in Python-space: + property period: + def __get__(self): + return 1.0 / self. freq + def __set__(self, value): + self. freq = 1.0 / value + <...> diff --git a/src/tutorial/cdef_functions.rst b/src/tutorial/cdef_functions.rst new file mode 100644 index 00000000..41b0bea3 --- /dev/null +++ b/src/tutorial/cdef_functions.rst @@ -0,0 +1,41 @@ +cdef functions +============== + +Python function calls can be expensive--in Cython doubly so because +one might need to convert to and from Python objects to do the call. +In our example above, the argument is assumed to be a C double both inside f() +and in the call to it, yet a Python ``float`` object must be constructed around the +argument in order to pass it. + +Therefore Cython provides a syntax for declaring a C-style function, +the cdef keyword:: + + cdef double f(double) except *: + return sin(x**2) + +Some form of except-modifier should usually be added, otherwise Cython +will not be able to propagate exceptions raised in the function (or a +function it calls). Above ``except *`` is used which is always +safe. An except clause can be left out if the function returns a Python +object or if it is guaranteed that an exception will not be raised +within the function call. + +A side-effect of cdef is that the function is no longer available from +Python-space, as Python wouldn't know how to call it. Using the +``cpdef`` keyword instead of cdef, a Python wrapper is also created, +so that the function is available both from Cython (fast, passing +typed values directly) and from Python (wrapping values in Python +objects). + +Note also that it is no longer possible to change ``f`` at runtime. + +Speedup: 45 times over pure Python. + +.. figure:: htmlreport.png + + Using the ``-a`` switch to the ``cython`` command line program (or + following a link from the Sage notebook) results in an HTML report + of Cython code interleaved with the generated C code. Lines are + colored according to the level of "typedness" -- white lines + translates to pure C without any Python API calls. This report + is invaluable when optimizing a function for speed. diff --git a/src/tutorial/clibraries.rst b/src/tutorial/clibraries.rst new file mode 100644 index 00000000..4dae583f --- /dev/null +++ b/src/tutorial/clibraries.rst @@ -0,0 +1,370 @@ +Using C libraries +================= + +Apart from writing fast code, one of the main use cases of Cython is +to call external C libraries from Python code. As seen for the C +string decoding functions above, it is actually trivial to call C +functions directly in the code. The following describes what needs to +be done to use an external C library in Cython code. + +Imagine you need an efficient way to store integer values in a FIFO +queue. Since memory really matters, and the values are actually +coming from C code, you cannot afford to create and store Python +``int`` objects in a list or deque. So you look out for a queue +implementation in C. + +After some web search, you find the C-algorithms library [CAlg]_ and +decide to use its double ended queue implementation. To make the +handling easier, however, you decide to wrap it in a Python extension +type that can encapsulate all memory management. + +The C API of the queue implementation, which is defined in the header +file ``libcalg/queue.h``, essentially looks like this:: + + typedef struct _Queue Queue; + typedef void *QueueValue; + + Queue *queue_new(void); + void queue_free(Queue *queue); + + int queue_push_head(Queue *queue, QueueValue data); + QueueValue queue_pop_head(Queue *queue); + QueueValue queue_peek_head(Queue *queue); + + int queue_push_tail(Queue *queue, QueueValue data); + QueueValue queue_pop_tail(Queue *queue); + QueueValue queue_peek_tail(Queue *queue); + + int queue_is_empty(Queue *queue); + +To get started, the first step is to redefine the C API in a ``.pxd`` +file, say, ``cqueue.pxd``:: + + cdef extern from "libcalg/queue.h": + ctypedef struct Queue: + pass + ctypedef void* QueueValue + + Queue* new_queue() + void queue_free(Queue* queue) + + int queue_push_head(Queue* queue, QueueValue data) + QueueValue queue_pop_head(Queue* queue) + QueueValue queue_peek_head(Queue* queue) + + int queue_push_tail(Queue* queue, QueueValue data) + QueueValue queue_pop_tail(Queue* queue) + QueueValue queue_peek_tail(Queue* queue) + + bint queue_is_empty(Queue* queue) + +Note how these declarations are almost identical to the header file +declarations, so you can often just copy them over. One exception is +the last line. The return value of the ``queue_is_empty`` method is +actually a C boolean value, i.e. it is either zero or non-zero, +indicating if the queue is empty or not. This is best expressed by +Cython's ``bint`` type, which is a normal ``int`` type when used in C +but maps to Python's boolean values ``True`` and ``False`` when +converted to a Python object. Another difference is the first +line. ``Queue`` is in this case used as an *opaque handle*; only the +library that is called know what is actually inside. Since no Cython code +needs to know the contents of the struct, we do not need to declare its contents, +so we simply provide an empty definition (as we do not want to declare +the ``_Queue`` type which is referenced in the C header) [#]_. + +.. [#] There's a subtle difference between ``cdef struct Queue: pass`` + and ``ctypedef struct Queue: pass``. The former declares a type + which is referenced in C code as ``struct Queue``, while the + latter is referenced in C as ``Queue``. This is a C language + quirk that Cython is not able to hide. Most modern C libraries + use the ``ctypedef`` kind of struct. + +Next, we need to design the Queue class that should wrap the C queue. +Here is a first start for the Queue class:: + + cimport cqueue + cimport python_exc + + cdef class Queue: + cdef cqueue.Queue _c_queue + def __cinit__(self): + self._c_queue = cqueue.new_queue() + +Note that it says ``__cinit__`` rather than ``__init__``. While +``__init__`` is available as well, it is not guaranteed to be run (for +instance, one could create a subclass and forget to call the ancestor +constructor). Because not initializing C pointers often leads to +crashing the Python interpreter without leaving as much as a stack +trace, Cython provides ``__cinit__`` which is *always* called on +construction. However, as ``__cinit__`` is called during object +construction, ``self`` is not fully +constructed yet, and one must avoid doing anything with ``self`` but +assigning to ``cdef`` fields. + +Note also that the above method takes no parameters, although subtypes +may want to accept some. Although it is guaranteed to get called, the +no-arguments ``__cinit__()`` method is a special case here as it does +not prevent subclasses from adding parameters as they see fit. If +parameters are added they must match those of any declared ``__init__`` +method. + +Before we continue implementing the other methods, it is important to +understand that the above implementation is not safe. In case +anything goes wrong in the call to ``new_queue()``, this code will +simply swallow the error, so we will likely run into a crash later on. +According to the documentation of the ``new_queue()`` function, the +only reason why the above can fail is due to insufficient memory. In +that case, it will return ``NULL``, whereas it would normally return a +pointer to the new queue. + +The normal way to get out of this is to raise an exception, but +allocating a new exception instance may actually fail when we are +running out of memory. Luckily, CPython provides a function +``PyErr_NoMemory()`` that raises the right exception for us. We can +thus change the init function as follows:: + + def __cinit__(self): + self._c_queue = cqueue.new_queue() + if self._c_queue is NULL: + python_exc.PyErr_NoMemory() + +The next thing to do is to clean up when the Queue is no longer used. +To this end, CPython provides a callback that Cython makes available +as a special method ``__dealloc__()``. In our case, all we have to do +is to free the Queue, but only if we succeeded in initialising it in +the init method:: + + def __dealloc__(self): + if self._c_queue is not NULL: + cqueue.queue_free(self._c_queue) + +At this point, we have a compilable Cython module that we can test. +To compile it, we need to configure a ``setup.py`` script for +distutils. Based on the example presented earlier on, we can extend +the script to include the necessary setup for building against the +external C library. Assuming it's installed in the normal places +(e.g. under ``/usr/lib`` and ``/usr/include`` on a Unix-like system), +we could simply change the extension setup from + +:: + + ext_modules = [Extension("hello", ["hello.pyx"])] + +to + +:: + + ext_modules = [ + Extension("hello", ["hello.pyx"], + libraries=["calg"]) + ] + +If it is not installed in a 'normal' location, users can provide the +required parameters externally by passing appropriate C compiler +flags, such as:: + + CFLAGS="-I/usr/local/otherdir/calg/include" \ + LDFLAGS="-L/usr/local/otherdir/calg/lib" \ + python setup.py build_ext -i + +Once we have compiled the module for the first time, we can try to +import it:: + + PYTHONPATH=. python -c 'import queue.Queue as Q; Q()' + +However, our class doesn't do much yet so far, so +let's make it more usable. + +Before implementing the public interface of this class, it is good +practice to look at what interfaces Python offers, e.g. in its +``list`` or ``collections.deque`` classes. Since we only need a FIFO +queue, it's enough to provide the methods ``append()``, ``peek()`` and +``pop()``, and additionally an ``extend()`` method to add multiple +values at once. Also, since we already know that all values will be +coming from C, it's better to provide only ``cdef`` methods for now, +and to give them a straight C interface. + +In C, it is common for data structures to store data as a ``void*`` to +whatever data item type. Since we only want to store ``int`` values, +which usually fit into the size of a pointer type, we can avoid +additional memory allocations through a trick: we cast our ``int`` values +to ``void*`` and vice versa, and store the value directly as the +pointer value. + +Here is a simple implementation for the ``append()`` method:: + + cdef append(self, int value): + cqueue.queue_push_tail(self._c_queue, value) + +Again, the same error handling considerations as for the +``__cinit__()`` method apply, so that we end up with this +implementation:: + + cdef append(self, int value): + if not cqueue.queue_push_tail(self._c_queue, + value): + python_exc.PyErr_NoMemory() + +Adding an ``extend()`` method should now be straight forward:: + + cdef extend(self, int* values, Py_ssize_t count): + """Append all ints to the queue. + """ + cdef Py_ssize_t i + for i in range(count): + if not cqueue.queue_push_tail( + self._c_queue, values[i]): + python_exc.PyErr_NoMemory() + +This becomes handy when reading values from a NumPy array, for +example. + +So far, we can only add data to the queue. The next step is to write +the two methods to get the first element: ``peek()`` and ``pop()``, +which provide read-only and destructive read access respectively:: + + cdef int peek(self): + return cqueue.queue_peek_head(self._c_queue) + + cdef int pop(self): + return cqueue.queue_pop_head(self._c_queue) + +Simple enough. Now, what happens when the queue is empty? According +to the documentation, the functions return a ``NULL`` pointer, which is +typically not a valid value. Since we are simply casting to and from +ints, we cannot distinguish anymore if the +return value was ``NULL`` because the queue was empty or because the +value stored in the queue was ``0``. However, in Cython code, we +would expect the first case to raise an exception, whereas the second +case should simply return ``0``. To deal with this, we need to +special case this value, and check if the queue really is empty or +not:: + + cdef int peek(self) except? 0: + cdef int value = \ + cqueue.queue_peek_head(self._c_queue) + if value == 0: + # this may mean that the queue is empty, or + # that it happens to contain a 0 value + if cqueue.queue_is_empty(self._c_queue): + raise IndexError("Queue is empty") + return value + +The ``except? 0`` declaration is worth explaining. If the function +was a Python function returning a Python object value, CPython would +simply return ``NULL`` instead of a Python object to indicate a raised +exception, which would immediately be propagated by the surrounding +code. The problem is that any ``int`` value is a valid queue item +value, so there is no way to explicitly indicate an error to the +calling code. + +The only way CPython (and Cython) can deal with this situation is to +call ``PyErr_Occurred()`` when returning from a function to check if +an exception was raised, and if so, propagate the exception. This +obviously has a performance penalty. Cython therefore allows you to +indicate which value is explicitly returned in the case of an +exception, so that the surrounding code only needs to check for an +exception when receiving this special value. All other values will be +accepted almost without a penalty. + +Now that the ``peek()`` method is implemented, the ``pop()`` method is +almost identical. It only calls a different C function:: + + cdef int pop(self) except? 0: + cdef int value = \ + cqueue.queue_pop_head(self._c_queue) + if value == 0: + # this may mean that the queue is empty, or + # that it happens to contain a 0 value + if cqueue.queue_is_empty(self._c_queue): + raise IndexError("Queue is empty") + return value + +Lastly, we can provide the Queue with an emptiness indicator in the +normal Python way:: + + def __nonzero__(self): + return not cqueue.queue_is_empty(self._c_queue) + +Note that this method returns either ``True`` or ``False`` as the +return value of the ``queue_is_empty`` function is declared as a +``bint``. + +Now that the implementation is complete, you may want to write some +tests for it to make sure it works correctly. Especially doctests are +very nice for this purpose, as they provide some documentation at the +same time. To enable doctests, however, you need a Python API that +you can call. C methods are not visible from Python code, and thus +not callable from doctests. + +A quick way to provide a Python API for the class is to change the +methods from ``cdef`` to ``cpdef``. This will let Cython generate two +entry points, one that is callable from normal Python code using the +Python call semantics and Python objects as arguments, and one that is +callable from C code with fast C semantics and without requiring +intermediate argument conversion from or to Python types. + +The following listing shows the complete implementation that uses +``cpdef`` methods where possible. This feature is obviously not +available for the ``extend()`` method, as the method signature is +incompatible with Python argument types. + +:: + + cimport cqueue + cimport python_exc + + cdef class Queue: + cdef cqueue.Queue* _c_queue + def __cinit__(self): + self._c_queue = cqueue.queue_new() + if self._c_queue is NULL: + python_exc.PyErr_NoMemory() + + def __dealloc__(self): + if self._c_queue is not NULL: + cqueue.queue_free(self._c_queue) + + cpdef append(self, int value): + if not cqueue.queue_push_tail(self._c_queue, + value): + python_exc.PyErr_NoMemory() + + cdef extend(self, int* values, Py_ssize_t count): + cdef Py_ssize_t i + for i in range(count): + if not cqueue.queue_push_tail( + self._c_queue, values[i]): + python_exc.PyErr_NoMemory() + + cpdef int peek(self) except? 0: + cdef int value = \ + cqueue.queue_peek_head(self._c_queue) + if value == 0: + # this may mean that the queue is empty, + # or that it happens to contain a 0 value + if cqueue.queue_is_empty(self._c_queue): + raise IndexError("Queue is empty") + return value + + cpdef int pop(self) except? 0: + cdef int value = \ + cqueue.queue_pop_head(self._c_queue) + if value == 0: + # this may mean that the queue is empty, + # or that it happens to contain a 0 value + if cqueue.queue_is_empty(self._c_queue): + raise IndexError("Queue is empty") + return value + + def __nonzero__(self): + return not cqueue.queue_is_empty(self._c_queue) + +As a quick test with numbers from 0 to 9999 indicates, using this +Queue from Cython code with C ``int`` values is about five times as +fast as using it from Cython code with Python values, almost eight +times faster than using it from Python code in a Python loop, and +still more than twice as fast as using Python's highly optimised +``collections.deque`` type from Cython code with Python integers. + +.. [CAlg] Simon Howard, C Algorithms library, http://c-algorithms.sourceforge.net/ diff --git a/src/tutorial/cythonize.rst b/src/tutorial/cythonize.rst new file mode 100644 index 00000000..f77abddf --- /dev/null +++ b/src/tutorial/cythonize.rst @@ -0,0 +1,44 @@ +Faster code by adding types +=========================== + +Consider the following pure Python code:: + + from math import sin + + def f(x): + return sin(x**2) + + def integrate_f(a, b, N): + s = 0 + dx = (b-a)/N + for i in range(N): + s += f(a+i*dx) + return s * dx + +Simply compiling this in Cython merely gives a 5% speedup. This is +better than nothing, but adding some static types can make a much larger +difference. + +With additional type declarations, this might look like:: + + from math import sin + + def f(double x): + return sin(x**2) + + def integrate_f(double a, double b, int N): + cdef int i + cdef double s, dx + s = 0 + dx = (b-a)/N + for i in range(N): + s += f(a+i*dx) + return s * dx + +Since the iterator variable ``i`` is typed with C semantics, the for-loop will be compiled +to pure C code. Typing ``a``, ``s`` and ``dx`` is important as they are involved +in arithmetic withing the for-loop; typing ``b`` and ``N`` makes less of a +difference, but in this case it is not much extra work to be +consistent and type the entire function. + +This results in a 24 times speedup over the pure Python version. diff --git a/src/tutorial/data.py b/src/tutorial/data.py new file mode 100644 index 00000000..f0027629 --- /dev/null +++ b/src/tutorial/data.py @@ -0,0 +1,40 @@ +{ + 'title': 'Cython Tutorial', + 'paper_abstract': ''' +Cython is a programming language based on Python with extra +syntax to provide static type declarations. This takes advantage of the +benefits of Python while allowing one to achieve the speed of C. +In this paper we describe the Cython language and show how it can +be used both to write optimized code and to interface with external +C libraries. +''', + 'authors': [ + {'first_names': 'Stefan', + 'surname': 'Behnel', + 'address': '', + 'country': 'Germany', + 'email_address': 'stefan\_ml@behnel.de', + 'institution': ''}, + {'first_names': 'Robert W.', + 'surname': 'Bradshaw', + 'address': '', + 'country': 'USA', + 'email_address': 'robertwb@math.washington.edu', + 'institution': '''University of Washington\\footnote{ + Department of Mathematics, University of Washington, Seattle, WA, USA + }'''}, + {'first_names': 'Dag Sverre', + 'surname': 'Seljebotn', + 'address': '', + 'country': 'Norway', + 'email_address': 'dagss@student.matnat.uio.no', + # I need three institutions w/ full address... leave it + # all here until we get to editing stage + 'institution': '''University of Oslo\\footnote{Institute of Theoretical Astrophysics, + University of Oslo, P.O. Box 1029 Blindern, N-0315 Oslo, Norway}\\footnote{Department + of Mathematics, University of Oslo, P.O. Box 1053 Blindern, + N-0316 Oslo, Norway}\\footnote{Centre of Mathematics for + Applications, University of Oslo, P.O. Box 1053 Blindern, N-0316 + Oslo, Norway}'''} + ], +} diff --git a/src/tutorial/datatypes.rst b/src/tutorial/datatypes.rst new file mode 100644 index 00000000..b94206a3 --- /dev/null +++ b/src/tutorial/datatypes.rst @@ -0,0 +1,24 @@ +Data types in Cython +==================== + +Cython is a Python compiler. This means that it can compile normal +Python code without changes (with a few obvious exceptions of some as-yet +unsupported language features). However, for performance critical +code, it is often helpful to add static type declarations, as they +will allow Cython to step out of the dynamic nature of the Python code +and generate simpler and faster C code - sometimes faster by orders of +magnitude. + +It must be noted, however, that type declarations can make the source +code more verbose and thus less readable. It is therefore discouraged +to use them without good reason, such as where benchmarks prove +that they really make the code substantially faster in a performance +critical section. Typically a few types in the right spots go a long way. + +All C types are available for type declarations: integer and floating +point types, complex numbers, structs, unions and pointer types. +Cython can automatically and correctly convert between the types on +assignment. This also includes Python's arbitrary size integer types, +where value overflows on conversion to a C type will raise a Python +``OverflowError`` at runtime. The generated C code will handle the +platform dependent sizes of C types correctly and safely in this case. diff --git a/src/tutorial/external.rst b/src/tutorial/external.rst new file mode 100644 index 00000000..dc40480e --- /dev/null +++ b/src/tutorial/external.rst @@ -0,0 +1,52 @@ +Calling external C functions +============================ + +It is perfectly OK do ``from math import sin`` to use Python's +``sin()`` function. However, calling C's own ``sin()`` function is +substantially faster, especially in tight loops. It can be declared +and used in Cython as follows:: + + cdef extern from "math.h": + double sin(double) + + cdef double f(double x): + return sin(x*x) + +At this point there are no longer any Python wrapper objects around +our values inside of the main for loop, and so we get an impressive +speedup to 219 times the speed of Python. + +Note that the above code re-declares the function from ``math.h`` to +make it available to Cython code. The C compiler will see the +original declaration in ``math.h`` at compile time, but Cython +does not parse "math.h" and requires a separate definition. + +When calling C functions, one must take care to link in the appropriate +libraries. This can be platform-specific; the below example works on Linux +and Mac OS X:: + + from distutils.core import setup + from distutils.extension import Extension + from Cython.Distutils import build_ext + + ext_modules=[ + Extension("demo", + ["demo.pyx"], + libraries=["m"]) # Unix-like specific + ] + + setup( + name = "Demos", + cmdclass = {"build_ext": build_ext}, + ext_modules = ext_modules + ) + +If one uses the Sage notebook to compile Cython code, one can use a special +comment to tell Sage to link in libraries:: + + #clib: m + +Just like the ``sin()`` function from the math library, it is possible +to declare and call into any C library as long as the module that +Cython generates is properly linked against the shared or static +library. diff --git a/src/tutorial/htmlreport.png b/src/tutorial/htmlreport.png new file mode 100644 index 0000000000000000000000000000000000000000..a07a53dfb65c39af7346d164762ef6733de2f660 GIT binary patch literal 51573 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 literal 0 HcmV?d00001 diff --git a/src/tutorial/index.rst b/src/tutorial/index.rst new file mode 100644 index 00000000..f9219148 --- /dev/null +++ b/src/tutorial/index.rst @@ -0,0 +1,33 @@ +Cython Tutorial +=============== + +Contents: + +.. toctree:: + :maxdepth: 2 + + overview + install + build + datatypes + cythonize + cdef_functions + external + cdef_classes + pxd_files + caveats + numpy + strings + clibraries + readings + related_work + appendix + references + + +Indices and tables +================== + +* :ref:`genindex` +* :ref:`modindex` +* :ref:`search` diff --git a/src/tutorial/install.rst b/src/tutorial/install.rst new file mode 100644 index 00000000..626b4347 --- /dev/null +++ b/src/tutorial/install.rst @@ -0,0 +1,52 @@ +Installing Cython +================= + +Many scientific Python distributions, such as the Enthought Python +Distribution [EPD]_, Python(x,y) [Pythonxy]_, and Sage [Sage]_, bundle +Cython and no setup is needed. Note however that if your distribution +ships a version of Cython which is too old you can still use the +instructions below to update Cython. Everything in this tutorial +should work with Cython 0.11.2 and newer, unless a footnote says +otherwise. + +Unlike most Python software, Cython requires a C compiler to be +present on the system. The details of getting a C compiler varies +according to the system used: + + - **Linux** The GNU C Compiler (gcc) is usually present, or easily + available through the package system. On Ubuntu or Debian, for + instance, the command ``sudo apt-get install build-essential`` will + fetch everything you need. + + - **Mac OS X** To retrieve gcc, one option is to install Apple's + XCode, which can be retrieved from the Mac OS X's install DVDs or + from http://developer.apple.com. + + - **Windows** A popular option is to use the open source MinGW (a + Windows distribution of gcc). See the appendix for instructions for + setting up MinGW manually. EPD and Python(x,y) bundle MinGW, but + some of the configuration steps in the appendix might still be + necessary. Another option is to use Microsoft's Visual C. One must + then use the same version which the installed Python was compiled + with. + +.. dagss tried other forms of ReST lists and they didn't look nice +.. with rst2latex. + +The newest Cython release can always be downloaded from +http://cython.org. Unpack the tarball or zip file, enter the +directory, and then run:: + + python setup.py install + +If you have Python setuptools set up on your system, you should be +able to fetch Cython from PyPI and install it using:: + + easy_install cython + +For Windows there is also an executable installer available for +download. + +.. [EPD] http://www.enthought.com/products/epd.php +.. [Pythonxy] http://www.pythonxy.com/ +.. [Sage] W. Stein et al., Sage Mathematics Software, http://sagemath.org diff --git a/src/tutorial/numpy.rst b/src/tutorial/numpy.rst new file mode 100644 index 00000000..9551bd00 --- /dev/null +++ b/src/tutorial/numpy.rst @@ -0,0 +1,106 @@ +Using Cython with NumPy +======================= + +Cython has support for fast access to NumPy arrays. To optimize code +using such arrays one must ``cimport`` the NumPy pxd file (which ships +with Cython), and declare any arrays as having the ``ndarray`` +type. The data type and number of dimensions should be fixed at +compile-time and passed. For instance:: + + import numpy as np + cimport numpy as np + def myfunc(np.ndarray[np.float64_t, ndim=2] A): + <...> + +``myfunc`` can now only be passed two-dimensional arrays containing +double precision floats, but array indexing operation is much, much faster, +making it suitable for numerical loops. Expect speed increases well +over 100 times over a pure Python loop; in some cases the speed +increase can be as high as 700 times or more. [Seljebotn09]_ +contains detailed examples and benchmarks. + +Fast array declarations can currently only be used with function +local variables and arguments to ``def``-style functions (not with +arguments to ``cpdef`` or ``cdef``, and neither with fields in cdef +classes or as global variables). These limitations are considered +known defects and we hope to remove them eventually. In most +circumstances it is possible to work around these limitations rather +easily and without a significant speed penalty, as all NumPy arrays +can also be passed as untyped objects. + +Array indexing is only optimized if exactly as many indices are +provided as the number of array dimensions. Furthermore, all indices +must have a native integer type. Slices and NumPy "fancy indexing" is +not optimized. Examples:: + + def myfunc(np.ndarray[np.float64_t, ndim=1] A): + cdef Py_ssize_t i, j + for i in range(A.shape[0]): + print A[i, 0] # fast + j = 2*i + print A[i, j] # fast + k = 2*i + print A[i, k] # slow, k is not typed + print A[i][j] # slow + print A[i,:] # slow + +``Py_ssize_t`` is a signed integer type provided by Python which +covers the same range of values as is supported as NumPy array +indices. It is the preferred type to use for loops over arrays. + +Any Cython primitive type (float, complex float and integer types) can +be passed as the array data type. For each valid dtype in the ``numpy`` +module (such as ``np.uint8``, ``np.complex128``) there is a +corresponding Cython compile-time definition in the cimport-ed NumPy +pxd file with a ``_t`` suffix [#]_. Cython structs are also allowed +and corresponds to NumPy record arrays. Examples:: + + cdef packed struct Point: + np.float64_t x, y + + def f(): + cdef np.ndarray[np.complex128_t, ndim=3] a = \ + np.zeros((3,3,3), dtype=np.complex128) + cdef np.ndarray[Point] b = np.zeros(10, + dtype=np.dtype([('x', np.float64), + ('y', np.float64)])) + <...> + +Note that ``ndim`` defaults to 1. Also note that NumPy record arrays +are by default unaligned, meaning data is packed as tightly as +possible without considering the alignment preferences of the +CPU. Such unaligned record arrays corresponds to a Cython ``packed`` +struct. If one uses an aligned dtype, by passing ``align=True`` to the +``dtype`` constructor, one must drop the ``packed`` keyword on the +struct definition. + +Some data types are not yet supported, like boolean arrays and string +arrays. Also data types describing data which is not in the native +endian will likely never be supported. It is however possible to +access such arrays on a lower level by casting the arrays:: + + cdef np.ndarray[np.uint8, cast=True] boolarr = (x < y) + cdef np.ndarray[np.uint32, cast=True] values = \ + np.arange(10, dtype='>i4') + +Assuming one is on a little-endian system, the ``values`` array +can still access the raw bit content of the array (which must then +be reinterpreted to yield valid results on a little-endian system). + +Finally, note that typed NumPy array variables in some respects behave +a little differently from untyped arrays. ``arr.shape`` is no longer a +tuple. ``arr.shape[0]`` is valid but to e.g. print the shape one must +do ``print (arr).shape`` in order to "untype" the variable +first. The same is true for ``arr.data`` (which in typed mode is a C +data pointer). + +There are many more options for optimizations to consider for Cython +and NumPy arrays. We again refer the interested reader to [Seljebotn09]_. + +.. [#] In Cython 0.11.2, ``np.complex64_t`` and ``np.complex128_t`` + does not work and one must write ``complex`` or + ``double complex`` instead. This is fixed in 0.11.3. Cython + 0.11.1 and earlier does not support complex numbers. + +.. [Seljebotn09] D. S. Seljebotn, Fast numerical computations with Cython, + Proceedings of the 8th Python in Science Conference, 2009. diff --git a/src/tutorial/overview.rst b/src/tutorial/overview.rst new file mode 100644 index 00000000..c0807759 --- /dev/null +++ b/src/tutorial/overview.rst @@ -0,0 +1,54 @@ +Cython - an overview +==================== + +[Cython]_ is a programming language based on Python, with extra syntax +allowing for optional static type declarations. It aims to become a superset +of the [Python]_ language which gives it high-level, object-oriented, +functional, and dynamic programming. The source code gets translated +into optimized C/C++ code and compiled as Python extension modules. +This allows for both very fast program execution and tight integration +with external C libraries, while keeping up the high programmer +productivity for which the Python language is well known. + +The primary Python execution environment is commonly referred to as +CPython, as it is written in C. Other major implementations use Java +(Jython [Jython]_), C# (IronPython [IronPython]_) and Python itself +(PyPy [PyPy]_). Written in C, CPython has been conducive to wrapping +many external libraries that interface through the C language. It +has, however, remained non trivial to write the necessary glue code in +C, especially for programmers who are more fluent in a high-level +language like Python than in a do-it-yourself language like C. + +Originally based on the well-known Pyrex [Pyrex]_, the Cython project has +approached this problem by means of a source code compiler that +translates Python code to equivalent C code. This code is executed +within the CPython runtime environment, but at the speed of compiled C +and with the ability to call directly into C libraries. +At the same time, it keeps the original interface of the Python +source code, which makes it directly usable from Python code. These +two-fold characteristics enable Cython's two major use cases: +extending the CPython interpreter with fast binary modules, and +interfacing Python code with external C libraries. + +While Cython can compile (most) regular Python code, the generated C +code usually gains major (and sometime impressive) speed improvements +from optional static type declarations for both Python and C types. +These allow Cython to assign C semantics to parts of the code, and to +translate them into very efficient C code. Type declarations can +therefore be used for two purposes: for moving code sections from +dynamic Python semantics into static-and-fast C semantics, but also +for directly manipulating types defined in external libraries. Cython +thus merges the two worlds into a very broadly applicable programming +language. + +.. [Cython] G. Ewing, R. W. Bradshaw, S. Behnel, D. S. Seljebotn et al., + The Cython compiler, http://cython.org. +.. [IronPython] Jim Hugunin et al., http://www.codeplex.com/IronPython. +.. [Jython] J. Huginin, B. Warsaw, F. Bock, et al., + Jython: Python for the Java platform, http://www.jython.org/ +.. [PyPy] The PyPy Group, PyPy: a Python implementation written in Python, + http://codespeak.net/pypy. +.. [Pyrex] G. Ewing, Pyrex: C-Extensions for Python, + http://www.cosc.canterbury.ac.nz/greg.ewing/python/Pyrex/ +.. [Python] G. van Rossum et al., The Python programming language, + http://python.org. diff --git a/src/tutorial/pxd_files.rst b/src/tutorial/pxd_files.rst new file mode 100644 index 00000000..c120c8b9 --- /dev/null +++ b/src/tutorial/pxd_files.rst @@ -0,0 +1,41 @@ +pxd files +========= + +In addition to the ``.pyx`` source files, Cython uses ``.pxd`` files +which work like C header files--they contain Cython declarations +(and sometimes code sections) which are only meant for inclusion by +Cython modules. A ``pxd`` file is imported into a ``pyx`` module by +using the ``cimport`` keyword. + +``pxd`` files have many use-cases: + + 1. They can be used for sharing external C declarations. + 2. They can contain functions which are well suited for inlining by + the C compiler. Such functions should be marked ``inline``, example: + :: + + cdef inline int int_min(int a, int b): + return b if b < a else a + + 3. When accompanying an equally named ``pyx`` file, they + provide a Cython interface to the Cython module so that other + Cython modules can communicate with it using a more efficient + protocol than the Python one. + +In our integration example, we might break it up into ``pxd`` files like this: + + 1. Add a ``cmath.pxd`` function which defines the C functions available from + the C ``math.h`` header file, like ``sin``. Then one would simply do + ``from cmath import sin`` in ``integrate.pyx``. + 2. Add a ``integrate.pxd`` so that other modules written in Cython + can define fast custom functions to integrate. + :: + + cdef class Function: + cpdef evaluate(self, double x) + cpdef integrate(Function f, double a, + double b, int N) + + Note that if you have a cdef class with attributes, the attributes must + be declared in the class declaration ``pxd`` file (if you use one), not + the ``pyx`` file. The compiler will tell you about this. diff --git a/src/tutorial/queue_example/cqueue.pxd b/src/tutorial/queue_example/cqueue.pxd new file mode 100644 index 00000000..a6c5d575 --- /dev/null +++ b/src/tutorial/queue_example/cqueue.pxd @@ -0,0 +1,17 @@ +cdef extern from "libcalg/queue.h": + ctypedef struct Queue: + pass + ctypedef void* QueueValue + + Queue* queue_new() + void queue_free(Queue* queue) + + int queue_push_head(Queue* queue, QueueValue data) + QueueValue queue_pop_head(Queue* queue) + QueueValue queue_peek_head(Queue* queue) + + int queue_push_tail(Queue* queue, QueueValue data) + QueueValue queue_pop_tail(Queue* queue) + QueueValue queue_peek_tail(Queue* queue) + + int queue_is_empty(Queue* queue) diff --git a/src/tutorial/queue_example/queue.pyx b/src/tutorial/queue_example/queue.pyx new file mode 100644 index 00000000..fd8addf7 --- /dev/null +++ b/src/tutorial/queue_example/queue.pyx @@ -0,0 +1,95 @@ +cimport cqueue +cimport python_exc + +cdef class Queue: + cdef cqueue.Queue* _c_queue + def __cinit__(self): + self._c_queue = cqueue.queue_new() + if self._c_queue is NULL: + python_exc.PyErr_NoMemory() + + def __dealloc__(self): + if self._c_queue is not NULL: + cqueue.queue_free(self._c_queue) + + cpdef int append(self, int value) except -1: + if not cqueue.queue_push_tail(self._c_queue, value): + python_exc.PyErr_NoMemory() + return 0 + + cdef int extend(self, int* values, Py_ssize_t count) except -1: + cdef Py_ssize_t i + for i in xrange(count): + if not cqueue.queue_push_tail(self._c_queue, values[i]): + python_exc.PyErr_NoMemory() + return 0 + + cpdef int peek(self) except? 0: + cdef int value = cqueue.queue_peek_head(self._c_queue) + if value == 0: + # this may mean that the queue is empty, or that it + # happens to contain a 0 value + if cqueue.queue_is_empty(self._c_queue): + raise IndexError("Queue is empty") + return value + + cpdef int pop(self) except? 0: + cdef int value = cqueue.queue_pop_head(self._c_queue) + if value == 0: + # this may mean that the queue is empty, or that it + # happens to contain a 0 value + if cqueue.queue_is_empty(self._c_queue): + raise IndexError("Queue is empty") + return value + + def __nonzero__(self): + return not cqueue.queue_is_empty(self._c_queue) + +DEF repeat_count=10000 + +def test_cy(): + cdef int i + cdef Queue q = Queue() + for i in xrange(repeat_count): + q.append(i) + for i in xrange(repeat_count): + q.peek() + while q: + q.pop() + +def test_py(): + cdef int i + q = Queue() + for i in xrange(repeat_count): + q.append(i) + for i in xrange(repeat_count): + q.peek() + while q: + q.pop() + +from collections import deque + +def test_deque(): + cdef int i + q = deque() + for i in xrange(repeat_count): + q.appendleft(i) + for i in xrange(repeat_count): + q[-1] + while q: + q.pop() + +repeat = range(repeat_count) + +def test_py_exec(): + q = Queue() + d = dict(q=q, repeat=repeat) + + exec u"""\ +for i in repeat: + q.append(9) +for i in repeat: + q.peek() +while q: + q.pop() +""" in d diff --git a/src/tutorial/readings.rst b/src/tutorial/readings.rst new file mode 100644 index 00000000..135ad563 --- /dev/null +++ b/src/tutorial/readings.rst @@ -0,0 +1,26 @@ +Further reading +=============== + +The main documentation is located at http://docs.cython.org/. Some +recent features might not have documentation written yet, in such +cases some notes can usually be found in the form of a Cython +Enhancement Proposal (CEP) on http://wiki.cython.org/enhancements. + +[Seljebotn09]_ contains more information about Cython and NumPy +arrays. If you intend to use Cython code in a multi-threaded setting, +it is essential to read up on Cython's features for managing the +Global Interpreter Lock (the GIL). The same paper contains an +explanation of the GIL, and the main documentation explains the Cython +features for managing it. + +Finally, don't hesitate to ask questions (or post reports on +successes!) on the Cython users mailing list [UserList]_. The Cython +developer mailing list, [DevList]_, is also open to everybody. Feel +free to use it to report a bug, ask for guidance, if you have time to +spare to develop Cython, or if you have suggestions for future +development. + +.. [DevList] Cython developer mailing list: http://codespeak.net/mailman/listinfo/cython-dev. +.. [Seljebotn09] D. S. Seljebotn, Fast numerical computations with Cython, + Proceedings of the 8th Python in Science Conference, 2009. +.. [UserList] Cython users mailing list: http://groups.google.com/group/cython-users diff --git a/src/tutorial/references.rst b/src/tutorial/references.rst new file mode 100644 index 00000000..10d738ec --- /dev/null +++ b/src/tutorial/references.rst @@ -0,0 +1,32 @@ +References +========== + +.. [Cython] G. Ewing, R. W. Bradshaw, S. Behnel, D. S. Seljebotn et al., + The Cython compiler, http://cython.org. +.. [Python] G. van Rossum et al., The Python programming language, + http://python.org. +.. [Sage] W. Stein et al., Sage Mathematics Software, http://sagemath.org +.. [EPD] http://www.enthought.com/products/epd.php +.. [Pythonxy] http://www.pythonxy.com/ +.. [Jython] J. Huginin, B. Warsaw, F. Bock, et al., + Jython: Python for the Java platform, http://www.jython.org/ +.. [Seljebotn09] D. S. Seljebotn, Fast numerical computations with Cython, + Proceedings of the 8th Python in Science Conference, 2009. +.. [NumPy] T. Oliphant et al., NumPy, http://numpy.scipy.org/ +.. [CAlg] Simon Howard, C Algorithms library, http://c-algorithms.sourceforge.net/ +.. [Pyrex] G. Ewing, Pyrex: C-Extensions for Python, + http://www.cosc.canterbury.ac.nz/greg.ewing/python/Pyrex/ +.. [ShedSkin] M. Dufour, J. Coughlan, ShedSkin, + http://code.google.com/p/shedskin/ +.. [PyPy] The PyPy Group, PyPy: a Python implementation written in Python, + http://codespeak.net/pypy. +.. [IronPython] Jim Hugunin et al., http://www.codeplex.com/IronPython. +.. [SWIG] David M. Beazley et al., + SWIG: An Easy to Use Tool for Integrating Scripting Languages with C and C++, + http://www.swig.org. +.. [WinInst] http://wiki.cython.org/InstallingOnWindows +.. [ctypes] http://docs.python.org/library/ctypes.html. +.. there's also the original ctypes home page: http://python.net/crew/theller/ctypes/ +.. [UserList] Cython users mailing list: http://groups.google.com/group/cython-users +.. [DevList] Cython developer mailing list: http://codespeak.net/mailman/listinfo/cython-dev. + diff --git a/src/tutorial/related_work.rst b/src/tutorial/related_work.rst new file mode 100644 index 00000000..6234e8ae --- /dev/null +++ b/src/tutorial/related_work.rst @@ -0,0 +1,49 @@ +Related work +============ + +Pyrex [Pyrex]_ is the compiler project that Cython was originally based on. +Many features and the major design decisions of the Cython language +were developed by Greg Ewing as part of that project. Today, Cython +supersedes the capabilities of Pyrex by providing a higher +compatibility with Python code and Python semantics, as well as +superior optimisations and better integration with scientific Python +extensions like NumPy. + +ctypes [ctypes]_ is a foreign function interface (FFI) for Python. It +provides C compatible data types, and allows calling functions in DLLs +or shared libraries. It can be used to wrap these libraries in pure +Python code. Compared to Cython, it has the major advantage of being +in the standard library and being usable directly from Python code, +without any additional dependencies. The major drawback is its +performance, which suffers from the Python call overhead as all +operations must pass through Python code first. Cython, being a +compiled language, can avoid much of this overhead by moving more +functionality and long-running loops into fast C code. + +SWIG [SWIG]_ is a wrapper code generator. It makes it very easy to parse +large API definitions in C/C++ header files, and to generate straight +forward wrapper code for a large set of programming languages. As +opposed to Cython, however, it is not a programming language itself. +Thin wrappers are easy to generate, but the more functionality a +wrapper needs to provide, the harder it gets to implement it with +SWIG. Cython, on the other hand, makes it very easy to write very +elaborate wrapper code specifically for the Python language. Also, +there exists third party code for parsing C header files and using it +to generate Cython definitions and module skeletons. + +ShedSkin [ShedSkin]_ is an experimental Python-to-C++ compiler. It +uses profiling information and very powerful type inference engine +to generate a C++ program from (restricted) Python source code. +The main drawback is has no support for calling the Python/C API for +operations it does not support natively, and supports very few of the +standard Python modules. + +.. [ctypes] http://docs.python.org/library/ctypes.html. +.. there's also the original ctypes home page: http://python.net/crew/theller/ctypes/ +.. [Pyrex] G. Ewing, Pyrex: C-Extensions for Python, + http://www.cosc.canterbury.ac.nz/greg.ewing/python/Pyrex/ +.. [ShedSkin] M. Dufour, J. Coughlan, ShedSkin, + http://code.google.com/p/shedskin/ +.. [SWIG] David M. Beazley et al., + SWIG: An Easy to Use Tool for Integrating Scripting Languages with C and C++, + http://www.swig.org. diff --git a/src/tutorial/sage.png b/src/tutorial/sage.png new file mode 100644 index 0000000000000000000000000000000000000000..b19df05d8ec53ab4cfcd01fc2acfdbd7eb4aa64e GIT binary patch literal 78281 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