210916 Part2.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 150,
   "id": "8941f9b4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.5488135 , 0.71518937, 0.60276338, 0.54488318],\n",
       "       [0.4236548 , 0.64589411, 0.43758721, 0.891773  ],\n",
       "       [0.96366276, 0.38344152, 0.79172504, 0.52889492],\n",
       "       [0.56804456, 0.92559664, 0.07103606, 0.0871293 ]])"
      ]
     },
     "execution_count": 150,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "np.random.seed(0)\n",
    "A2 = np.random.random((4,4)) \n",
    "A2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "id": "baf30128",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.5488135 , 0.71518937],\n",
       "       [0.4236548 , 0.64589411]])"
      ]
     },
     "execution_count": 151,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#create a subarray\n",
    "A3 = A2[0:2,0:2]\n",
    "A3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "id": "ecf1b899",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1.09762701 1.43037873]\n",
      " [0.8473096  1.29178823]]\n"
     ]
    }
   ],
   "source": [
    "print(A3*2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "id": "9e5fd097",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[10.5488135  10.71518937]\n",
      " [10.4236548  10.64589411]]\n"
     ]
    }
   ],
   "source": [
    "print(A3+10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "id": "9063c1d5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4, 5, 6, 7, 8, 9])"
      ]
     },
     "execution_count": 154,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#reshaping of arrays\n",
    "np.arange(1,10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "id": "72cc8f17",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3],\n",
       "       [4, 5, 6],\n",
       "       [7, 8, 9]])"
      ]
     },
     "execution_count": 155,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.arange(1,10).reshape((3,3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "id": "cc16d682",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3, 4, 5, 6, 7, 8, 9]])"
      ]
     },
     "execution_count": 156,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#A common reshaping pattern is the conversion of a one-dimensional \n",
    "#array into a two-dimensional row or column matrix\n",
    "#Vector having only one column is called a column vector\n",
    "#Vector having only one row is called a row vector\n",
    "np.arange(1,10).reshape((1,9))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "id": "1ec27fab",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1],\n",
       "       [2],\n",
       "       [3],\n",
       "       [4],\n",
       "       [5],\n",
       "       [6],\n",
       "       [7],\n",
       "       [8],\n",
       "       [9]])"
      ]
     },
     "execution_count": 157,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.arange(1,10).reshape((9,1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "id": "456e584d",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Array concatenation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 159,
   "id": "ef0dbd6e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4, 5, 6])"
      ]
     },
     "execution_count": 159,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A1 = np.array([1,2,3])\n",
    "A2 = np.array([4,5,6])\n",
    "A3 = np.concatenate([A1,A2])\n",
    "A3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "id": "be5036f3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([4, 5, 6, 1, 2, 3])"
      ]
     },
     "execution_count": 160,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A3 = np.concatenate([A2,A1])\n",
    "A3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "id": "4bacb0ad",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[4 5] [6 1] [2 3]\n"
     ]
    }
   ],
   "source": [
    "#Array splitting, the opposite of concatenation\n",
    "#Need to specify the split points\n",
    "#The number of arrays is N the number of split points + 1\n",
    "A3\n",
    "a1,a2,a3 = np.split(A3, [2,4])\n",
    "print(a1,a2,a3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "id": "d632de6e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2],\n",
       "       [4, 5]])"
      ]
     },
     "execution_count": 162,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Append a column to a Numpy array\n",
    "#Class example\n",
    "import numpy as np\n",
    "A1 = np.array([[1,2],[4,5]])\n",
    "A1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "id": "44dd0d35",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[3], [6]]"
      ]
     },
     "execution_count": 163,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Column to add is a column vector\n",
    "A2 = [[3],[6]]\n",
    "A2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "id": "e25f0399",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3],\n",
       "       [4, 5, 6]])"
      ]
     },
     "execution_count": 164,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "newA1 = np.append(A1,A2,axis=1)\n",
    "newA1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "id": "9b57f336",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 3],\n",
       "       [4, 6]])"
      ]
     },
     "execution_count": 165,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Insert a column in a Numpy array\n",
    "#Class example\n",
    "import numpy as np\n",
    "A1 = np.array([[1,3],[4,6]])\n",
    "A1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 166,
   "id": "ff6d9630",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 5]"
      ]
     },
     "execution_count": 166,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Values to insert into the Numpy array\n",
    "A2 = [2,5]\n",
    "A2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 167,
   "id": "09beb7e3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 3]\n",
      " [4 6]]\n",
      "[2, 5]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3],\n",
       "       [4, 5, 6]])"
      ]
     },
     "execution_count": 167,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#insert a new column at index 1\n",
    "print(A1)\n",
    "print(A2)\n",
    "newA1 = np.insert(A1,1,A2,axis=1)\n",
    "newA1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 168,
   "id": "1e6a5d2c",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Numpy provides an easy and flexible interface to optimize \n",
    "#computations with arrays of data\n",
    "#To make computations faster, use vectorized operations implemented \n",
    "#through Numpy's universal functions (UFuncs)\n",
    "#Types of ufuncs: single input i.e. unary ufuncs and binary ufuncs\n",
    "#Numpy understands Python's built-in arithmetic operations\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 169,
   "id": "c3f8eec4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'numpy.ndarray'> [0 1 2 3 4 5 6 7 8 9]\n"
     ]
    }
   ],
   "source": [
    "x = np.arange(10)\n",
    "print(type(x),x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 170,
   "id": "2ea1f36e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 1  2  3  4  5  6  7  8  9 10]\n",
      "[ 0  2  4  6  8 10 12 14 16 18]\n",
      "[-10  -9  -8  -7  -6  -5  -4  -3  -2  -1]\n",
      "[0.  0.5 1.  1.5 2.  2.5 3.  3.5 4.  4.5]\n",
      "[ 0 -1 -2 -3 -4 -5 -6 -7 -8 -9]\n",
      "[ 0  1  4  9 16 25 36 49 64 81]\n",
      "[0 1 0 1 0 1 0 1 0 1]\n",
      "[3 2 1 0 1 2 3 4 5 6]\n"
     ]
    }
   ],
   "source": [
    "print(x+1)\n",
    "print(x*2)\n",
    "print(x-10)\n",
    "print(x/2)\n",
    "print(-x) #negation\n",
    "print(x**2) #exponentiation\n",
    "print(x%2) #modulus\n",
    "print(abs(x-3)) #absolute value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 171,
   "id": "2bf95ff8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[10 15 20 25 30 35 40 45 50 55]\n"
     ]
    }
   ],
   "source": [
    "#can string them together such as an expression\n",
    "print(x*5+10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 172,
   "id": "47696199",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Numpy understands other Python's built-in functions including \n",
    "#but not limited to \n",
    "#abs,trigonometric functions, exponents and logarithms"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 173,
   "id": "dbb72efc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.02021839744032572\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([0.0202184 , 0.04043679, 0.06065519, 0.08087359, 0.10109199,\n",
       "       0.12131038, 0.14152878, 0.16174718, 0.18196558, 0.20218397,\n",
       "       0.22240237, 0.24262077, 0.26283917, 0.28305756, 0.30327596,\n",
       "       0.32349436, 0.34371276, 0.36393115, 0.38414955, 0.40436795,\n",
       "       0.42458635, 0.44480474, 0.46502314, 0.48524154, 0.50545994,\n",
       "       0.52567833, 0.54589673, 0.56611513, 0.58633353, 0.60655192,\n",
       "       0.62677032, 0.64698872, 0.66720712, 0.68742551, 0.70764391,\n",
       "       0.72786231, 0.74808071, 0.7682991 , 0.7885175 , 0.8087359 ,\n",
       "       0.8289543 , 0.84917269, 0.86939109, 0.88960949, 0.90982788,\n",
       "       0.93004628, 0.95026468, 0.97048308, 0.99070147, 1.01091987])"
      ]
     },
     "execution_count": 173,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "R1 = np.random.random()\n",
    "print(R1)\n",
    "A1 = np.arange(1,51)*R1\n",
    "A1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 174,
   "id": "d7c6cfb1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.0202184 , 0.04043679, 0.06065519, 0.08087359, 0.10109199],\n",
       "       [0.12131038, 0.14152878, 0.16174718, 0.18196558, 0.20218397],\n",
       "       [0.22240237, 0.24262077, 0.26283917, 0.28305756, 0.30327596],\n",
       "       [0.32349436, 0.34371276, 0.36393115, 0.38414955, 0.40436795],\n",
       "       [0.42458635, 0.44480474, 0.46502314, 0.48524154, 0.50545994],\n",
       "       [0.52567833, 0.54589673, 0.56611513, 0.58633353, 0.60655192],\n",
       "       [0.62677032, 0.64698872, 0.66720712, 0.68742551, 0.70764391],\n",
       "       [0.72786231, 0.74808071, 0.7682991 , 0.7885175 , 0.8087359 ],\n",
       "       [0.8289543 , 0.84917269, 0.86939109, 0.88960949, 0.90982788],\n",
       "       [0.93004628, 0.95026468, 0.97048308, 0.99070147, 1.01091987]])"
      ]
     },
     "execution_count": 174,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A2 = A1.reshape(10,5)\n",
    "A2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 175,
   "id": "84352330",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Often when we are faced with a large amount of data, a first step is \n",
    "#to compute summary statistics (more to come)\n",
    "#Using A2 and A3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 176,
   "id": "fa713c81",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "25.77845673641529"
      ]
     },
     "execution_count": 176,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A2.sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 177,
   "id": "6ed03f4c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([4.7513234 , 4.95350737, 5.15569135, 5.35787532, 5.5600593 ])"
      ]
     },
     "execution_count": 177,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A2.sum(axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 178,
   "id": "d6c57843",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.30327596, 0.8087359 , 1.31419583, 1.81965577, 2.32511571,\n",
       "       2.83057564, 3.33603558, 3.84149551, 4.34695545, 4.85241539])"
      ]
     },
     "execution_count": 178,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A2.sum(axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 179,
   "id": "fe675a1d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.ndarray"
      ]
     },
     "execution_count": 179,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(A2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 180,
   "id": "50d2a07c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.5155691347283058"
      ]
     },
     "execution_count": 180,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A2.mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 181,
   "id": "bcc38359",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.47513234, 0.49535074, 0.51556913, 0.53578753, 0.55600593])"
      ]
     },
     "execution_count": 181,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#axis = 0 refers to within each column will be aggregated or collapsed\n",
    "A2.mean(axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 182,
   "id": "a1f6f19c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.06065519, 0.16174718, 0.26283917, 0.36393115, 0.46502314,\n",
       "       0.56611513, 0.66720712, 0.7682991 , 0.86939109, 0.97048308])"
      ]
     },
     "execution_count": 182,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#axis = 1 refers to within each row will be aggregated or collapsed\n",
    "A2.mean(axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 183,
   "id": "7167ac28",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.0202184 , 0.04043679, 0.06065519, 0.08087359, 0.10109199],\n",
       "       [0.12131038, 0.14152878, 0.16174718, 0.18196558, 0.20218397],\n",
       "       [0.22240237, 0.24262077, 0.26283917, 0.28305756, 0.30327596],\n",
       "       [0.32349436, 0.34371276, 0.36393115, 0.38414955, 0.40436795],\n",
       "       [0.42458635, 0.44480474, 0.46502314, 0.48524154, 0.50545994],\n",
       "       [0.52567833, 0.54589673, 0.56611513, 0.58633353, 0.60655192],\n",
       "       [0.62677032, 0.64698872, 0.66720712, 0.68742551, 0.70764391],\n",
       "       [0.72786231, 0.74808071, 0.7682991 , 0.7885175 , 0.8087359 ],\n",
       "       [0.8289543 , 0.84917269, 0.86939109, 0.88960949, 0.90982788],\n",
       "       [0.93004628, 0.95026468, 0.97048308, 0.99070147, 1.01091987]])"
      ]
     },
     "execution_count": 183,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 184,
   "id": "71e519ca",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.0202184 , 0.04043679, 0.06065519, 0.08087359, 0.10109199])"
      ]
     },
     "execution_count": 184,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A2.min(axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 185,
   "id": "17836954",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.10109199, 0.20218397, 0.30327596, 0.40436795, 0.50545994,\n",
       "       0.60655192, 0.70764391, 0.8087359 , 0.90982788, 1.01091987])"
      ]
     },
     "execution_count": 185,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A2.max(axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 186,
   "id": "91c837fd",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Let's use our normal distribution generator\n",
    "A3 = np.random.normal(0,1,(100,5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 187,
   "id": "bfa4b6ab",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(100, 5)"
      ]
     },
     "execution_count": 187,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A3.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 188,
   "id": "bc5ffbee",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-0.07271607, -0.17837509,  0.00832367, -0.08173388,  0.00830538])"
      ]
     },
     "execution_count": 188,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Calculate the mean for each column\n",
    "A3.mean(axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 189,
   "id": "2c8fef6b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.3835206 ,  0.08107537, -0.23820199,  0.7521679 ,  0.34210952,\n",
       "       -0.41403917, -0.17193642, -0.52299173, -0.37823284,  0.13853756,\n",
       "        0.14520607,  0.17248319, -0.49188373,  0.0116472 ,  0.19097146,\n",
       "        0.19814695,  0.51026438,  0.59316247,  0.24986204, -0.16904396,\n",
       "       -0.17872055,  1.04301037, -0.66721455,  0.19207304, -0.36405662,\n",
       "        0.51859969, -0.26874386,  0.50240549,  0.85928003, -0.87021659,\n",
       "       -0.33687839, -0.28653485,  0.06700472,  0.26175892,  0.08156695,\n",
       "       -1.31494588,  0.14315737, -0.41108489, -0.33279697, -0.40886095,\n",
       "        0.05441296,  0.20291789,  0.47646166, -0.56174592, -0.32411879,\n",
       "       -0.13347887, -0.33978084, -0.04805136, -0.31533384,  0.2222016 ,\n",
       "       -0.246102  , -0.75084616, -0.12649455,  0.6507652 ,  0.15292565,\n",
       "        0.38570275,  0.25349723,  0.22615299,  0.6313353 , -0.22916892,\n",
       "       -0.44015075, -0.89615229, -0.58774274,  0.01245938, -0.26178942,\n",
       "        0.21327791, -0.48473164, -0.05270161, -0.14141927, -0.47087549,\n",
       "       -0.21648743,  0.19295591, -0.62804712, -0.35539288, -0.04122654,\n",
       "       -1.13139683, -0.47512111,  0.57426816, -0.00295643, -0.21814491,\n",
       "       -0.34362734,  0.82739463,  0.61532733,  0.09473271,  0.07703268,\n",
       "        0.57205968, -0.21629795,  0.39044124, -0.0541434 , -0.50024943,\n",
       "       -0.47850946, -0.87586786,  0.14183698,  0.45244438, -0.01157966,\n",
       "       -0.56583734,  0.17455463, -0.38755732, -0.38364551, -0.23393287])"
      ]
     },
     "execution_count": 189,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Calculate the mean for each row\n",
    "A3.mean(axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 190,
   "id": "fae63371",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "217"
      ]
     },
     "execution_count": 190,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Other functions include standard deviation, minimu, maximum, \n",
    "#finding the index of minimum value, finding the index of maximum value\n",
    "np.argmin(A3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 191,
   "id": "b424fed8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "266"
      ]
     },
     "execution_count": 191,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.argmax(A3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 192,
   "id": "98834449",
   "metadata": {},
   "outputs": [],
   "source": [
    "#The book goes into broadcasting by providing rules to determine the \n",
    "#interaction between two arrays\n",
    "#Array can be padded or stretched. This topic is out of scope for this course."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 193,
   "id": "f508065e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ True,  True, False, False, False])"
      ]
     },
     "execution_count": 193,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Numpy also implements comparison operators such as <, <=, >, >=, != \n",
    "#and == as element-wise ufuncs.\n",
    "#The results is always an array with a boolean data type.\n",
    "A4 = np.array([11,12,13,14,15])\n",
    "A4 < 13"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 194,
   "id": "f8acf2a0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([False,  True,  True,  True,  True])"
      ]
     },
     "execution_count": 194,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A4 > 11"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 195,
   "id": "3de7b10d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([False, False, False,  True,  True])"
      ]
     },
     "execution_count": 195,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A4 >= 14"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 196,
   "id": "6cfde1a2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ True, False,  True,  True,  True])"
      ]
     },
     "execution_count": 196,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A4 != 12"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 197,
   "id": "31ff6228",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 197,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Working with boolean arrays\n",
    "np.count_nonzero(A4<13)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 198,
   "id": "1cbedd86",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 198,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sum(A4<13)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 199,
   "id": "c630e661",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[66 72 78 84]\n"
     ]
    }
   ],
   "source": [
    "#Recall that aggregate functions such as sum can be done along rows or columns\n",
    "A5 = np.array([[21,23,25,27],[22,24,26,28],[23,25,27,29]])\n",
    "\n",
    "print(np.sum(A5,axis=0))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 200,
   "id": "e981f36d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 96 100 104]\n"
     ]
    }
   ],
   "source": [
    "print(np.sum(A5,axis=1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 201,
   "id": "f8b6b9a9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2 1 1]\n"
     ]
    }
   ],
   "source": [
    "#To sum the number of true entries in each row, collapsing or \n",
    "#aggregating the column\n",
    "print(np.sum(A5<24,axis=1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 202,
   "id": "46cc6469",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3 1 0 0]\n"
     ]
    }
   ],
   "source": [
    "#To sum the number of true entries in each column, collapsing or \n",
    "#aggregating the row\n",
    "print(np.sum(A5<24,axis=0))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 203,
   "id": "2aacf8ec",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Fancing indexing - pass an array of indices to access multiple \n",
    "#array elements at once\n",
    "#Shape of the results reflects the shape of the index array\n",
    "A6 = np.array([10,11,12,13,14,15,16,17,18,19,20])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 204,
   "id": "ada654f2",
   "metadata": {},
   "outputs": [],
   "source": [
    "A6_ind = np.array([[4,6],[3,5]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 205,
   "id": "5ba79200",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(11,)"
      ]
     },
     "execution_count": 205,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.shape(A6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 206,
   "id": "30fa41aa",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 2)"
      ]
     },
     "execution_count": 206,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.shape(A6_ind)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 207,
   "id": "e1cb48ca",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[14, 16],\n",
       "       [13, 15]])"
      ]
     },
     "execution_count": 207,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A6[A6_ind]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 208,
   "id": "c47d8e89",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Combined indexing allows for fancing indexing to be combined \n",
    "#with other indexing schemes\n",
    "A7 = np.array([['a','b','c','d'],['e','f','g','h'],['i','j','k','l']])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 209,
   "id": "86685360",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([['a', 'b', 'c', 'd'],\n",
       "       ['e', 'f', 'g', 'h'],\n",
       "       ['i', 'j', 'k', 'l']], dtype='<U1')"
      ]
     },
     "execution_count": 209,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 210,
   "id": "ceed8a89",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['k', 'i'], dtype='<U1')"
      ]
     },
     "execution_count": 210,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Combine fancy and simple indices\n",
    "A7[2,[2,0]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 211,
   "id": "0aaa4a3d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([['g', 'e'],\n",
       "       ['k', 'i']], dtype='<U1')"
      ]
     },
     "execution_count": 211,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Combine slicing and fancy indexing\n",
    "A7[1:,[2,0]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 212,
   "id": "72f5ba9c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([['i', 'j', 'k', 'l'],\n",
       "       ['a', 'b', 'c', 'd'],\n",
       "       ['e', 'f', 'g', 'h']], dtype='<U1')"
      ]
     },
     "execution_count": 212,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Last topic - sorting using Numpy\n",
    "A8 = np.array([['k','l','i','j'],['b','a','d','c'],['h','g','f','e']])\n",
    "np.sort(A8)\n",
    "#Note - default uses axis=1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 213,
   "id": "0a95d7fa",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([['i', 'j', 'k', 'l'],\n",
       "       ['a', 'b', 'c', 'd'],\n",
       "       ['e', 'f', 'g', 'h']], dtype='<U1')"
      ]
     },
     "execution_count": 213,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Sorting by each row\n",
    "np.sort(A8,axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 214,
   "id": "3714f402",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[['k' 'l' 'i' 'j']\n",
      " ['b' 'a' 'd' 'c']\n",
      " ['h' 'g' 'f' 'e']]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([['b', 'a', 'd', 'c'],\n",
       "       ['h', 'g', 'f', 'e'],\n",
       "       ['k', 'l', 'i', 'j']], dtype='<U1')"
      ]
     },
     "execution_count": 214,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Sorting by each column\n",
    "print(A8)\n",
    "np.sort(A8,axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 215,
   "id": "d3b0461c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[2, 3, 0, 1],\n",
       "       [1, 0, 3, 2],\n",
       "       [3, 2, 1, 0]], dtype=int64)"
      ]
     },
     "execution_count": 215,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Related method argsort returns the indices of the sorted elements\n",
    "#Sorting by each row\n",
    "np.argsort(A8,axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 216,
   "id": "5c8f3af4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 1, 1, 1],\n",
       "       [2, 2, 2, 2],\n",
       "       [0, 0, 0, 0]], dtype=int64)"
      ]
     },
     "execution_count": 216,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Sorting by each column\n",
    "np.argsort(A8,axis=0)"
   ]
  }
 ],
 "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.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}