jvdp_ch2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This notebook is part of my [Python data science curriculum](http://www.terran.us/articles/python_curriculum.html)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Chapter 2 Exercises"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import scipy as sp"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This document uses the [\"collapsible headings\" extension from nbextensions](https://jupyter-contrib-nbextensions.readthedocs.io/en/latest/nbextensions/collapsible_headings/readme.html).  If you have that extension installed, you will see that the \"solution\" sections start collapsed, and you can expand them and look at them _after_ doing the exercise yourself.  I also recommend the \"toc2\" extension.\n",
    "\n",
    "I also tried the \"exercise2\" extension, but it had unacceptable bugs (the solution became irretrievable if I inserted a new cell right below the collapsed exercise)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise\n",
    "Make a 12-long array of consecutive integers from 1 to 12, inclusive:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "## Solution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12], dtype=int32)"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a1=np.array(np.arange(1,13),dtype='int32')\n",
    "a1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise\n",
    "Make a 12-long array of floating point numbers between 0 and 1:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "## Solution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.        , 0.09090909, 0.18181818, 0.27272727, 0.36363636,\n",
       "       0.45454545, 0.54545455, 0.63636364, 0.72727273, 0.81818182,\n",
       "       0.90909091, 1.        ])"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a2=np.array(np.arange(0,1+1/11,1/11))\n",
    "a2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise\n",
    "Add them together.  What is the type of the result?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "## Solution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('float64')"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(a1+a2).dtype"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise\n",
    "Take your 1d array of integers and transform it into a row vector, then transform it into a column vector."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "## Solution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12]], dtype=int32)"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Row:\n",
    "a1[np.newaxis,:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1],\n",
       "       [ 2],\n",
       "       [ 3],\n",
       "       [ 4],\n",
       "       [ 5],\n",
       "       [ 6],\n",
       "       [ 7],\n",
       "       [ 8],\n",
       "       [ 9],\n",
       "       [10],\n",
       "       [11],\n",
       "       [12]], dtype=int32)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Column:\n",
    "np.vstack(a1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1],\n",
       "       [ 2],\n",
       "       [ 3],\n",
       "       [ 4],\n",
       "       [ 5],\n",
       "       [ 6],\n",
       "       [ 7],\n",
       "       [ 8],\n",
       "       [ 9],\n",
       "       [10],\n",
       "       [11],\n",
       "       [12]], dtype=int32)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# One more approach, which will do either:\n",
    "a1.reshape(12, 1)\n",
    "# Or, if you don't want to hardcode the size:\n",
    "a1.reshape(a1.shape[0], 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise\n",
    "\n",
    "Using your array of integers, create a \"multiplication table\" (2d array where each cell is the product of its axis indices).  Do this in two different ways.  One way should use the row and column matrix versions, and the other should not"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "## Solution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[  1,   2,   3,   4,   5,   6,   7,   8,   9,  10,  11,  12],\n",
       "       [  2,   4,   6,   8,  10,  12,  14,  16,  18,  20,  22,  24],\n",
       "       [  3,   6,   9,  12,  15,  18,  21,  24,  27,  30,  33,  36],\n",
       "       [  4,   8,  12,  16,  20,  24,  28,  32,  36,  40,  44,  48],\n",
       "       [  5,  10,  15,  20,  25,  30,  35,  40,  45,  50,  55,  60],\n",
       "       [  6,  12,  18,  24,  30,  36,  42,  48,  54,  60,  66,  72],\n",
       "       [  7,  14,  21,  28,  35,  42,  49,  56,  63,  70,  77,  84],\n",
       "       [  8,  16,  24,  32,  40,  48,  56,  64,  72,  80,  88,  96],\n",
       "       [  9,  18,  27,  36,  45,  54,  63,  72,  81,  90,  99, 108],\n",
       "       [ 10,  20,  30,  40,  50,  60,  70,  80,  90, 100, 110, 120],\n",
       "       [ 11,  22,  33,  44,  55,  66,  77,  88,  99, 110, 121, 132],\n",
       "       [ 12,  24,  36,  48,  60,  72,  84,  96, 108, 120, 132, 144]],\n",
       "      dtype=int32)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.multiply.outer(a1,a1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[  1,   2,   3,   4,   5,   6,   7,   8,   9,  10,  11,  12],\n",
       "       [  2,   4,   6,   8,  10,  12,  14,  16,  18,  20,  22,  24],\n",
       "       [  3,   6,   9,  12,  15,  18,  21,  24,  27,  30,  33,  36],\n",
       "       [  4,   8,  12,  16,  20,  24,  28,  32,  36,  40,  44,  48],\n",
       "       [  5,  10,  15,  20,  25,  30,  35,  40,  45,  50,  55,  60],\n",
       "       [  6,  12,  18,  24,  30,  36,  42,  48,  54,  60,  66,  72],\n",
       "       [  7,  14,  21,  28,  35,  42,  49,  56,  63,  70,  77,  84],\n",
       "       [  8,  16,  24,  32,  40,  48,  56,  64,  72,  80,  88,  96],\n",
       "       [  9,  18,  27,  36,  45,  54,  63,  72,  81,  90,  99, 108],\n",
       "       [ 10,  20,  30,  40,  50,  60,  70,  80,  90, 100, 110, 120],\n",
       "       [ 11,  22,  33,  44,  55,  66,  77,  88,  99, 110, 121, 132],\n",
       "       [ 12,  24,  36,  48,  60,  72,  84,  96, 108, 120, 132, 144]],\n",
       "      dtype=int32)"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a1[:,np.newaxis] @ a1[np.newaxis,:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "row * column\n",
      "[[ 1  2  3  4]\n",
      " [ 2  4  6  8]\n",
      " [ 3  6  9 12]\n",
      " [ 4  8 12 16]]\n",
      "column * row\n",
      "[[ 1  2  3  4]\n",
      " [ 2  4  6  8]\n",
      " [ 3  6  9 12]\n",
      " [ 4  8 12 16]]\n",
      "row @ column\n",
      "[[30]]\n",
      "column @ row\n",
      "[[ 1  2  3  4]\n",
      " [ 2  4  6  8]\n",
      " [ 3  6  9 12]\n",
      " [ 4  8 12 16]]\n"
     ]
    }
   ],
   "source": [
    "# Note a subtlety here - in Python, @ does matrix multiplication, and * does \"broadcasting\",\n",
    "# which is always the outer product, regardless of whether the row or column comes first:\n",
    "\n",
    "rowv = a1[np.newaxis,0:4]\n",
    "colv = a1[0:4,np.newaxis]\n",
    "print(\"row * column\")\n",
    "print(rowv * colv)\n",
    "print(\"column * row\")\n",
    "print(colv * rowv)\n",
    "\n",
    "print(\"row @ column\")\n",
    "print(rowv @ colv)\n",
    "print(\"column @ row\")\n",
    "print(colv @ rowv)\n",
    "# In older versions you had to use numpy.dot or numpy.matmul instead of infix @.  They behave\n",
    "# differently in dimensions greater than two."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3],\n",
       "       [-1,  0,  1,  2],\n",
       "       [-2, -1,  0,  1],\n",
       "       [-3, -2, -1,  0]], dtype=int32)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Unlike matrix multiplication, in Python, you can also broadcast non-multiplicative operations:\n",
    "\n",
    "rowv - colv"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise\n",
    "Compute the factorial of 12 by reducing your array.  Now compute it with the Numpy factorial function.  Use ipython timing magic functions to see which is faster."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "## Solution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "479001600\n",
      "3.54 µs ± 124 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)\n"
     ]
    }
   ],
   "source": [
    "print(np.multiply.reduce(a1))\n",
    "%timeit np.multiply.reduce(a1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "479001600\n",
      "174 ns ± 6.8 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)\n"
     ]
    }
   ],
   "source": [
    "print(np.math.factorial(12))\n",
    "%timeit np.math.factorial(12)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise\n",
    "\n",
    "In Python, is a 1d vector taken as a row or column vector for broadcasting purposes?  What about for matrix multiplication?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "## Solution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 1, 1, 1],\n",
       "       [2, 2, 2, 2],\n",
       "       [3, 3, 3, 3],\n",
       "       [4, 4, 4, 4]])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# For broadcasting, they are effectively rows, because broadcasting pads on the left:\n",
    "colv * np.full(4,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "row by 1d:\n",
      "[10]\n",
      "\n",
      "1d by row:\n",
      "ValueError('shapes (4,) and (1,4) not aligned: 4 (dim 0) != 1 (dim 0)')\n"
     ]
    }
   ],
   "source": [
    "# For matrix multiplication, they're not exactly either:\n",
    "print(\"row by 1d:\")\n",
    "print(rowv @ np.full(4,1))\n",
    "\n",
    "print(\"\\n1d by row:\")\n",
    "try:\n",
    "  print(np.full(4,1) @ rowv)\n",
    "except Exception as e:\n",
    "  print(repr(e))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise\n",
    "Create an array of normal random numbers.  Sort the original array in order of decreasing absolute value."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "## Solution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-2.49073165,  2.39633395, -2.04363117, -1.66539244,  1.27749369,\n",
       "       -1.25198296, -0.83854892, -0.78263418, -0.62685332, -0.5671522 ,\n",
       "       -0.39794515, -0.29073459,  0.2352208 , -0.20088277,  0.16662046,\n",
       "        0.16407303, -0.11810839, -0.11593318,  0.10746925,  0.06451154])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n=np.random.normal(size=20)\n",
    "n[(-(n*n)).argsort()]"
   ]
  }
 ],
 "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.5"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "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
}