Python for scientific computing.ipynb

{
 "cells": [
  {
   "attachments": {
    "anaconda.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    \n",
    "# Python for scientific computing\n",
    "\n",
    "<a href=\"https://lb-aps-frontend.statista.com/chart/21017/most-popular-programming-languages/\" title=\"Infographic: Python Remains Most Popular Programming Language | Statista\"><img src=\"https://cdn.statcdn.com/Infographic/images/normal/21017.jpeg\" alt=\"Infographic: Python Remains Most Popular Programming Language | Statista\" width=\"50%\" height=\"auto\" style=\"width: 50%; height: auto !important; max-width:960px;-ms-interpolation-mode: bicubic;\"/></a> You will find more infographics at <a href=\"https://lb-aps-frontend.statista.com/chartoftheday/\">Statista</a>\n",
    "\n",
    "\n",
    "<img src=\"bilder/data-scientist-skills-statistics-966x807.jpeg\" width=500>\n",
    "\n",
    "<font size=\"4\">\n",
    "<ul>\n",
    "  <li>Python is today usually considered the most popular programming language in the world for scientific computing</li>\n",
    "  <li>With over 25 million users worldwide, Anaconda Python is the most poplar edition of Python for scientific computing</li>\n",
    "  \n",
    "</ul>    \n",
    "</font>\n",
    "    \n",
    "![anaconda.png](attachment:anaconda.png)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For example, I am using Anaconda Python to run this Jupyter notebook. With conda I can set up different environments for computing. This environment is named fortran, because I have a fortran compiler installed here."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-info\">\n",
    "    <h4>Some facts</h4>\n",
    "    <ul>\n",
    "        <li>Python is written in C!</li>\n",
    "    <li>Python became popular for scientific computing when scientists discovered that it was very easy to wrap existing and fast Fortran libraries (like BLAS, LAPACK etc.), and call them from Python </li>\n",
    "        <li>My kids learn Python programming in their Mathematics classes in high-school in Norway</li>\n",
    "    </ul>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# How about computational speed?\n",
    "\n",
    "Python in itself is not very fast, but there are excellent and easy to use tools for optimizations. Lets consider the dot-product between two vectors $\\mathbf{u}$ and $\\mathbf{v}$\n",
    "\n",
    "$$\n",
    "\\begin{align*}\n",
    "\\mathbf{u} &= (u_0, u_1, \\ldots, u_{N-1}) \\\\\n",
    "\\mathbf{v} &= (v_0, v_1, \\ldots, v_{N-1}) \\\\\n",
    "c &= \\mathbf{u} \\cdot \\mathbf{v} = \\sum_{i=0}^{N-1}u_i v_i\n",
    "\\end{align*}\n",
    "$$\n",
    "\n",
    "We use the [Numpy](https://numpy.org) module for scientific computing with arrays."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "N = 1000000\n",
    "u = np.random.random(N)\n",
    "v = np.random.random(N)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First a naive Python implementation of the dot product"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def dot(a, b):\n",
    "    c = 0.0\n",
    "    N = a.shape[0]\n",
    "    for i in range(N):\n",
    "        c += a[i]*b[i]\n",
    "    return c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%timeit c = dot(u, v)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "How fast is this? Compared with fortran or C? It's actually pretty slow:-(\n",
    "\n",
    "However, there are numerous alternative options. We can compute it using a vectorized elementwise multiplication and sum:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%timeit c = np.sum(u*v)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So vectorization is much much faster than for-loops in Python.\n",
    "\n",
    "[Numpy](https://numpy.org) also has its own [dot](https://numpy.org/doc/stable/reference/generated/numpy.dot.html) function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%timeit c = np.dot(u, v)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Wow, that's fast! It's actually faster than I can do it in fortran, as you will see soon. The reason is that it is using BLAS under the hood. We can actually use BLAS directly, but it should not be faster"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from scipy import linalg\n",
    "ddot = linalg.get_blas_funcs('dot', (u, v))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%timeit c = ddot(u, v)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Think Fortran can do better? Lets try using Fortran's [dot_fortran](https://gcc.gnu.org/onlinedocs/gcc-4.7.4/gfortran/DOT_005fPRODUCT.html) and also show how to call it from Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%file dot_fortran.f90\n",
    "      function dot_fortran(a,b,N) result(c)\n",
    "      integer :: N\n",
    "      real(8), dimension(N) :: a, b\n",
    "      real(8) :: c\n",
    "      c = dot_product(a, b)\n",
    "      end function dot_fortran"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!cat dot_fortran.f90"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can compile this Fortran function and make it directly callable from Python. This is how many Python functions are implemented for speed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%capture\n",
    "!python -m numpy.f2py -c dot_fortran.f90 -m dotf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import dotf\n",
    "%timeit c = dotf.dot_fortran(u, v)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ok, I can probably do better"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%file dot_fortran2.f90\n",
    "      function dot_fortran(a,b,N) result(c)\n",
    "      integer :: N\n",
    "      real(8), dimension(N) :: a,b\n",
    "      real(8) :: c\n",
    "Cf2py intent(in) N\n",
    "Cf2py intent(in) a\n",
    "Cf2py intent(in) b\n",
    "Cf2py intent(out) c\n",
    "      c = dot_product(a,b)\n",
    "      end function dot_fortran"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%capture\n",
    "!python -m numpy.f2py -c dot_fortran2.f90 -m dotf2 --f90flags='-Ofast'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import dotf2\n",
    "%timeit c = dotf2.dot_fortran(u, v)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Still not close to Numpy and BLAS. Lets try pure Fortran. Create a pure Fortran program, compile and run it from bash. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%file test_dot_fortran.f90\n",
    "program test_dot\n",
    "    real(8) :: t0,t1,c\n",
    "    real(8), allocatable :: a(:), b(:)\n",
    "    integer :: n\n",
    "    character(len=12) :: arg\n",
    "    call get_command_argument(1, arg)\n",
    "    read(arg,*) n\n",
    "    allocate (a(1:n))\n",
    "    allocate (b(1:n))\n",
    "    call random_number(a)\n",
    "    call random_number(b)\n",
    "    call cpu_time(t0)\n",
    "    c = dot_product(a, b)\n",
    "    call cpu_time(t1)\n",
    "    write(*,*) \"time \",(t1-t0)*1000,\" milliseconds \",c\n",
    "end program test_dot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!gfortran -Ofast -march=native test_dot_fortran.f90 -o test_dot_fortran\n",
    "!./test_dot_fortran 10000000"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Try one more time, with explicit do-loop:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%file dot_fortran3.f90\n",
    "      function dot_fortran(a,b,N) result(c)\n",
    "      integer :: N\n",
    "      real(8), dimension(n) :: a,b\n",
    "      real(8) :: c\n",
    "Cf2py intent(in) N\n",
    "Cf2py intent(in) a\n",
    "Cf2py intent(in) b\n",
    "Cf2py intent(out) c\n",
    "      c = 0.0\n",
    "      do i = 1,N\n",
    "        c = c + a(i)*b(i)\n",
    "      end do\n",
    "      end function dot_fortran"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%capture\n",
    "!python -m numpy.f2py -c dot_fortran3.f90 -m dotf3 --f90flags='-Ofast -march=native' -DF2PY_REPORT_ON_ARRAY_COPY=1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import dotf3\n",
    "%timeit c = dotf3.dot_fortran(u, v)"
   ]
  },
  {
   "attachments": {
    "cython.jpeg": {
     "image/jpeg": "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"
    },
    "numba.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ok. I'm not able to make Fortran faster. Perhaps I'm not the best Fortran programmer, or I simply do not have the best fortran compiler (gfortran on MAC OSX). \n",
    "\n",
    "<div class=\"alert alert-info\">\n",
    "The point is that it is trivially simple to wrap a Fortran function and call it from Python!\n",
    "</div>\n",
    "\n",
    "What else is there?\n",
    "\n",
    "![numba.png](attachment:numba.png)\n",
    "![cython.jpeg](attachment:cython.jpeg)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "fortran3",
   "language": "python",
   "name": "fortran3"
  },
  "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.9.7"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": false,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}