c_c++_python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Extending Python with C (and C++)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Marco De Pascale . Py@AstroPD 30/01/2018"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. [Introduction](#introduction)\n",
    "2. [Cython inside Jupiter](#cyjupiter)\n",
    "3. [Cython outside Jypiter](#cynojupiter)\n",
    "4. [Static typing](#faster)\n",
    "5. [Examples](#examples)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I will introduce on the use on Cython as an easy way to extends Python with C/C++ code.  <a name=\"introduction\"></a>\n",
    "\n",
    "> _Cython is a superset of the Python programming language, designed to give **C**-like performance with code which is **mostly written in Python** [Wikipedia]_\n",
    "\n",
    "[//]: <> (https://simplyml.com/python-ml/)\n",
    "\n",
    "![](img/runtimes_202.png?raw=true)\n",
    "\n",
    "> Cython works by producing a standard Python module. However, the behavior differs from standard Python in that the module code, originally written in Python, is translated into **C**\n",
    "\n",
    "Just to stress it, as a standard Cython generates C code, **NOT C++**.\n",
    "\n",
    "Cython is a fork of [Pyrex](http://www.cosc.canterbury.ac.nz/greg.ewing/python/Pyrex/), and is developed by, and for, [Sage](https://en.wikipedia.org/wiki/SageMath)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Install\n",
    "\n",
    "Now, did you install `cython`? \n",
    "Anaconda should ship with it, if not run:\n",
    "```\n",
    "conda install cython\n",
    "```\n",
    "Additionally, Cython needs the C compiler, so you should get it for you OS\n",
    "+ **Linux**: get gcc from repository\n",
    "+ **MacOS**: get Apple XCode from DVD or http://developer.apple.com \n",
    "+ **Windows**: use the open source MinDW. Cython documentation has an appendix on this (http://docs.cython.org/en/latest/src/tutorial/appendix.html).\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Cython inside Jupiter Notebook  <a name=\"cyjupiter\"></a>\n",
    "\n",
    "Use the magic symbol `%` !"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# The following \"magic\" command is to enable support for Cython compilation\n",
    "%load_ext Cython"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# To compile the notebook cell, you need a second magic command %%cython.\n",
    "# NOTE: It has to be the first instruction in the cell!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "%%cython\n",
    "#%%cython --annotate\n",
    "from astropy import constants as const\n",
    "def say_hello_to(name):\n",
    "    print(\"Hello %s!\" % name)\n",
    "    print(const.c.value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World!\n",
      "299792458.0\n"
     ]
    }
   ],
   "source": [
    "say_hello_to(\"World\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Cython ouside Jupyter <a name=\"cynojupiter\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is the normal way of using Cython. You need to write 2 files:\n",
    "+ the source code, with extension `.pyx`\n",
    "+ a `setup.py` file to invoke the `setuptools` build process that generates the module"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The `source` code\n",
    "\n",
    "Save following code in `hello.pyx`\n",
    "```\n",
    "def say_hello_to(name):\n",
    "    print(\"Hello %s!\" % name)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The `setup.py` file\n",
    "\n",
    "Save following code in `setup.py`\n",
    "\n",
    "```\n",
    "from distutils.core import setup\n",
    "from Cython.Build import cythonize\n",
    "\n",
    "setup(\n",
    "  name = 'Hello world app',\n",
    "  ext_modules = cythonize(\"hello.pyx\"),\n",
    ")\n",
    "```\n",
    "\n",
    "Build running the command\n",
    "```\n",
    "python setup.py build_ext --inplace\n",
    "```\n",
    "\n",
    "The above command generates the Cython source file(s)\n",
    "\n",
    "Finally, from a Python session import the function to use it"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello Pippo!\n"
     ]
    }
   ],
   "source": [
    "from hello import say_hello_to\n",
    "say_hello_to(\"Pippo\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Quite long... but if you are not using the notebook, that is the way.\n",
    "Probably you need this way to profile your code."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Avoiding the `setup.py`\n",
    "\n",
    "If you do not require extra C libraries, you can use the `pyximport` module. \n",
    "It will load `.pyx` files directly on import.\n",
    "\n",
    "You would do something like:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello pyximport!\n"
     ]
    }
   ],
   "source": [
    "import pyximport; pyximport.install()\n",
    "from hello import say_hello_to\n",
    "\n",
    "say_hello_to(\"pyximport\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Faster code via static typing <a name=\"faster\"></a>\n",
    "\n",
    "Cython is a Python compiler. This means that it can compile normal Python code without changes\n",
    "\n",
    "> For performance critical code, it is often helpful to add **static type declarations**. They will allow Cython to generate simpler and **faster C code**.\n",
    "\n",
    "This is achieved by stepping out of the dynamic nature of the Python code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "%%cython\n",
    "cdef int i\n",
    "cdef float f\n",
    "# ...\n",
    "cdef:\n",
    "    int w, z\n",
    "    bint b\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "All standard C types are available: `char`, `short`, `int`, `long`, `long long` as well as their `unsigned` version.\n",
    "\n",
    "For booleans there is the special `bint` type.\n",
    "\n",
    "You can declare also pointer as in C with the `*`: \n",
    "```\n",
    "cdef int *n\n",
    "```\n",
    "\n",
    "And functions\n",
    "\n",
    "```\n",
    "cdef int eggs(unsigned long l, float f):\n",
    "```\n",
    "\n",
    "> This can make the source code more verbose and thus less readable. **It is therefore discouraged to use them without good reason**. Typically a few types in the right spots go a long way.\n",
    "\n",
    "#### Right spots?!\n",
    "Two essential tools to help with this task are [**profiling**](http://docs.cython.org/en/latest/src/tutorial/profiling_tutorial.html) and **annotation**....\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Examples <a name=\"examples\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Fibonacci"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%cython\n",
    "#%%cython --annotate\n",
    "def fib (n):\n",
    "    \"\"\"Print the Fibonacci series up to n.\"\"\"\n",
    "    a, b = 0, 1\n",
    "    while b < n:\n",
    "        print(b),\n",
    "        a, b = b, a + b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Adding some static typing (in rigth spots?)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "%%cython\n",
    "#%%cython --annotate\n",
    "cdef fib (int n):\n",
    "    \"\"\"Print the Fibonacci series up to n.\"\"\"\n",
    "    #a, b = 0, 1\n",
    "    cdef int a=0\n",
    "    cdef int b=1\n",
    "    while b < n:\n",
    "        print(b),\n",
    "        a, b = b, a + b"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}