lectures/Python_Intro.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'theme': 'sky',\n",
       " 'transition': 'zoom',\n",
       " 'start_slideshow_at': 'selected',\n",
       " 'scroll': True}"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from traitlets.config.manager import BaseJSONConfigManager\n",
    "#path = \"/Users/alexgrinch/miniconda3/envs/opensim-rl/etc/jupyter/nbconfig/\"\n",
    "cm = BaseJSONConfigManager()\n",
    "cm.update(\"livereveal\", {\n",
    "              \"theme\": \"sky\",\n",
    "              \"transition\": \"zoom\",\n",
    "              \"start_slideshow_at\": \"selected\",\n",
    "              \"scroll\": True,\n",
    "})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "https://github.com/oseledets/nla2018/blob/master/table_of_contents.ipynb"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Table of Contents\n",
    "* [Tasks for those who \"feel like a pro\":](#Tasks-for-those-who-\"feel-like-a-pro\":)\n",
    "* [Learning Resources](#Learning-Resources)\n",
    "\t* [Online](#Online)\n",
    "\t* [Reading (in the future)](#Reading-%28in-the-future%29)\n",
    "* [Programming in python](#Programming-in-python)\n",
    "\t* [Writing code](#Writing-code)\n",
    "\t* [Some anti-patterns](#Some-anti-patterns)\n",
    "* [Python basics](#Python-basics)\n",
    "\t* [Basic types](#Basic-typesw)\n",
    "\t\t* [variables](#variables)\n",
    "\t\t* [strings](#strings)\n",
    "\t* [data containers](#data-containers)\n",
    "\t\t* [lists](#lists)\n",
    "\t\t* [tuples](#tuples)\n",
    "\t\t* [sets](#sets)\n",
    "\t\t* [dictionaries](#dictionaries)\n",
    "\t* [Functions](#Functions)\n",
    "\t\t* [general patterns](#general-patterns)\n",
    "\t\t* [functions as arguments](#functions-as-arguments)\n",
    "\t\t* [lambda evaluation](#lambda-evaluation)\n",
    "* [Numpy - scientific computing](#Numpy---scientific-computing)\n",
    "\t* [Building matrices and vectors](#Building-matrices-and-vectors)\n",
    "\t* [Basic manipulations](#Basic-manipulations)\n",
    "\t\t* [matvec](#matvec)\n",
    "\t\t* [broadcasting](#broadcasting)\n",
    "\t\t* [forcing dtype](#forcing-dtype)\n",
    "\t\t* [converting dtypes](#converting-dtypes)\n",
    "\t\t* [shapes (singletons)](#shapes-%28singletons%29)\n",
    "\t\t* [adding new dimension](#adding-new-dimension)\n",
    "\t* [Indexing, slicing](#Indexing,-slicing)\n",
    "\t* [View vs Copy](#View-vs-Copy)\n",
    "\t* [Reshaping](#Reshaping)\n",
    "\t* [Boolean indexing](#Boolean-indexing)\n",
    "\t* [Useful numpy functions](#Useful-numpy-functions)\n",
    "\t\t* [reducers: sum, mean, max, min, all, any](#reducers:-sum,-mean,-max,-min,-all,-any)\n",
    "\t\t* [numpy math functions](#numpy-math-functions)\n",
    "\t\t* [managing output](#managing-output)\n",
    "\t\t* [Meshes](#Meshes)\n",
    "* [Scipy - scientific computing 2](#Scipy---scientific-computing-2)\n",
    "\t* [Building sparse matrix](#Building-sparse-matrix)\n",
    "\t\t* [How does scipy represent sparse matrix?](#How-does-scipy-represent-sparse-matrix?)\n",
    "\t\t* [Restoring full matrix](#Restoring-full-matrix)\n",
    "\t* [Popular  (not sparse) matrices:](#Popular--%28not-sparse%29-matrices:)\n",
    "* [Timing - measuring performance](#Timing---measuring-performance)\n",
    "\t* [Simplest way to measure time](#Simplest-way-to-measure-time)\n",
    "\t* [Storing timings in a separate variable](#Storing-timings-in-a-separate-variable)\n",
    "\t* [`timeit` with -o parameter](#timeit-with--o-parameter)\n",
    "* [Matplotlib - plotting in python](#Matplotlib---plotting-in-python)\n",
    "\t* [Configuring matplotlib](#Configuring-matplotlib)\n",
    "\t* [Global controls](#Global-controls)\n",
    "\t* [Combined plot](#Combined-plot)\n",
    "\t\t* [Combined plot \"one-liner\"](#Combined-plot-\"one-liner\")\n",
    "\t* [Plot formatting](#Plot-formatting)\n",
    "\t* [Subplots](#Subplots)\n",
    "\t\t* [Iterating over subplots](#Iterating-over-subplots)\n",
    "\t\t* [Manual control of subplots](#Manual-control-of-subplots)\n",
    "* [Other topics](#Other-topics)\n",
    "* [Solutions](#Solutions)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Tasks for those who \"feel like a pro\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "**TASK 1**\n",
    "\n",
    "Write the code to enumerate items in the list:\n",
    "* items are not ordered\n",
    "* items are not unique\n",
    "* **don't use loops**\n",
    "* **try to be as short as possible** (not considering import statements)\n",
    "\n",
    "Example:\n",
    "\n",
    "*Input*\n",
    "```\n",
    "items = ['foo', 'bar', 'baz', 'foo', 'baz', 'bar']\n",
    "\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "*Output*\n",
    "```\n",
    "#something like:\n",
    "[0, 1, 2, 0, 2, 1]\n",
    "\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "**TASK 2**\n",
    "\n",
    "For each element in a list ```[0, 1, 2, ..., N]``` build all possible pairs with other elements of that list.\n",
    "\n",
    "* exclude \"self-pairing\" (e.g. 0-0, 1-1, 2-2)\n",
    "* **don't use loops**\n",
    "* **try to be as short as possible**   (not considering import statements)\n",
    "\n",
    "Example:\n",
    "\n",
    "*Input:*\n",
    "```\n",
    "[0, 1, 2, 3] or just 4\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "*Output:*\n",
    "```\n",
    "0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 3\n",
    "\n",
    "1, 2, 3, 0, 2, 3, 0, 1, 3, 0, 1, 2\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Learning Resources"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Highly recommended\n",
    "\n",
    "* \"A Whirlwind Tour of Python\" http://www.oreilly.com/programming/free/files/a-whirlwind-tour-of-python.pdf\n",
    "* \"Python Data Science Handbook\" https://jakevdp.github.io/PythonDataScienceHandbook/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Online\n",
    "\n",
    "* The Hitchhiker’s Guide to Python\n",
    "http://docs.python-guide.org/en/latest/\n",
    "\n",
    "* Hard way is easier http://learnpythonthehardway.org\n",
    "\n",
    "* Google python class\n",
    "https://developers.google.com/edu/python/\n",
    "\n",
    "* Python tutorial\n",
    "https://docs.python.org/2/tutorial/\n",
    "\n",
    "* Python Tutor - code visualizing (developed by MIT)\n",
    "http://pythontutor.com/\n",
    "\n",
    "* If you feel lost: CodeAcademy https://www.codecademy.com/en/tracks/python\n",
    "\n",
    "**Learning by doing!**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Reading (in the future)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* Al Sweigart, \"Automate the Boring Stuff with Python\", https://automatetheboringstuff.com\n",
    "* Mark Lutz, \"Python Pocket Reference\" (250 pages)\n",
    "* Mark Lutz, \"Learning Python\" (1600 pages!)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<center>\n",
    "<img src=\"google-search.jpg\">\n",
    "</center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Google Foobar"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "<center>\n",
    "<img src=\"google_foobar.png\">\n",
    "</center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Programming in python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Writing code"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* code should be readable first!\n",
    "\n",
    "* style guides\n",
    "    * PEP8 (PEP = Python Enhancement Proposal) http://legacy.python.org/dev/peps/pep-0008/\n",
    "    * writing idiomatic code http://python.net/~goodger/projects/pycon/2007/idiomatic/handout.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Some anti-patterns"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "looping through dictionaries\n",
    "http://docs.quantifiedcode.com/python-anti-patterns/performance/index.html\n",
    "\n",
    "using wildcard imports (from ... import *)\n",
    "http://docs.quantifiedcode.com/python-anti-patterns/maintainability/from_module_import_all_used.html\n",
    "\n",
    "\n",
    "Using single letter to name your variables\n",
    "http://docs.quantifiedcode.com/python-anti-patterns/maintainability/using_single_letter_as_variable_name.html\n",
    "\n",
    "\n",
    "Comparing things to None the wrong way\n",
    "http://docs.quantifiedcode.com/python-anti-patterns/readability/comparison_to_none.html\n",
    "\n",
    "\n",
    "Comparing things to True the wrong way\n",
    "http://docs.quantifiedcode.com/python-anti-patterns/readability/comparison_to_true.html\n",
    "\n",
    "\n",
    "Using type() to compare types\n",
    "http://docs.quantifiedcode.com/python-anti-patterns/readability/do_not_compare_types_use_isinstance.html\n",
    "\n",
    "\n",
    "Using an unpythonic loop\n",
    "http://docs.quantifiedcode.com/python-anti-patterns/readability/using_an_unpythonic_loop.html\n",
    "\n",
    "\n",
    "Using CamelCase in function names\n",
    "http://docs.quantifiedcode.com/python-anti-patterns/readability/using_camelcase_in_function_names.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Python basics"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Verify your python version by running\n",
    "```python\n",
    "python --version\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "This notebook is written in Python 3."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Basic types"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### variables"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "```python\n",
    "a = b = 3\n",
    "\n",
    "c, d = 4, 5\n",
    "\n",
    "c, d = d, c\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### strings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "greeting = 'Hello'\n",
    "guest = \"John\"\n",
    "my_string = 'Hello \"John\"'\n",
    "named_greeting = 'Hello, {name}'.format(name=guest)\n",
    "\n",
    "named_greeting2 = '{}, {}'.format(greeting, guest)\n",
    "\n",
    "print(named_greeting)\n",
    "print(named_greeting2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## data containers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* list\n",
    "* tuple\n",
    "* set\n",
    "* dictionary"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "for more details see docs:  https://docs.python.org/2/tutorial/datastructures.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "fruit_list = ['apple', 'orange', 'peach', 'mango', 'bananas', 'pineapple']\n",
    "\n",
    "name_length = [len(fruit) for fruit in fruit_list]\n",
    "print(name_length)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "name_with_p = [fruit for fruit in fruit_list if fruit[0]=='p']  #even better: fruit.startswith('p')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "numbered_fruits = []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "for i, fruit in enumerate(fruit_list):\n",
    "    numbered_fruits.append('{}.{}'.format(i, fruit))\n",
    "    \n",
    "numbered_fruits"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Indexing starts with zero.\n",
    "\n",
    "General indexing rule (mind the brackets): ```[start:stop:step]```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "numbered_fruits[0] = None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "numbered_fruits[1:4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "numbered_fruits[1:-1:2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "numbered_fruits[::-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### tuples"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "immutable type!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "p_fruits = (name_with_p[1], name_with_p[0])\n",
    "p_fruits[1] = 'mango'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "single_number_tuple = 3,\n",
    "single_number_tuple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "single_number_tuple + (2,) + (1, 0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### sets"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Immutable type. Stores only unique elements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "my_set = set([0, 1, 2, 1, 1, 1, 3])\n",
    "my_set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "my_set.remove(2)\n",
    "my_set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "my_set.add(\"word\")\n",
    "my_set"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### dictionaries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "fruit_list = ['apple', 'orange', 'mango', 'banana', 'pineapple']\n",
    "quantities = [3, 5, 2, 3, 4]\n",
    "\n",
    "order_fruits = {fruit: num \\\n",
    "                for fruit, num in zip(fruit_list, quantities)}\n",
    "order_fruits"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "order_fruits['pineapple'] = 2\n",
    "order_fruits"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "print(order_fruits.keys())\n",
    "print(order_fruits.values())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "for fruit, amount in order_fruits.items():\n",
    "    print('Buy {num} {entity}s'.format(num=amount, entity=fruit))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### general patterns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def my_func(var1, var2, default_var1=0, default_var2 = False):\n",
    "    \"\"\"\n",
    "    This is a generic example of python a function.\n",
    "    You can see this string when do call: my_func?\n",
    "    \"\"\"\n",
    "    #do something with vars\n",
    "    if not default_var2:\n",
    "        result = var1\n",
    "    elif default_var1 == 0:\n",
    "        result = var1\n",
    "    else:\n",
    "        result = var1 + var2\n",
    "    return result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "function is just another object (like almost everything in python)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "print('Function {} has the following docstring:\\n{}'\\\n",
    "        .format(my_func.__name__, my_func.__doc__))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Guidence on how to create meaningful docstring:\n",
    "https://github.com/numpy/numpy/blob/master/doc/HOWTO_DOCUMENT.rst.txt#docstring-standard"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### functions as arguments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def function_over_function(func, *args, **kwargs):\n",
    "    function_result = func(*args, **kwargs)\n",
    "    return function_result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "function_over_function(my_func, 3, 5, default_var1=1, default_var2=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### lambda evaluation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "function_over_function(lambda x, y, factor=10: (x+y)*factor, 1, 2, 5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Don't assign lambda expressions to variables. If you need named instance - create standard function with `def`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "my_simple_func = lambda x: x+1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "vs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def my_simple_func(x):\n",
    "    return x + 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Numpy - scientific computing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Building matrices and vectors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "format": "column",
    "scrolled": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "matrix_from_list = np.array([[1, 3, 4],\n",
    "                             [2, 0, 5],\n",
    "                             [4, 4, 1],\n",
    "                             [0, 1, 0]])\n",
    "\n",
    "vector_from_list = np.array([2, 1, 3])\n",
    "\n",
    "print('The matrix is\\n{matrix}\\n\\nthe vector is\\n{vector}'\\\n",
    "        .format(vector=vector_from_list, matrix=matrix_from_list))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Basic manipulations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### matvec"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "matrix_from_list.dot(vector_from_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "matrix_from_list @ vector_from_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### broadcasting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "matrix_from_list + vector_from_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "i = np.arange(4)\n",
    "j = np.arange(4)\n",
    "mat = i[:, None] - j[None, :]\n",
    "mat"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### forcing dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "single_precision_vector = np.array([1, 3, 5, 2], dtype=np.float32)\n",
    "single_precision_vector.dtype"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### converting dtypes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "vector_from_list.dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "vector_from_list.astype(np.int16)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### shapes (singletons)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "mind dimensionality!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "format": "column",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "row_vector = np.array([[1,2,3]])\n",
    "\n",
    "print('New vector {} has dimensionality {}'\\\n",
    "        .format(row_vector, row_vector.shape))\n",
    "\n",
    "print('The dot-product is: ', matrix_from_list.dot(row_vector))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "singleton_vector = row_vector.squeeze()\n",
    "print('Squeezed vector {} has shape {}'.format(singleton_vector, singleton_vector.shape))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "matrix_from_list.dot(singleton_vector)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### adding new dimension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "print(singleton_vector[:, np.newaxis])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "print(singleton_vector[:, None])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Indexing, slicing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "vector12 = np.arange(12)\n",
    "vector12"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Guess what is the output:\n",
    "```python\n",
    "vector12[:3]\n",
    "vector12[-1]\n",
    "vector12[:-2]\n",
    "vector12[3:7]\n",
    "vector12[::2]\n",
    "vector12[::-1]\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "matrix43 = vector12.reshape(4, 3)\n",
    "matrix43"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Guess what is the output:\n",
    "```python\n",
    "matrix43[:, 0]\n",
    "matrix43[-1, :]\n",
    "matrix43[::2, :]\n",
    "matrix43[:3, :-1]\n",
    "matrix43[3:, 1]\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "Unlike Matlab, numpy arrays are column-major (or C-major) by default, not row-major (or F-major)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## View vs Copy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Working with views is more efficient and is a preferred way."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "view is returned whenever basic slicing is used\n",
    "\n",
    "more details at http://docs.scipy.org/doc/numpy/reference/arrays.indexing.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "making copy is simple:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "matrix43_copy = matrix43[:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Reshaping"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "format": "row",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "matrix_to_reshape = np.random.randint(10, 99, size=(6, 4))\n",
    "matrix_to_reshape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "format": "row",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "reshaped_matrix = matrix_to_reshape.reshape(8, 3)\n",
    "reshaped_matrix"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "reshape always returns view!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Boolean indexing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "idx = matrix43 > 4\n",
    "matrix43[idx]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Useful numpy functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "eye, ones, zeros, diag"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "**Example:**\n",
    "Build three-diagonal matrix with -2's on main diagonal and 1's and subdiagonals\n",
    "\n",
    "Is this code valid?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def three_diagonal(N):\n",
    "    A = np.zeros((N, N), dtype=np.int)\n",
    "    for i in range(N):\n",
    "        A[i, i] = -2\n",
    "        if i > 0:\n",
    "            A[i, i-1] = 1\n",
    "        if i < N-1:\n",
    "            A[i, i+1] = 1\n",
    "    return A\n",
    "\n",
    "print(three_diagonal(5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Let's rewrite it in numpy!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def numpy_three_diagonal(N):\n",
    "    main_diagonal = -2 * np.eye(N)\n",
    "    \n",
    "    suddiag_value = np.ones(N-1,)\n",
    "    lower_subdiag = np.diag(suddiag_value, k=-1)\n",
    "    upper_subdiag = np.diag(suddiag_value, k=1)\n",
    "    \n",
    "    result = main_diagonal + lower_subdiag + upper_subdiag\n",
    "    return result.astype(np.int)\n",
    "\n",
    "numpy_three_diagonal(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### reducers: sum, mean, max, min, all, any"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "A = numpy_three_diagonal(5)\n",
    "A[0, -1] = 5\n",
    "A[-1, 0] = 3\n",
    "\n",
    "print(A)\n",
    "print(A.sum())\n",
    "print(A.min())\n",
    "print(A.max(axis=0))\n",
    "print(A.sum(axis=0))\n",
    "print(A.mean(axis=1))\n",
    "print((A > 4).any(axis=1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### numpy math functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "print(np.pi)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "args = np.arange(0, 2.5*np.pi, 0.5*np.pi)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "print(np.sin(args))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "print(np.round(np.sin(args), decimals=2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Meshes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "linspace, meshgrid"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Let's produce a function\n",
    "$$\n",
    "f(x, y) = \\sin(x+y)\n",
    "$$\n",
    "on some mesh."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "linear_index = np.linspace(0, np.pi, 10, endpoint=True)\n",
    "mesh_x, mesh_y = np.meshgrid(linear_index, linear_index)\n",
    "\n",
    "values_3D = np.sin(mesh_x + mesh_y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "format": "row",
    "scrolled": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "from mpl_toolkits.mplot3d import Axes3D\n",
    "%matplotlib inline\n",
    "\n",
    "fig = plt.figure(figsize=(10,6))\n",
    "ax = fig.gca(projection='3d')\n",
    "\n",
    "ax.plot_wireframe(mesh_x, mesh_y, values_3D)\n",
    "ax.view_init(azim=-45, elev=30)\n",
    "\n",
    "plt.title('The plot of $f(x, y) = sin(x+y)$')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Scipy - scientific computing 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Building sparse matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "import scipy.sparse as sp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def scipy_three_diagonal(N):\n",
    "    main_diagonal = -2 * np.ones(N, )\n",
    "    suddiag_values = np.ones(N-1,)\n",
    "    \n",
    "    diagonals = [main_diagonal, suddiag_values, suddiag_values]\n",
    "    # Another option: use sp.eye(N) and add subdiagonals\n",
    "    offsets = [0, 1, -1]\n",
    "    \n",
    "    result = sp.diags(diagonals, offsets, shape=(N, N), format='coo')\n",
    "    return result\n",
    "\n",
    "my_sparse_matrix = scipy_three_diagonal(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### How does scipy represent sparse matrix?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "my_sparse_matrix"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Sparse matrix stores only non-zero elements (and their indices)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "print(my_sparse_matrix)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Restoring full matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "my_sparse_matrix.toarray()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "my_sparse_matrix.A"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Popular  (not sparse) matrices:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "from scipy.linalg import toeplitz, hankel"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "hankel(range(4), [-1, -2, -3, -4])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "toeplitz(range(4))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Timing - measuring performance"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Simplest way to measure time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "N = 100\n",
    "%timeit three_diagonal(N)\n",
    "%timeit numpy_three_diagonal(N)\n",
    "%timeit scipy_three_diagonal(N)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "You can also use `%%timeit` magic to measure run time of the whole cell"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "%%timeit\n",
    "N = 100\n",
    "calc = three_diagonal(N)\n",
    "calc = scipy_three_diagonal(N)\n",
    "del calc"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Storing timings in a separate variable"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Avoid using `time.time()` or `time.clock()` directly as their behaviour's different depending on platform; `default_timer` makes the best choice for you. It measures wall time though, e.g. not very precise."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "from timeit import default_timer as timer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "dims = [300, 1000, 2000, 3000]\n",
    "bench_names = ['loop', 'numpy', 'scipy']\n",
    "timings = {bench:[] for bench in bench_names}\n",
    "\n",
    "for n in dims:\n",
    "    start_time = timer()\n",
    "    calc = three_diagonal(n)\n",
    "    time_delta = timer() - start_time\n",
    "    timings['loop'].append(time_delta)\n",
    "    \n",
    "    start_time = timer()\n",
    "    calc = numpy_three_diagonal(n)\n",
    "    time_delta = timer() - start_time\n",
    "    timings['numpy'].append(time_delta)\n",
    "    \n",
    "    start_time = timer()\n",
    "    calc = scipy_three_diagonal(n)\n",
    "    time_delta = timer() - start_time\n",
    "    timings['scipy'].append(time_delta)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Let's make the code less redundant"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "dims = [300, 1000, 2000, 3000]\n",
    "bench_names = ['loop', 'numpy', 'scipy']\n",
    "timings = {bench_name: [] for bench_name in bench_names}\n",
    "\n",
    "def timing_machine(func, *args, **kwargs):\n",
    "    start_time = timer()\n",
    "    result = func(*args, **kwargs)\n",
    "    time_delta = timer() - start_time\n",
    "    return time_delta\n",
    "\n",
    "for n in dims:\n",
    "    timings['loop'].append(timing_machine(three_diagonal, n))\n",
    "    timings['numpy'].append(timing_machine(numpy_three_diagonal, n))\n",
    "    timings['scipy'].append(timing_machine(scipy_three_diagonal, n))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Matplotlib - plotting in python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "don't forget to check\n",
    "* http://matplotlib.org/users/pyplot_tutorial.html\n",
    "* http://matplotlib.org/gallery.html\n",
    "* http://matplotlib.org/examples/index.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Configuring matplotlib"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "run_control": {
     "marked": false
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "`%matplotlib inline` ensures all graphs are plotted inside your notebook"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Global controls"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "(more at http://matplotlib.org/users/customizing.html)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# plt.rcParams.update({'axes.labelsize': 'large'})\n",
    "plt.rcParams.update({'font.size': 14})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Combined plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "plt.figure(figsize=(10,6))\n",
    "\n",
    "for bench_name, values in timings.items():\n",
    "    plt.semilogy(dims, values, label=bench_name)\n",
    "    \n",
    "plt.legend(loc='best')\n",
    "plt.title('Benchmarking results', y=1.03)\n",
    "plt.xlabel('Matrix dimension size')\n",
    "plt.ylabel('Time, s')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "**Think, why:**\n",
    "* \"loop\" was faster then \"numpy\"\n",
    "* \"scipy\" is almost constant\n",
    "* results for *default_timer* and *\"best of timeit\"* are different\n",
    "\n",
    "You might want to read the docs:\n",
    "* https://docs.python.org/2/library/timeit.html#timeit.default_timer\n",
    "* https://docs.python.org/2/library/time.html#time.clock and https://docs.python.org/2/library/time.html#time.time\n",
    "\n",
    "**Remark:** starting from *python 3.3* it's recommended to use ```time.perf_counter()``` and ```time.process_time()```\n",
    "https://docs.python.org/3/library/time.html#time.perf_counter\n",
    "\n",
    "Also note, that for advanced benchmarking it's better to use profiling tools."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Combined plot \"one-liner\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "k = len(timings)\n",
    "iter_xyf = [item for sublist in zip([dims]*k,\n",
    "                                    timings.values(),\n",
    "                                    list('rgb'))\\\n",
    "                                for item in sublist]\n",
    "\n",
    "plt.figure(figsize=(10, 6))\n",
    "plt.semilogy(*iter_xyf)\n",
    "\n",
    "plt.legend(timings.keys(), loc=2, frameon=False)\n",
    "plt.title('Benchmarking results - \"one-liner\"', y=1.03)\n",
    "plt.xlabel('Matrix dimension size')\n",
    "plt.ylabel('Time, s')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Even simpler way - also gives you granular control on plot objects"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "plt.figure(figsize=(10, 4))\n",
    "\n",
    "figs = [plt.semilogy(dims, values, label=bench_name)\\\n",
    "        for bench_name, values in timings.items()];\n",
    "\n",
    "ax0, = figs[0]\n",
    "ax0.set_dashes([5, 10, 20, 10, 5, 10])\n",
    "\n",
    "ax1, = figs[1]\n",
    "ax1.set_marker('s')\n",
    "ax1.set_markerfacecolor('r')\n",
    "\n",
    "ax2, = figs[2]\n",
    "ax2.set_linewidth(6)\n",
    "ax2.set_alpha(0.3)\n",
    "ax2.set_color('m')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Plot formatting"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "matplotlib has a number of different options for styling your plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "all_markers = [\n",
    "'.', # point\n",
    "',', # pixel\n",
    "'o', # circle\n",
    "'v', # triangle down\n",
    "'^', # triangle up\n",
    "'<', # triangle_left\n",
    "'>', # triangle_right\n",
    "'1', # tri_down\n",
    "'2', # tri_up\n",
    "'3', # tri_left\n",
    "'4', # tri_right\n",
    "'8', # octagon\n",
    "'s', # square\n",
    "'p', # pentagon\n",
    "'*', # star\n",
    "'h', # hexagon1\n",
    "'H', # hexagon2\n",
    "'+', # plus\n",
    "'x', # x\n",
    "'D', # diamond\n",
    "'d', # thin_diamond\n",
    "'|', # vline\n",
    "]\n",
    "\n",
    "all_linestyles = [\n",
    "'-',  # solid line style\n",
    "'--', # dashed line style\n",
    "'-.', # dash-dot line style\n",
    "':',  # dotted line style\n",
    "'None'# no line\n",
    "]\n",
    "\n",
    "all_colors = [\n",
    "'b', # blue\n",
    "'g', # green\n",
    "'r', # red\n",
    "'c', # cyan\n",
    "'m', # magenta\n",
    "'y', # yellow\n",
    "'k', # black\n",
    "'w', # white\n",
    "]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Subplots"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "for advanced usage of subplots start here\n",
    "* http://matplotlib.org/examples/pylab_examples/subplots_demo.html\n",
    "* http://matplotlib.org/users/tight_layout_guide.html\n",
    "* http://matplotlib.org/users/gridspec.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Iterating over subplots"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "format": "tab",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "n = len(timings)\n",
    "experiment_names = list(timings.keys())\n",
    "\n",
    "fig, axes = plt.subplots(1, n, sharey=True, figsize=(16,4))\n",
    "\n",
    "colors = np.random.choice(list('rgbcmyk'), n, replace=False)\n",
    "markers = np.random.choice(all_markers, n, replace=False)\n",
    "lines = np.random.choice(all_linestyles, n, replace=False)\n",
    "\n",
    "for ax_num, ax in enumerate(axes):\n",
    "    key = experiment_names[ax_num]\n",
    "    ax.semilogy(dims, timings[key], label=key,\n",
    "            color=colors[ax_num],\n",
    "            marker=markers[ax_num],\n",
    "            markersize=8,\n",
    "            linestyle=lines[ax_num],\n",
    "            lw=3)\n",
    "    ax.set_xlabel('matrix dimension')\n",
    "    ax.set_title(key)\n",
    "\n",
    "axes[0].set_ylabel('Time, s')\n",
    "plt.suptitle('Benchmarking results', fontsize=16,  y=1.03)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "# Solutions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "**Task 1**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "outputs": [],
   "source": [
    "items = ['foo', 'bar', 'baz', 'foo', 'baz', 'bar']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "outputs": [],
   "source": [
    "from collections import defaultdict\n",
    "\n",
    "item_ids = defaultdict(lambda: len(item_ids))\n",
    "list(map(item_ids.__getitem__, items))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "\n",
    "pd.DataFrame({'items': items}).groupby('items', sort=False).grouper.group_info[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "np.unique(items, return_inverse=True)[1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "**Task 2**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "outputs": [],
   "source": [
    "N = 1000"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "outputs": [],
   "source": [
    "from itertools import permutations\n",
    "\n",
    "%timeit list(permutations(range(N), 2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "Hankel matrix: $a_{ij} = a_{i-1, j+1}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from scipy.linalg import hankel\n",
    "\n",
    "def pairs_idx(n):\n",
    "    return np.vstack((np.repeat(range(n), n-1), hankel(range(1, n), range(-1, n-1)).ravel()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "run_control": {
     "marked": false
    },
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "outputs": [],
   "source": [
    "%timeit pairs_idx(N)"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "celltoolbar": "Slideshow",
  "kernelspec": {
   "display_name": "opensim",
   "language": "python",
   "name": "opensim"
  },
  "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.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}