cookbook_numpy.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy  as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### numpy cookbook\n",
    "\n",
    "All you quickly need to know about numpy\n",
    "\n",
    "Dr *Gonzalo Martínez Lema*\n",
    "\n",
    "January 2020"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.random.seed(2**31)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Building arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "https://docs.scipy.org/doc/numpy-1.10.0/reference/routines.array-creation.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Constant values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0.])"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.zeros(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.ones(10, dtype=int) # Force the array to be integers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1.2, 1.2, 1.2, 1.2, 1.2, 1.2, 1.2, 1.2, 1.2, 1.2])"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a_value = 1.2\n",
    "np.full(10, a_value)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### From other sequences"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3.        , 4.        , 5.        , 6.333     , 3.14159265])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c = [3, 4, 5, 6.333, np.pi]\n",
    "np.array(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0., 0., 0., 0., 0.])"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.zeros_like(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1., 1., 1., 1., 1.])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.ones_like(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([4.5, 4.5, 4.5, 4.5, 4.5])"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.full_like(c, 4.5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Converting to and copying arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3.        , 4.        , 5.        , 6.333     , 3.14159265])"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d = np.asarray(c)\n",
    "d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d is c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.asarray(d) is d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<generator object <genexpr> at 0x7f77f0b9add0>\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([0., 1., 4., 9.])"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gen = (i**2 for i in range(4))\n",
    "print(gen)\n",
    "np.fromiter(gen, dtype=float)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sequences of numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 4,  7, 10, 13, 16])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "start, stop, step = 4, 19, 3\n",
    "np.arange(start, stop, step) # same as python's range, but returns a np.array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 4.  ,  7.75, 11.5 , 15.25, 19.  ])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "start, stop, ndiv = 4, 19, 5\n",
    "np.linspace(start, stop, ndiv) # by default endpoint is included, use endpoint=False for a np.arange-like behaviour"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1.e-07, 1.e-06, 1.e-05, 1.e-04, 1.e-03, 1.e-02, 1.e-01, 1.e+00])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.logspace(-7, 0, 8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[5 6 7 8 9]\n",
      "[2 3 4]\n",
      "[[5 6 7 8 9]\n",
      " [5 6 7 8 9]\n",
      " [5 6 7 8 9]]\n",
      "[[2 2 2 2 2]\n",
      " [3 3 3 3 3]\n",
      " [4 4 4 4 4]]\n"
     ]
    }
   ],
   "source": [
    "x = np.arange(5, 10)\n",
    "y = np.arange(2,  5)\n",
    "print(x)\n",
    "print(y)\n",
    "xx, yy = np.meshgrid(x, y) # x is the inner loop\n",
    "print(xx)\n",
    "print(yy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[5 6 7 8 9]\n",
      "[2 3 4]\n",
      "[[5 5 5]\n",
      " [6 6 6]\n",
      " [7 7 7]\n",
      " [8 8 8]\n",
      " [9 9 9]]\n",
      "[[2 3 4]\n",
      " [2 3 4]\n",
      " [2 3 4]\n",
      " [2 3 4]\n",
      " [2 3 4]]\n"
     ]
    }
   ],
   "source": [
    "x = np.arange(5, 10)\n",
    "y = np.arange(2,  5)\n",
    "print(x)\n",
    "print(y)\n",
    "xx, yy = np.meshgrid(x, y, indexing=\"ij\") # x is the outer loop\n",
    "print(xx)\n",
    "print(yy)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Empty arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "May be useful for assigning values within a loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1.2 1.2 1.2 1.2 1.2 1.2 1.2 1.2 1.2 1.2]\n",
      "[ 0.  1.  4.  9. 16. 25. 36. 49. 64. 81.]\n"
     ]
    }
   ],
   "source": [
    "e = np.empty(10)\n",
    "print(e) # takes whatever is on memory or something like that\n",
    "for i in range(10):\n",
    "    e[i] = i**2\n",
    "print(e)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 4.    7.75 11.5  15.25 19.  ]\n",
      "[  1.   4.  16.  64. 256.]\n"
     ]
    }
   ],
   "source": [
    "f = np.empty_like(c)\n",
    "print(f)\n",
    "for i in range(len(c)):\n",
    "    f[i] = 4**i\n",
    "print(f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Matrices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 2],\n",
       "       [6, 5]])"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.array([[0, 2],\n",
    "          [6, 5]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 0., 0., 0.],\n",
       "       [0., 1., 0., 0.],\n",
       "       [0., 0., 1., 0.],\n",
       "       [0., 0., 0., 1.]])"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.identity(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 0., 0., 0.],\n",
       "       [0., 1., 0., 0.],\n",
       "       [0., 0., 1., 0.],\n",
       "       [0., 0., 0., 1.]])"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.eye(4, 4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 0., 0., 0.],\n",
       "       [0., 1., 0., 0.]])"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.eye(2, 4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 0., 0., 0.],\n",
       "       [1., 0., 0., 0.],\n",
       "       [0., 1., 0., 0.],\n",
       "       [0., 0., 1., 0.]])"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.eye(4, 4, k=-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 0, 0, 0, 0],\n",
       "       [0, 1, 0, 0, 0],\n",
       "       [0, 0, 2, 0, 0],\n",
       "       [0, 0, 0, 3, 0],\n",
       "       [0, 0, 0, 0, 4]])"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.diag(np.arange(5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Manipulating arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "https://docs.scipy.org/doc/numpy-1.10.0/reference/routines.array-manipulation.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Shaping"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 1 2 3 4 5 6 7 8]\n",
      "[[0 1 2]\n",
      " [3 4 5]\n",
      " [6 7 8]]\n"
     ]
    }
   ],
   "source": [
    "g = np.arange(9)\n",
    "print(g)\n",
    "h = g.reshape(3, 3)\n",
    "print(h)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4, 5, 6, 7, 8])"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "h.flatten() # copy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4, 5, 6, 7, 8])"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.ravel(h) # not copied!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Transposing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 3, 6],\n",
       "       [1, 4, 7],\n",
       "       [2, 5, 8]])"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "h.T # it's a view of the same oject, not a copy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 3, 6],\n",
       "       [1, 4, 7],\n",
       "       [2, 5, 8]])"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "h.transpose() # same as h.T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(3, 5, 6, 2)\n",
      "(3, 2, 6, 5)\n"
     ]
    }
   ],
   "source": [
    "i = np.ones((3, 5, 6, 2))\n",
    "print(i.shape)\n",
    "j = np.swapaxes(i, 3, 1)\n",
    "print(j.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(3, 5, 6, 2)\n",
      "(6, 3, 5, 2)\n"
     ]
    }
   ],
   "source": [
    "k = np.rollaxis(i, 2, 0)\n",
    "print(i.shape)\n",
    "print(k.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Combining arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[  1.   4.  16.  64. 256.]\n",
      "[0 1 2 3 4 5 6 7 8]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([  1.,   4.,  16.,  64., 256.,   0.,   1.,   2.,   3.,   4.,   5.,\n",
       "         6.,   7.,   8.])"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(f)\n",
    "print(g)\n",
    "np.concatenate([f, g])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1. 0. 0.]\n",
      " [0. 1. 0.]\n",
      " [0. 0. 1.]\n",
      " [0. 0. 0.]]\n",
      "[[0 1 2]\n",
      " [3 4 5]\n",
      " [6 7 8]]\n",
      "[[1. 0. 0.]\n",
      " [0. 1. 0.]\n",
      " [0. 0. 1.]\n",
      " [0. 0. 0.]\n",
      " [0. 1. 2.]\n",
      " [3. 4. 5.]\n",
      " [6. 7. 8.]]\n",
      "[[1. 0. 0. 0. 0. 1. 2.]\n",
      " [0. 1. 0. 0. 3. 4. 5.]\n",
      " [0. 0. 1. 0. 6. 7. 8.]]\n"
     ]
    }
   ],
   "source": [
    "l = np.eye(4, 3)\n",
    "print(l)\n",
    "print(h)\n",
    "print(np.concatenate([l, h]))\n",
    "print(np.concatenate([l.T, h], axis=1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3.         4.         5.         6.333      3.14159265]\n",
      "[  1.   4.  16.  64. 256.]\n",
      "[[  3.           4.           5.           6.333        3.14159265]\n",
      " [  1.           4.          16.          64.         256.        ]]\n"
     ]
    }
   ],
   "source": [
    "print(d)\n",
    "print(f)\n",
    "print(np.stack([d, f], axis=0)) # axis=0 is the default. concatenate along axis 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3.         4.         5.         6.333      3.14159265]\n",
      "[  1.   4.  16.  64. 256.]\n",
      "[[  3.           1.        ]\n",
      " [  4.           4.        ]\n",
      " [  5.          16.        ]\n",
      " [  6.333       64.        ]\n",
      " [  3.14159265 256.        ]]\n"
     ]
    }
   ],
   "source": [
    "print(d)\n",
    "print(f)\n",
    "print(np.stack([d, f], axis=1)) # makes them column vectors and concatenate along axis 1\n",
    "# check out np.column_stack which does the same and it's more readable for 1-d arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3.         4.         5.         6.333      3.14159265]\n",
      "[  1.   4.  16.  64. 256.]\n",
      "[  3.           4.           5.           6.333        3.14159265\n",
      "   1.           4.          16.          64.         256.        ]\n"
     ]
    }
   ],
   "source": [
    "print(d)\n",
    "print(f)\n",
    "print(np.hstack([d, f])) # column-wise stacking"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3.         4.         5.         6.333      3.14159265]\n",
      "[  1.   4.  16.  64. 256.]\n",
      "[[  3.           4.           5.           6.333        3.14159265]\n",
      " [  1.           4.          16.          64.         256.        ]]\n"
     ]
    }
   ],
   "source": [
    "print(d)\n",
    "print(f)\n",
    "print(np.vstack([d, f])) # row-wise stacking"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise: create two 1-D arrays of length 10 and:\n",
    "- concatenate them\n",
    "- make them column vectors\n",
    "- concatenate the column vectors row-wise\n",
    "- concatenate the column vectors column-wise"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Splitting arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 1 2 3 4 5 6 7 8]\n"
     ]
    }
   ],
   "source": [
    "print(g)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[array([0, 1, 2]), array([3, 4, 5]), array([6, 7, 8])]"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.split(g, 3) # split in 3, length % n must be 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[array([0, 1, 2]), array([3, 4, 5, 6, 7, 8])]"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.split(g, (3,)) # split at position 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[array([0, 1, 2]), array([3, 4, 5, 6, 7]), array([8])]"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.split(g, (3, 8)) # split at positions 3 and 8"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0 1 2]\n",
      " [3 4 5]\n",
      " [6 7 8]]\n"
     ]
    }
   ],
   "source": [
    "print(h)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[array([[0, 1, 2]]), array([[3, 4, 5],\n",
       "        [6, 7, 8]])]"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.split(h, (1,)) # split row-wise. Check np.hsplit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[array([[0],\n",
       "        [3],\n",
       "        [6]]), array([[1, 2],\n",
       "        [4, 5],\n",
       "        [7, 8]])]"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.split(h, (1,), axis=1) # split column-wise. Check np.vsplit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[array([0, 1, 2]), array([3, 4]), array([5, 6]), array([7, 8])]"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.array_split(g, 4) # same as split, but allows length % 0 != 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise: create a 2-D array of shape (5, 3) by splitting a 1-D array and joining the results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tiles and repeats"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([4, 4, 4, 4, 4])"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.tile(4, 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([4, 4, 4, 4, 4])"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.repeat(4, 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3])"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.tile(np.arange(4), 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3])"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.repeat(np.arange(4), 5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Adding and removing elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[  1.   4.  16.  64. 256.]\n"
     ]
    }
   ],
   "source": [
    "print(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([  1.,   4.,  16.,  64., 256., 513.])"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.append(f, 513) # f is not modified. This is a new object"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([   1.,    4.,   16., -123.,   64.,  256.])"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.insert(f, 3, -123) # f is not modified. This is a new object"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1.,  4., 16., 64.])"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.delete(f, 4) # f is not modified. This is a new object"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 3 2 2 1 1 1 2 1 2 2 2 2 0 4 1 1 0 4 0]\n",
      "[0 1 2 3 4]\n"
     ]
    }
   ],
   "source": [
    "m = np.random.poisson(2, 20)\n",
    "print(m)\n",
    "print(np.unique(m))\n",
    "# Check out documentation for returning extra information such as number of occurrences of each value"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise: reverse the following array by removing and inserting elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0, 10, 20, 30, 40, 50, 60, 70, 80, 90])"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "reverse_me = np.arange(0, 100, 10)\n",
    "reverse_me"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Moving elements around"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 1 2 3 4 5 6 7 8]\n"
     ]
    }
   ],
   "source": [
    "print(g)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([5, 6, 7, 8, 0, 1, 2, 3, 4])"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.roll(g, 4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3, 4, 5, 6, 7, 8, 0, 1, 2])"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.roll(g, -3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0 1 2]\n",
      " [3 4 5]\n",
      " [6 7 8]]\n"
     ]
    }
   ],
   "source": [
    "print(h)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[2, 5, 8],\n",
       "       [1, 4, 7],\n",
       "       [0, 3, 6]])"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.rot90(h)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise: print all possible rolls of the following array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [],
   "source": [
    "roll_me = np.arange(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Indexing\n",
    "\n",
    "Given an N-dimensional array, x, x[index] performs basic indexing, where index can be:\n",
    "\n",
    "- integers\n",
    "- slice objects\n",
    "- numpy.newaxis objects (None)\n",
    "- Ellipsis objects\n",
    "\n",
    "Basic indexing will return a VIEW of the array (is a pointer that is pointing to the same memory where the original array is stored).\n",
    "\n",
    "Advanced indexing is using a non-tuple object as index (such as boolean mask or integer indices of an array). Advanced indexing will always return a COPY of the original array.\n",
    "Meaning that when you call a getattr of numpy class it will return a temporary copy (note that setattr is not returning anything)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Indexing with integers:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 0.  1.  4.  9. 16. 25. 36. 49. 64. 81.]\n",
      "0.0\n",
      "1.0\n",
      "4.0\n",
      "9.0\n",
      "16.0\n",
      "25.0\n",
      "36.0\n",
      "49.0\n",
      "64.0\n",
      "81.0\n"
     ]
    }
   ],
   "source": [
    "print(e)\n",
    "for i in range(len(e)):\n",
    "    print(e[i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 0.  1.  4.  9. 16. 25. 36. 49. 64. 81.]\n",
      "16.0\n",
      "[ 0.  1.  4.  9.  0. 25. 36. 49. 64. 81.]\n"
     ]
    }
   ],
   "source": [
    "e_copy = np.copy(e)\n",
    "print(e_copy)\n",
    "print (e_copy[4])\n",
    "e_copy[4] = 0\n",
    "print(e_copy)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Indexing with slices can be either using python slice object or a syntax  `:`. In the case of `:` it will take all the values in a given dimension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[25. 16.  9.  4.  1.]\n"
     ]
    }
   ],
   "source": [
    "sl = slice(5, 0, -1) # start, end, step\n",
    "print(e[sl])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[25. 16.  9.  4.  1.]\n",
      "[ 0.  1.  4.  9. 16. 25. 36. 49. 64. 81.]\n"
     ]
    }
   ],
   "source": [
    "# Thes syntax ':' is identical to python slice object\n",
    "print(e[5:0:-1])\n",
    "print(e[:])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 0.  1.  4.  9. 16. 25. 36. 49. 64. 81.]\n",
      "[25. 16.  9.  4.  1.]\n",
      "[ 0.  1.  4.  9. 16. 99. 36. 49. 64. 81.]\n"
     ]
    }
   ],
   "source": [
    "e_copy = np.copy (e)\n",
    "print(e_copy)\n",
    "sl = slice(5, 0, -1) # start, end, step\n",
    "print(e_copy[sl])\n",
    "np.shares_memory(e_copy, e_copy[sl])\n",
    "e_copy[sl][0] = 99\n",
    "print(e_copy) #it changed!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`np.newaxis` (which is actually a descriptive name for `None`) increases the dimension of the array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0.]\n",
      " [ 1.]\n",
      " [ 4.]\n",
      " [ 9.]\n",
      " [16.]\n",
      " [25.]\n",
      " [36.]\n",
      " [49.]\n",
      " [64.]\n",
      " [81.]]\n",
      "[[ 0.  1.  4.  9. 16. 25. 36. 49. 64. 81.]]\n"
     ]
    }
   ],
   "source": [
    "print(e[:,np.newaxis])   # add axis after \n",
    "print(e[np.newaxis,...]) # add axis before"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Indexing with array will always return a copy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 1.  4. 16. 64.]\n",
      "[ 0.  1.  4.  9. 16. 25. 36. 49. 64. 81.]\n"
     ]
    }
   ],
   "source": [
    "mask = [False, True, True, False, True, False, False, False, True, False]\n",
    "mask = np.asarray(mask) # not really needed\n",
    "print(e[mask])\n",
    "e[mask][0] = 9999\n",
    "print(e) #nothing changed!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Multidimensional indexing \n",
    "Works similar as one dimensional indexing, you should provide indexing pattern per dimension (or use Ellipsis)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1. 0. 0.]\n",
      " [0. 1. 0.]\n",
      " [0. 0. 1.]\n",
      " [0. 0. 0.]]\n"
     ]
    }
   ],
   "source": [
    "print(l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0., 0., 1., 0.])"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l[:, 2] # all rows, single column"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 0.],\n",
       "       [0., 1.],\n",
       "       [0., 0.],\n",
       "       [0., 0.]])"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l[:, 0:2] # all rows, range of columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 0., 0.],\n",
       "       [0., 1., 0.]])"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l[:2, :] # range of rows, all columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 0.],\n",
       "       [0., 0.]])"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l[2:4, 0:2] # range of rows, range of columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 0., 0.]])"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l[np.newaxis , 0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Broadcasting\n",
    "It is a way how numpy treats arrays with different shapes during aritmethical operations. \n",
    "Two dimensionals are combatible if:\n",
    "- they are equal\n",
    "- one of them is scalar\n",
    "\n",
    "The results will always have the shape of a larger array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.arange(8)\n",
    "b = np.arange(8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(8,) (8,) (8,)\n",
      "(8,)\n"
     ]
    }
   ],
   "source": [
    "#equal dimensions\n",
    "ab = a*b\n",
    "print(a.shape, b.shape, ab.shape)\n",
    "#with a scalar\n",
    "ascal = a*2\n",
    "print(ascal.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2, 3, 4) (3, 4) (2, 3, 4)\n"
     ]
    }
   ],
   "source": [
    "#works with N-D arrays as well\n",
    "at = np.random.randint(0, 100, size=(2,3,4))\n",
    "bt = np.random.randint(0, 100, size=(3,4))  # This is broadcasted to (1, 3, 4)\n",
    "print(at.shape, bt.shape, (at*bt).shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[78 52 49 57]]\n",
      "\n",
      " [[69 19 74 55]]]\n",
      "[[46  3 70 23]\n",
      " [49 77 49 51]\n",
      " [56  0 27 37]]\n",
      "[[[3588  156 3430 1311]\n",
      "  [3822 4004 2401 2907]\n",
      "  [4368    0 1323 2109]]\n",
      "\n",
      " [[3174   57 5180 1265]\n",
      "  [3381 1463 3626 2805]\n",
      "  [3864    0 1998 2035]]]\n",
      "(2, 1, 4) (3, 4) (2, 3, 4)\n"
     ]
    }
   ],
   "source": [
    "at = np.random.randint(0, 100, size=(2,1,4))# This is broadcasted to (2, 3, 4)\n",
    "bt = np.random.randint(0, 100, size=(3,4))  # This is broadcasted to (1, 3, 4)\n",
    "print(at)\n",
    "print(bt)\n",
    "print(at*bt)\n",
    "print(at.shape, bt.shape, (at*bt).shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise:\n",
    "- can you multiply an array of shape (4, 2) with one of shape (4, 2, 1)?\n",
    "- can you multiply an array of shape (4, 2) with one of shape (4, 1, 2)?\n",
    "- can you multiply an array of shape (4, 2) with one of shape (1, 4, 2)?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Binary operations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ True False  True  True  True False  True False  True False]\n",
      "[ True False False  True False  True  True False False  True]\n"
     ]
    }
   ],
   "source": [
    "n = np.random.choice([True, False], size=10)\n",
    "o = np.random.choice([True, False], size=10)\n",
    "print(n)\n",
    "print(o)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ True, False, False,  True, False, False,  True, False, False,\n",
       "       False])"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n & o"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ True, False,  True,  True,  True,  True,  True, False,  True,\n",
       "        True])"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n | o"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([False, False,  True, False,  True,  True, False, False,  True,\n",
       "        True])"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n ^ o"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([False,  True, False, False, False,  True, False,  True, False,\n",
       "        True])"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "~ n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise: implement a 3-bit xor by combining two-bit operators\n",
    "```\n",
    "False False False = False\n",
    "False False  True =  True\n",
    "False  True False =  True\n",
    " True False False =  True\n",
    "False  True  True = False\n",
    " True  True False = False\n",
    " True False  True = False\n",
    " True  True  True = False\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Applying functions over arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Extending a scalar function to an array"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Probably the easiest way to apply a apply functions that operate over arrays is using `np.vectorize`. `np.vectorize` is a decorator to apply to a function that operates over a scalar. The result is a function that can operate over an arbitrary array at C-like speed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [],
   "source": [
    "def myfunc(a, b):\n",
    "    if   (a * b) % 3 == 0: return a - b\n",
    "    elif a % 2           : return b - a\n",
    "    else                 : return a + b\n",
    "    \n",
    "myfunc_vectorized = np.vectorize(myfunc)\n",
    "# same as\n",
    "#\n",
    "# @np.vectorize\n",
    "# def ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "h = \n",
      " [[0 1 2]\n",
      " [3 4 5]\n",
      " [6 7 8]]\n",
      "p = \n",
      " [[6 6 6]\n",
      " [8 0 2]\n",
      " [0 7 1]]\n"
     ]
    }
   ],
   "source": [
    "p = np.random.randint(0, 10, 9).reshape(3, 3)\n",
    "print(\"h = \\n\", h)\n",
    "print(\"p = \\n\", p)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Error: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    myfunc(h, p)\n",
    "except ValueError as error:\n",
    "    print(\"Error:\", error)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-6, -5, -4],\n",
       "       [-5,  4, -3],\n",
       "       [ 6,  0,  9]])"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myfunc_vectorized(h, p)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Applying functions over axes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 3, 12, 21])"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.apply_along_axis(np.sum, 1, h)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.        , 1.        , 1.41421356],\n",
       "       [1.73205081, 2.        , 2.23606798],\n",
       "       [2.44948974, 2.64575131, 2.82842712]])"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.apply_along_axis(np.sqrt, 1, h)\n",
    "# This function operates element by element, therefore it change the shape!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([      1,    4096, 1500625])"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def complex_operation_over_array(a):\n",
    "    b = a[0] + a[2] - a[1]**2\n",
    "    c = b ** 4\n",
    "    return c\n",
    "\n",
    "np.apply_along_axis(complex_operation_over_array, 1, h)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Applying different operations to different parts of the array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1, -2],\n",
       "       [ 9, -4, 25],\n",
       "       [-6, 49, -8]])"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "even = h % 2 == 0\n",
    "odd  = ~even\n",
    "np.piecewise(h, [even, odd], [np.negative, np.square])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise: create an array with two columns (mean and std) of each row of the following array. Repeat for columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [],
   "source": [
    "means   = np.random.uniform(10, 1000, 10)\n",
    "stat_me = np.random.uniform(means, means**0.5, (20, means.size))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Sorting, searching and counting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[  1   3  65   2  -1   4  -5 -10]\n"
     ]
    }
   ],
   "source": [
    "q = np.asarray([1, 3, 65, 2, -1, 4, -5, -10])\n",
    "print(q)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-10,  -5,  -1,   1,   2,   3,   4,  65])"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sort(q)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([7, 6, 4, 0, 3, 1, 5, 2])"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.argsort(q)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-10,  -5,  -1,   1,   2,   3,   4,  65])"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q[np.argsort(q)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-10,  -5,  -1,   1,   2,   3,   4,  65])"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "r = np.copy(q)\n",
    "r.sort() # sort in-place\n",
    "r"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "65 2\n"
     ]
    }
   ],
   "source": [
    "print(np.max(q), np.argmax(q))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-10 7\n"
     ]
    }
   ],
   "source": [
    "print(np.min(q), np.argmin(q))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ -1,  -3, -65,   4,   1,  16,   5, 100])"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.where(q % 2 == 0, q**2, -q)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0 1 2]\n",
      " [3 4 5]\n",
      " [6 7 8]]\n"
     ]
    }
   ],
   "source": [
    "print(h)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 0],\n",
       "       [0, 2],\n",
       "       [1, 1],\n",
       "       [2, 0],\n",
       "       [2, 2]])"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.argwhere(h % 2 == 0) # each entry is a set of indices that point to the element"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[False  True  True False  True False False False  True False]\n"
     ]
    }
   ],
   "source": [
    "print(mask)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 4 6\n"
     ]
    }
   ],
   "source": [
    "print(len(mask), np.count_nonzero(mask), np.count_nonzero(~mask))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([False, False,  True, False, False,  True, False, False,  True,\n",
       "       False])"
      ]
     },
     "execution_count": 107,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "to_search = [1, 2, 5, 6, 7, 10, 11, 14, 15, 66]\n",
    "good_ones = [5, 10, 15]\n",
    "np.in1d(to_search, good_ones)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([False, False,  True, False])"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.isnan([1, 3, np.nan, 4])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Find the indices of the nan value in the following array. Try to do it in two different ways"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9485"
      ]
     },
     "execution_count": 109,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "find_the_nan = np.random.uniform(0, 100, 100000)\n",
    "true_index   = np.random.randint(0,      100000)\n",
    "find_the_nan[true_index] = np.nan\n",
    "true_index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Others"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-10  -5  -1   1   2   3   4  65] 8\n"
     ]
    }
   ],
   "source": [
    "print(r, len(r))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 5  4  2  1  1  1 61] 7\n"
     ]
    }
   ],
   "source": [
    "s = np.diff(r)\n",
    "print(s, len(s))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-2, -2, -1,  1,  2,  3,  4,  5])"
      ]
     },
     "execution_count": 112,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.clip(r, -2, 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [],
   "source": [
    "heights, bin_edges = np.histogram(r, 20, (-10, 20))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6.708203932499369"
      ]
     },
     "execution_count": 114,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x_pos = np.asarray([1, 4,  4])\n",
    "y_pos = np.asarray([5, 2, -1])\n",
    "np.linalg.norm(x_pos - y_pos) # Euclidean distance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 1, 1, 2, 2, 2, 2, 4])"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bins = [-10, 0, 10, 20]\n",
    "np.digitize(r, bins) # ask which bin each value falls into 0 = underflow, len(bins) = overflow"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(4.0, 5.0)"
      ]
     },
     "execution_count": 116,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.floor(4.4), np.ceil(4.6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 117,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.round(1.234)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.234568"
      ]
     },
     "execution_count": 118,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.round(1.23456789, decimals=6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Random number generation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<module 'numpy.random' from '/home/gonzalo/sw/anaconda3/envs/IC-3.7-2018-11-14/lib/python3.7/site-packages/numpy/random/__init__.py'>"
      ]
     },
     "execution_count": 119,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.9362641152115523"
      ]
     },
     "execution_count": 120,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.exponential(4) # sample from a exponential distribution with scale value 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.9423931455462915"
      ]
     },
     "execution_count": 121,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.normal(5, 1.1) # sample from a gaussian with mean 5 and sigma 1.1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 122,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.poisson(5.3) # sample from a poisson with mean 5.3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# For testing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are some utilities in numpy to compare numbers: `np.isclose`, `np.allclose`.\n",
    "The first is used to compare two numbers or two arrays element by element. The second one is equivalent to `all(np.isclose(a, b))`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Element by element [ True  True  True  True  True  True  True  True  True  True]\n",
      "All together       True\n"
     ]
    }
   ],
   "source": [
    "a = np.random.uniform(1, 2    , size=10)\n",
    "b = np.random.normal (0, 1e-13, size=10)\n",
    "print(\"Element by element\", np.isclose (a, a + b))\n",
    "print(\"All together      \", np.allclose(a, a + b))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The function is parametrizable with two tolerances: an absolute one and a relative one and it checks\n",
    "$$|a - b| \\leq a_{tol} + r_{tol} \\cdot |b|$$\n",
    "The values default to $a_{tol} = 10^{-8}$ and $r_{tol} = 10^{-5}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Element by element [ True False False False  True  True  True  True  True  True]\n",
      "All together       False\n"
     ]
    }
   ],
   "source": [
    "print(\"Element by element\", np.isclose (a, a + b, atol=0, rtol=1e-13))\n",
    "print(\"All together      \", np.allclose(a, a + b, atol=0, rtol=1e-13))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Element by element [False False False False  True  True  True  True False False]\n",
      "All together       False\n"
     ]
    }
   ],
   "source": [
    "print(\"Element by element\", np.isclose (a, a + b, atol=1e-13, rtol=0))\n",
    "print(\"All together      \", np.allclose(a, a + b, atol=1e-13, rtol=0))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}