lessons/libs/03_Numpy_Notebook.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"font-family: Arial; font-size:3.75em;color:purple; font-style:bold\"><br>\n",
    "Introduction to numpy:\n",
    "</p><br>\n",
    "\n",
    "<p style=\"font-family: Arial; font-size:1.25em;color:#2462C0; font-style:bold\"><br>\n",
    "Package for scientific computing with Python\n",
    "</p><br>\n",
    "\n",
    "Numerical Python, or \"Numpy\" for short, is a foundational package on which many of the most common data science packages are built.  Numpy provides us with high performance multi-dimensional arrays which we can use as vectors or matrices.  \n",
    "\n",
    "The key features of numpy are:\n",
    "\n",
    "- ndarrays: n-dimensional arrays of the same data type which are fast and space-efficient.  There are a number of built-in methods for ndarrays which allow for rapid processing of data without using loops (e.g., compute the mean).\n",
    "- Broadcasting: a useful tool which defines implicit behavior between multi-dimensional arrays of different sizes.\n",
    "- Vectorization: enables numeric operations on ndarrays.\n",
    "- Input/Output: simplifies reading and writing of data from/to file.\n",
    "\n",
    "<b>Additional Recommended Resources:</b><br>\n",
    "<a href=\"https://docs.scipy.org/doc/numpy/reference/\">Numpy Documentation</a><br>\n",
    "<i>Python for Data Analysis</i> by Wes McKinney<br>\n",
    "<i>Python Data science Handbook</i> by Jake VanderPlas\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"font-family: Arial; font-size:2.75em;color:purple; font-style:bold\"><br>\n",
    "\n",
    "Getting started with ndarray<br><br></p>\n",
    "\n",
    "**ndarrays** are time and space-efficient multidimensional arrays at the core of numpy.  Like the data structures in Week 2, let's get started by creating ndarrays using the numpy package."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"font-family: Arial; font-size:1.75em;color:#2462C0; font-style:bold\"><br>\n",
    "\n",
    "How to create Rank 1 numpy arrays:\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T00:11:30.959062Z",
     "start_time": "2018-10-15T00:11:30.930824Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'numpy.ndarray'>\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "an_array = np.array([3, 33, 333])  # Create a rank 1 array\n",
    "\n",
    "print(type(an_array))              # The type of an ndarray is: \"<class 'numpy.ndarray'>\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T00:11:38.594465Z",
     "start_time": "2018-10-15T00:11:38.573974Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(3,)\n"
     ]
    }
   ],
   "source": [
    "# test the shape of the array we just created, it should have just one dimension (Rank 1)\n",
    "print(an_array.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T00:11:43.246619Z",
     "start_time": "2018-10-15T00:11:43.229499Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3 33 333\n"
     ]
    }
   ],
   "source": [
    "# because this is a 1-rank array, we need only one index to accesss each element\n",
    "print(an_array[0], an_array[1], an_array[2]) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T00:11:45.559420Z",
     "start_time": "2018-10-15T00:11:45.545589Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[888  33 333]\n"
     ]
    }
   ],
   "source": [
    "an_array[0] =888            # ndarrays are mutable, here we change an element of the array\n",
    "\n",
    "print(an_array)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"font-family: Arial; font-size:1.75em;color:#2462C0; font-style:bold\"><br>\n",
    "\n",
    "How to create a Rank 2 numpy array:</p>\n",
    "\n",
    "A rank 2 **ndarray** is one with two dimensions.  Notice the format below of [ [row] , [row] ].  2 dimensional arrays are great for representing matrices which are often useful in data science."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T00:12:32.995657Z",
     "start_time": "2018-10-15T00:12:32.970103Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[11 12 13]\n",
      " [21 22 23]]\n",
      "The shape is 2 rows, 3 columns:  (2, 3)\n",
      "Accessing elements [0,0], [0,1], and [1,0] of the ndarray:  11 ,  12 ,  21\n"
     ]
    }
   ],
   "source": [
    "another = np.array([[11,12,13],[21,22,23]])   # Create a rank 2 array\n",
    "\n",
    "print(another)  # print the array\n",
    "\n",
    "print(\"The shape is 2 rows, 3 columns: \", another.shape)  # rows x columns                   \n",
    "\n",
    "print(\"Accessing elements [0,0], [0,1], and [1,0] of the ndarray: \", another[0, 0], \", \",another[0, 1],\", \", another[1, 0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"font-family: Arial; font-size:1.75em;color:#2462C0; font-style:bold\"><br>\n",
    "\n",
    "There are many way to create numpy arrays:\n",
    "</p>\n",
    "\n",
    "Here we create a number of different size arrays with different shapes and different pre-filled values.  numpy has a number of built in methods which help us quickly and easily create multidimensional arrays."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T00:14:13.844337Z",
     "start_time": "2018-10-15T00:14:13.826846Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0. 0.]\n",
      " [0. 0.]]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "# create a 2x2 array of zeros\n",
    "ex1 = np.zeros((2,2))      \n",
    "print(ex1)                              "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T00:14:21.009649Z",
     "start_time": "2018-10-15T00:14:20.995344Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[9. 9.]\n",
      " [9. 9.]]\n"
     ]
    }
   ],
   "source": [
    "# create a 2x2 array filled with 9.0\n",
    "ex2 = np.full((2,2), 9.0)  \n",
    "print(ex2)   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T00:14:23.652166Z",
     "start_time": "2018-10-15T00:14:23.641132Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1. 0.]\n",
      " [0. 1.]]\n"
     ]
    }
   ],
   "source": [
    "# create a 2x2 matrix with the diagonal 1s and the others 0\n",
    "ex3 = np.eye(2,2)\n",
    "print(ex3)  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T00:14:34.954731Z",
     "start_time": "2018-10-15T00:14:34.939176Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1. 1.]]\n"
     ]
    }
   ],
   "source": [
    "# create an array of ones\n",
    "ex4 = np.ones((1,2))\n",
    "print(ex4)    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T00:18:12.617021Z",
     "start_time": "2018-10-15T00:18:12.605485Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2)\n",
      "\n",
      "1.0\n"
     ]
    }
   ],
   "source": [
    "# notice that the above ndarray (ex4) is actually rank 2, it is a 2x1 array\n",
    "print(ex4.shape)\n",
    "\n",
    "# which means we need to use two indexes to access an element\n",
    "print()\n",
    "print(ex4[0,1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T00:18:21.347702Z",
     "start_time": "2018-10-15T00:18:21.334760Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.62079617 0.43269448]\n",
      " [0.06682533 0.08159367]]\n"
     ]
    }
   ],
   "source": [
    "# create an array of random floats between 0 and 1\n",
    "ex5 = np.random.random((2,2))\n",
    "print(ex5)    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T00:18:52.139087Z",
     "start_time": "2018-10-15T00:18:52.122050Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[6.20796174 4.32694475]\n",
      " [0.66825329 0.81593671]]\n"
     ]
    }
   ],
   "source": [
    "ex5 = ex5 *10\n",
    "print(ex5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"font-family: Arial; font-size:2.75em;color:purple; font-style:bold\"><br>\n",
    "\n",
    "Array Indexing\n",
    "<br><br></p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"font-family: Arial; font-size:1.75em;color:#2462C0; font-style:bold\"><br>\n",
    "Slice indexing:\n",
    "</p>\n",
    "\n",
    "Similar to the use of slice indexing with lists and strings, we can use slice indexing to pull out sub-regions of ndarrays."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T00:19:13.816506Z",
     "start_time": "2018-10-15T00:19:13.805142Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[11 12 13 14]\n",
      " [21 22 23 24]\n",
      " [31 32 33 34]]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "# Rank 2 array of shape (3, 4)\n",
    "an_array = np.array([[11,12,13,14], [21,22,23,24], [31,32,33,34]])\n",
    "print(an_array)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Use array slicing to get a subarray consisting of the first 2 rows x 2 columns."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T00:19:24.654640Z",
     "start_time": "2018-10-15T00:19:24.644086Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[12 13]\n",
      " [22 23]]\n"
     ]
    }
   ],
   "source": [
    "a_slice = an_array[:2, 1:3]\n",
    "print(a_slice)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When you modify a slice, you actually modify the underlying array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T00:19:44.592134Z",
     "start_time": "2018-10-15T00:19:44.584391Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Before: 12\n",
      "After: 1000\n"
     ]
    }
   ],
   "source": [
    "print(\"Before:\", an_array[0, 1])   #inspect the element at 0, 1  \n",
    "a_slice[0, 0] = 1000    # a_slice[0, 0] is the same piece of data as an_array[0, 1]\n",
    "print(\"After:\", an_array[0, 1])    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"font-family: Arial; font-size:1.75em;color:#2462C0; font-style:bold\"><br>\n",
    "\n",
    "Use both integer indexing & slice indexing\n",
    "</p>\n",
    "\n",
    "We can use combinations of integer indexing and slice indexing to create different shaped matrices."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T00:21:03.725174Z",
     "start_time": "2018-10-15T00:21:03.712145Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[11 12 13 14]\n",
      " [21 22 23 24]\n",
      " [31 32 33 34]]\n"
     ]
    }
   ],
   "source": [
    "# Create a Rank 2 array of shape (3, 4)\n",
    "an_array = np.array([[11,12,13,14], [21,22,23,24], [31,32,33,34]])\n",
    "print(an_array)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T00:21:05.583595Z",
     "start_time": "2018-10-15T00:21:05.577598Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[21 22 23 24] (4,)\n"
     ]
    }
   ],
   "source": [
    "# Using both integer indexing & slicing generates an array of lower rank\n",
    "row_rank1 = an_array[1, :]    # Rank 1 view \n",
    "\n",
    "print(row_rank1, row_rank1.shape)  # notice only a single []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T00:21:15.916262Z",
     "start_time": "2018-10-15T00:21:15.908817Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[21 22 23 24]] (1, 4)\n"
     ]
    }
   ],
   "source": [
    "# Slicing alone: generates an array of the same rank as the an_array\n",
    "row_rank2 = an_array[1:2, :]  # Rank 2 view \n",
    "\n",
    "print(row_rank2, row_rank2.shape)   # Notice the [[ ]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T00:22:26.603820Z",
     "start_time": "2018-10-15T00:22:26.594064Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "[12 22 32] (3,)\n",
      "\n",
      "[[12]\n",
      " [22]\n",
      " [32]] (3, 1)\n"
     ]
    }
   ],
   "source": [
    "#We can do the same thing for columns of an array:\n",
    "\n",
    "print()\n",
    "col_rank1 = an_array[:, 1]\n",
    "col_rank2 = an_array[:, 1:2]\n",
    "\n",
    "print(col_rank1, col_rank1.shape)  # Rank 1\n",
    "print()\n",
    "print(col_rank2, col_rank2.shape)  # Rank 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"font-family: Arial; font-size:1.75em;color:#2462C0; font-style:bold\"><br>\n",
    "\n",
    "Array Indexing for changing elements:\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sometimes it's useful to use an array of indexes to access or change elements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T00:23:04.677848Z",
     "start_time": "2018-10-15T00:23:04.668783Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original Array:\n",
      "[[11 12 13]\n",
      " [21 22 23]\n",
      " [31 32 33]\n",
      " [41 42 43]]\n"
     ]
    }
   ],
   "source": [
    "# Create a new array\n",
    "an_array = np.array([[11,12,13], [21,22,23], [31,32,33], [41,42,43]])\n",
    "\n",
    "print('Original Array:')\n",
    "print(an_array)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T00:24:03.297193Z",
     "start_time": "2018-10-15T00:24:03.286381Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Col indices picked :  [0 1 2 0]\n",
      "\n",
      "Rows indices picked :  [0 1 2 3]\n"
     ]
    }
   ],
   "source": [
    "# Create an array of indices\n",
    "col_indices = np.array([0, 1, 2, 0])\n",
    "print('\\nCol indices picked : ', col_indices)\n",
    "\n",
    "row_indices = np.arange(4)\n",
    "print('\\nRows indices picked : ', row_indices)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T00:24:21.590722Z",
     "start_time": "2018-10-15T00:24:21.580018Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 ,  0\n",
      "1 ,  1\n",
      "2 ,  2\n",
      "3 ,  0\n"
     ]
    }
   ],
   "source": [
    "# Examine the pairings of row_indices and col_indices.  These are the elements we'll change next.\n",
    "for row,col in zip(row_indices,col_indices):\n",
    "    print(row, \", \",col)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T00:24:50.256319Z",
     "start_time": "2018-10-15T00:24:50.248649Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Values in the array at those indices:  [11 22 33 41]\n"
     ]
    }
   ],
   "source": [
    "# Select one element from each row\n",
    "print('Values in the array at those indices: ',an_array[row_indices, col_indices])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T00:25:41.143121Z",
     "start_time": "2018-10-15T00:25:41.129206Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Changed Array:\n",
      "[[100011     12     13]\n",
      " [    21 100022     23]\n",
      " [    31     32 100033]\n",
      " [100041     42     43]]\n"
     ]
    }
   ],
   "source": [
    "# Change one element from each row using the indices selected\n",
    "an_array[row_indices, col_indices] += 100000\n",
    "\n",
    "print('\\nChanged Array:')\n",
    "print(an_array)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"font-family: Arial; font-size:2.75em;color:purple; font-style:bold\"><br>\n",
    "Boolean Indexing\n",
    "\n",
    "<br><br></p>\n",
    "<p style=\"font-family: Arial; font-size:1.75em;color:#2462C0; font-style:bold\"><br>\n",
    "\n",
    "Array Indexing for changing elements:\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T00:25:54.195922Z",
     "start_time": "2018-10-15T00:25:54.189934Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[11 12]\n",
      " [21 22]\n",
      " [31 32]]\n"
     ]
    }
   ],
   "source": [
    "# create a 3x2 array\n",
    "an_array = np.array([[11,12], [21, 22], [31, 32]])\n",
    "print(an_array)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T00:25:59.570092Z",
     "start_time": "2018-10-15T00:25:59.545320Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[False, False],\n",
       "       [ True,  True],\n",
       "       [ True,  True]])"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# create a filter which will be boolean values for whether each element meets this condition\n",
    "filter = (an_array > 15)\n",
    "filter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T00:26:59.036102Z",
     "start_time": "2018-10-15T00:26:59.031007Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[False, False],\n",
       "       [ True,  True],\n",
       "       [ True,  True]])"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "filter = an_array > 15\n",
    "filter"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that the filter is a same size ndarray as an_array which is filled with True for each element whose corresponding element in an_array which is greater than 15 and False for those elements whose value is less than 15."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T00:27:06.324565Z",
     "start_time": "2018-10-15T00:27:06.318989Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[21 22 31 32]\n"
     ]
    }
   ],
   "source": [
    "# we can now select just those elements which meet that criteria\n",
    "print(an_array[filter])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T00:28:01.599098Z",
     "start_time": "2018-10-15T00:28:01.582306Z"
    },
    "code_folding": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([12, 22, 32])"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# For short, we could have just used the approach below without the need for the separate filter array.\n",
    "\n",
    "an_array[(an_array % 2 == 0)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What is particularly useful is that we can actually change elements in the array applying a similar logical filter.  Let's add 100 to all the even values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T00:28:50.526225Z",
     "start_time": "2018-10-15T00:28:50.514794Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 11 112]\n",
      " [ 21 122]\n",
      " [ 31 132]]\n"
     ]
    }
   ],
   "source": [
    "an_array[an_array % 2 == 0] +=100\n",
    "print(an_array)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"font-family: Arial; font-size:2.75em;color:purple; font-style:bold\"><br>\n",
    "\n",
    "Datatypes and Array Operations\n",
    "<br><br></p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"font-family: Arial; font-size:1.75em;color:#2462C0; font-style:bold\"><br>\n",
    "\n",
    "Datatypes:\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T00:29:00.246339Z",
     "start_time": "2018-10-15T00:29:00.242183Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "int64\n"
     ]
    }
   ],
   "source": [
    "ex1 = np.array([11, 12]) # Python assigns the  data type\n",
    "print(ex1.dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T00:29:12.134716Z",
     "start_time": "2018-10-15T00:29:12.125141Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "float64\n"
     ]
    }
   ],
   "source": [
    "ex2 = np.array([11.0, 12.0]) # Python assigns the  data type\n",
    "print(ex2.dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T00:31:57.928458Z",
     "start_time": "2018-10-15T00:31:57.918671Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "int64\n",
      "[11 21]\n"
     ]
    }
   ],
   "source": [
    "ex3 = np.array([11, 21], dtype=np.int64) #You can also tell Python the  data type\n",
    "print(ex3.dtype)\n",
    "print(ex3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T00:32:10.455385Z",
     "start_time": "2018-10-15T00:32:10.447842Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "int64\n",
      "\n",
      "[11 12]\n"
     ]
    }
   ],
   "source": [
    "# you can use this to force floats into integers (using floor function)\n",
    "ex4 = np.array([11.1,12.7], dtype=np.int64)\n",
    "print(ex4.dtype)\n",
    "print()\n",
    "print(ex4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T00:32:16.787449Z",
     "start_time": "2018-10-15T00:32:16.776631Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "float64\n",
      "\n",
      "[11. 21.]\n"
     ]
    }
   ],
   "source": [
    "# you can use this to force integers into floats if you anticipate\n",
    "# the values may change to floats later\n",
    "ex5 = np.array([11, 21], dtype=np.float64)\n",
    "print(ex5.dtype)\n",
    "print()\n",
    "print(ex5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"font-family: Arial; font-size:1.75em;color:#2462C0; font-style:bold\"><br>\n",
    "\n",
    "Arithmetic Array Operations:\n",
    "\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T00:32:28.412719Z",
     "start_time": "2018-10-15T00:32:28.392523Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[111 112]\n",
      " [121 122]]\n",
      "\n",
      "[[211.1 212.1]\n",
      " [221.1 222.1]]\n"
     ]
    }
   ],
   "source": [
    "x = np.array([[111,112],[121,122]], dtype=np.int)\n",
    "y = np.array([[211.1,212.1],[221.1,222.1]], dtype=np.float64)\n",
    "\n",
    "print(x)\n",
    "print()\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T00:32:29.835004Z",
     "start_time": "2018-10-15T00:32:29.823662Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[322.1 324.1]\n",
      " [342.1 344.1]]\n",
      "\n",
      "[[322.1 324.1]\n",
      " [342.1 344.1]]\n"
     ]
    }
   ],
   "source": [
    "# add\n",
    "print(x + y)         # The plus sign works\n",
    "print()\n",
    "print(np.add(x, y))  # so does the numpy function \"add\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T00:32:53.815061Z",
     "start_time": "2018-10-15T00:32:53.805226Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-100.1 -100.1]\n",
      " [-100.1 -100.1]]\n",
      "\n",
      "[[-100.1 -100.1]\n",
      " [-100.1 -100.1]]\n"
     ]
    }
   ],
   "source": [
    "# subtract\n",
    "print(x - y)\n",
    "print()\n",
    "print(np.subtract(x, y))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T00:32:58.028470Z",
     "start_time": "2018-10-15T00:32:58.018517Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[23432.1 23755.2]\n",
      " [26753.1 27096.2]]\n",
      "\n",
      "[[23432.1 23755.2]\n",
      " [26753.1 27096.2]]\n"
     ]
    }
   ],
   "source": [
    "# multiply\n",
    "print(x * y)\n",
    "print()\n",
    "print(np.multiply(x, y))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T00:33:10.937482Z",
     "start_time": "2018-10-15T00:33:10.924828Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.52581715 0.52805281]\n",
      " [0.54726368 0.54930212]]\n",
      "\n",
      "[[0.52581715 0.52805281]\n",
      " [0.54726368 0.54930212]]\n"
     ]
    }
   ],
   "source": [
    "# divide\n",
    "print(x / y)\n",
    "print()\n",
    "print(np.divide(x, y))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T00:33:19.526659Z",
     "start_time": "2018-10-15T00:33:19.518167Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[10.53565375 10.58300524]\n",
      " [11.         11.04536102]]\n"
     ]
    }
   ],
   "source": [
    "# square root\n",
    "print(np.sqrt(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T00:33:19.786716Z",
     "start_time": "2018-10-15T00:33:19.780381Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1.60948707e+48 4.37503945e+48]\n",
      " [3.54513118e+52 9.63666567e+52]]\n"
     ]
    }
   ],
   "source": [
    "# exponent (e ** x)\n",
    "print(np.exp(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"font-family: Arial; font-size:2.75em;color:purple; font-style:bold\"><br>\n",
    "\n",
    "Statistical Methods, Sorting, and <br> <br> Set Operations:\n",
    "<br><br>\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"font-family: Arial; font-size:1.75em;color:#2462C0; font-style:bold\"><br>\n",
    "\n",
    "Basic Statistical Operations:\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T00:33:34.787505Z",
     "start_time": "2018-10-15T00:33:34.779443Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[  4.91297588  13.18587698  -7.44064566  -0.33323465 -17.84142168]\n",
      " [-13.22501513   6.56593959  15.31977174 -21.00703609 -23.97523053]]\n"
     ]
    }
   ],
   "source": [
    "# setup a random 2 x 4 matrix\n",
    "arr = 10 * np.random.randn(2,5)\n",
    "print(arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T00:34:15.103253Z",
     "start_time": "2018-10-15T00:34:15.098495Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-4.383801955038625\n"
     ]
    }
   ],
   "source": [
    "# compute the mean for all elements\n",
    "print(arr.mean())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T00:34:27.825068Z",
     "start_time": "2018-10-15T00:34:27.819866Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-1.50328983 -7.26431408]\n"
     ]
    }
   ],
   "source": [
    "# compute the means by row\n",
    "print(arr.mean(axis = 1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T00:34:38.571317Z",
     "start_time": "2018-10-15T00:34:38.548093Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ -4.15601962   9.87590829   3.93956304 -10.67013537 -20.9083261 ]\n"
     ]
    }
   ],
   "source": [
    "# compute the means by column\n",
    "print(arr.mean(axis = 0))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T00:35:07.331201Z",
     "start_time": "2018-10-15T00:35:07.325631Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-43.83801955038625\n"
     ]
    }
   ],
   "source": [
    "# sum all the elements\n",
    "print(arr.sum())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T00:35:07.648722Z",
     "start_time": "2018-10-15T00:35:07.638590Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ -0.33323465 -13.22501513]\n"
     ]
    }
   ],
   "source": [
    "# compute the medians\n",
    "print(np.median(arr, axis = 1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"font-family: Arial; font-size:1.75em;color:#2462C0; font-style:bold\"><br>\n",
    "\n",
    "Sorting:\n",
    "</p>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T00:35:13.494185Z",
     "start_time": "2018-10-15T00:35:13.479130Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 2.28877355  0.77739235  0.28801779 -0.40145856 -1.28204384  0.54761558\n",
      " -0.28681476 -0.6967186  -0.65480103  0.77166096]\n"
     ]
    }
   ],
   "source": [
    "# create a 10 element array of randoms\n",
    "unsorted = np.random.randn(10)\n",
    "\n",
    "print(unsorted)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T00:35:15.795548Z",
     "start_time": "2018-10-15T00:35:15.780349Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-1.28204384 -0.6967186  -0.65480103 -0.40145856 -0.28681476  0.28801779\n",
      "  0.54761558  0.77166096  0.77739235  2.28877355]\n",
      "\n",
      "[ 2.28877355  0.77739235  0.28801779 -0.40145856 -1.28204384  0.54761558\n",
      " -0.28681476 -0.6967186  -0.65480103  0.77166096]\n"
     ]
    }
   ],
   "source": [
    "# create copy and sort\n",
    "sorted = np.array(unsorted)\n",
    "sorted.sort()\n",
    "\n",
    "print(sorted)\n",
    "print()\n",
    "print(unsorted)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T00:35:54.377650Z",
     "start_time": "2018-10-15T00:35:54.369701Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-1.28204384 -0.6967186  -0.65480103 -0.40145856 -0.28681476  0.28801779\n",
      "  0.54761558  0.77166096  0.77739235  2.28877355]\n"
     ]
    }
   ],
   "source": [
    "# inplace sorting\n",
    "unsorted.sort() \n",
    "\n",
    "print(unsorted)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"font-family: Arial; font-size:1.75em;color:#2462C0; font-style:bold\"><br>\n",
    "\n",
    "Finding Unique elements:\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T00:36:47.589489Z",
     "start_time": "2018-10-15T00:36:47.581315Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 4]\n"
     ]
    }
   ],
   "source": [
    "array = np.array([1,2,1,4,2,1,4,2])\n",
    "\n",
    "print(np.unique(array))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"font-family: Arial; font-size:1.75em;color:#2462C0; font-style:bold\"><br>\n",
    "\n",
    "Set Operations with np.array data type:\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T00:36:52.409201Z",
     "start_time": "2018-10-15T00:36:52.399852Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['desk' 'chair' 'bulb'] ['lamp' 'bulb' 'chair']\n"
     ]
    }
   ],
   "source": [
    "s1 = np.array(['desk','chair','bulb'])\n",
    "s2 = np.array(['lamp','bulb','chair'])\n",
    "print(s1, s2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T00:36:59.119899Z",
     "start_time": "2018-10-15T00:36:59.115022Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['bulb' 'chair']\n"
     ]
    }
   ],
   "source": [
    "print( np.intersect1d(s1, s2) ) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T00:37:09.947806Z",
     "start_time": "2018-10-15T00:37:09.937521Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['bulb' 'chair' 'desk' 'lamp']\n"
     ]
    }
   ],
   "source": [
    "print( np.union1d(s1, s2) )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T00:37:21.155380Z",
     "start_time": "2018-10-15T00:37:21.150243Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['desk']\n"
     ]
    }
   ],
   "source": [
    "print( np.setdiff1d(s1, s2) )# elements in s1 that are not in s2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T00:37:22.086937Z",
     "start_time": "2018-10-15T00:37:22.080663Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[False  True  True]\n"
     ]
    }
   ],
   "source": [
    "print( np.in1d(s1, s2) )#which element of s1 is also in s2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"font-family: Arial; font-size:2.75em;color:purple; font-style:bold\"><br>\n",
    "\n",
    "Broadcasting:\n",
    "<br><br>\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Introduction to broadcasting. <br>\n",
    "For more details, please see: <br>\n",
    "https://docs.scipy.org/doc/numpy-1.10.1/user/basics.broadcasting.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T00:37:42.116284Z",
     "start_time": "2018-10-15T00:37:42.106213Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0. 0. 0.]\n",
      " [0. 0. 0.]\n",
      " [0. 0. 0.]\n",
      " [0. 0. 0.]]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "start = np.zeros((4,3))\n",
    "print(start)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T00:37:43.875516Z",
     "start_time": "2018-10-15T00:37:43.867886Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 0 2]\n"
     ]
    }
   ],
   "source": [
    "# create a rank 1 ndarray with 3 values\n",
    "add_rows = np.array([1, 0, 2])\n",
    "print(add_rows)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T00:37:47.408226Z",
     "start_time": "2018-10-15T00:37:47.402211Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1. 0. 2.]\n",
      " [1. 0. 2.]\n",
      " [1. 0. 2.]\n",
      " [1. 0. 2.]]\n"
     ]
    }
   ],
   "source": [
    "y = start + add_rows  # add to each row of 'start' using broadcasting\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T00:37:51.757248Z",
     "start_time": "2018-10-15T00:37:51.739277Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0]\n",
      " [1]\n",
      " [2]\n",
      " [3]]\n"
     ]
    }
   ],
   "source": [
    "# create an ndarray which is 4 x 1 to broadcast across columns\n",
    "add_cols = np.array([[0,1,2,3]])\n",
    "add_cols = add_cols.T\n",
    "\n",
    "print(add_cols)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T00:37:58.446794Z",
     "start_time": "2018-10-15T00:37:58.438111Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0. 0. 0.]\n",
      " [1. 1. 1.]\n",
      " [2. 2. 2.]\n",
      " [3. 3. 3.]]\n"
     ]
    }
   ],
   "source": [
    "# add to each column of 'start' using broadcasting\n",
    "y = start + add_cols \n",
    "print(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T00:38:20.400658Z",
     "start_time": "2018-10-15T00:38:20.391198Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1. 1. 1.]\n",
      " [1. 1. 1.]\n",
      " [1. 1. 1.]\n",
      " [1. 1. 1.]]\n"
     ]
    }
   ],
   "source": [
    "# this will just broadcast in both dimensions\n",
    "add_scalar = np.array([1])  \n",
    "print(start+add_scalar)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Example from the slides:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T00:38:24.231311Z",
     "start_time": "2018-10-15T00:38:24.224875Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1  2  3  4]\n",
      " [ 5  6  7  8]\n",
      " [ 9 10 11 12]]\n"
     ]
    }
   ],
   "source": [
    "# create our 3x4 matrix\n",
    "arrA = np.array([[1,2,3,4],[5,6,7,8],[9,10,11,12]])\n",
    "print(arrA)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T00:38:34.855932Z",
     "start_time": "2018-10-15T00:38:34.847773Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 0, 2]\n"
     ]
    }
   ],
   "source": [
    "# create our 4x1 array\n",
    "arrB = [0,1,0,2]\n",
    "print(arrB)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T00:38:42.346323Z",
     "start_time": "2018-10-15T00:38:42.335883Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1  3  3  6]\n",
      " [ 5  7  7 10]\n",
      " [ 9 11 11 14]]\n"
     ]
    }
   ],
   "source": [
    "# add the two together using broadcasting\n",
    "print(arrA + arrB)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"font-family: Arial; font-size:2.75em;color:purple; font-style:bold\"><br>\n",
    "\n",
    "Speedtest: ndarrays vs lists\n",
    "<br><br>\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First setup paramaters for the speed test. We'll be testing time to sum elements in an ndarray versus a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T00:39:03.888123Z",
     "start_time": "2018-10-15T00:39:03.868431Z"
    }
   },
   "outputs": [],
   "source": [
    "from numpy import arange\n",
    "from timeit import Timer\n",
    "\n",
    "size    = 1000000\n",
    "timeits = 1000"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T00:39:40.618404Z",
     "start_time": "2018-10-15T00:39:40.605190Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'numpy.ndarray'>\n"
     ]
    }
   ],
   "source": [
    "# create the ndarray with values 0,1,2...,size-1\n",
    "nd_array = arange(size)\n",
    "print( type(nd_array) )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T00:41:10.386894Z",
     "start_time": "2018-10-15T00:41:09.227349Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Time taken by numpy ndarray: 0.001154 seconds\n"
     ]
    }
   ],
   "source": [
    "# timer expects the operation as a parameter, \n",
    "# here we pass nd_array.sum()\n",
    "timer_numpy = Timer(\"nd_array.sum()\", \"from __main__ import nd_array\")\n",
    "\n",
    "print(\"Time taken by numpy ndarray: %f seconds\" % \n",
    "      (timer_numpy.timeit(timeits)/timeits))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T00:41:13.541568Z",
     "start_time": "2018-10-15T00:41:13.473443Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'list'>\n"
     ]
    }
   ],
   "source": [
    "# create the list with values 0,1,2...,size-1\n",
    "a_list = list(range(size))\n",
    "print (type(a_list) )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T00:41:31.266301Z",
     "start_time": "2018-10-15T00:41:17.440426Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Time taken by list:  0.013816 seconds\n"
     ]
    }
   ],
   "source": [
    "# timer expects the operation as a parameter, here we pass sum(a_list)\n",
    "timer_list = Timer(\"sum(a_list)\", \"from __main__ import a_list\")\n",
    "\n",
    "print(\"Time taken by list:  %f seconds\" % \n",
    "      (timer_list.timeit(timeits)/timeits))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"font-family: Arial; font-size:2.75em;color:purple; font-style:bold\"><br>\n",
    "\n",
    "Read or Write to Disk:\n",
    "<br><br>\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"font-family: Arial; font-size:1.3em;color:#2462C0; font-style:bold\"><br>\n",
    "\n",
    "Binary Format:</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T00:41:39.495116Z",
     "start_time": "2018-10-15T00:41:39.491028Z"
    }
   },
   "outputs": [],
   "source": [
    "x = np.array([ 23.23, 24.24] )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T00:41:41.257442Z",
     "start_time": "2018-10-15T00:41:41.249602Z"
    }
   },
   "outputs": [],
   "source": [
    "np.save('an_array', x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T00:41:45.461652Z",
     "start_time": "2018-10-15T00:41:45.451588Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([23.23, 24.24])"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.load('an_array.npy')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"font-family: Arial; font-size:1.3em;color:#2462C0; font-style:bold\"><br>\n",
    "\n",
    "Text Format:</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T00:42:34.488723Z",
     "start_time": "2018-10-15T00:42:34.481465Z"
    }
   },
   "outputs": [],
   "source": [
    "np.savetxt('array.txt', X=x, delimiter=',')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T00:42:35.557684Z",
     "start_time": "2018-10-15T00:42:35.120739Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.323000000000000043e+01\r\n",
      "2.423999999999999844e+01\r\n"
     ]
    }
   ],
   "source": [
    "!cat array.txt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T00:42:36.042612Z",
     "start_time": "2018-10-15T00:42:36.029904Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([23.23, 24.24])"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.loadtxt('array.txt', delimiter=',')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"font-family: Arial; font-size:2.75em;color:purple; font-style:bold\"><br>\n",
    "\n",
    "Additional Common ndarray Operations\n",
    "<br><br></p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"font-family: Arial; font-size:1.75em;color:#2462C0; font-style:bold\"><br>\n",
    "\n",
    "Dot Product on Matrices and Inner Product on Vectors:\n",
    "\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T00:44:27.725918Z",
     "start_time": "2018-10-15T00:44:27.710489Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[4 4]\n",
      " [4 4]]\n",
      "\n",
      "[[4 4]\n",
      " [4 4]]\n"
     ]
    }
   ],
   "source": [
    "# determine the dot product of two matrices\n",
    "x2d = np.array([[1,1],[1,1]])\n",
    "y2d = np.array([[2,2],[2,2]])\n",
    "\n",
    "print(x2d.dot(y2d))\n",
    "print()\n",
    "print(np.dot(x2d, y2d))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T00:44:30.196257Z",
     "start_time": "2018-10-15T00:44:30.176072Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "180\n",
      "\n",
      "180\n"
     ]
    }
   ],
   "source": [
    "# determine the inner product of two vectors\n",
    "a1d = np.array([9 , 9 ])\n",
    "b1d = np.array([10, 10])\n",
    "\n",
    "print(a1d.dot(b1d))\n",
    "print()\n",
    "print(np.dot(a1d, b1d))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T00:55:10.712209Z",
     "start_time": "2018-10-15T00:55:10.698868Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[18 18]\n",
      "\n",
      "[18 18]\n"
     ]
    }
   ],
   "source": [
    "# dot produce on an array and vector\n",
    "print(x2d.dot(a1d))\n",
    "print()\n",
    "print(np.dot(x2d, a1d))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"font-family: Arial; font-size:1.75em;color:#2462C0; font-style:bold\"><br>\n",
    "\n",
    "Sum:\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T00:55:13.011801Z",
     "start_time": "2018-10-15T00:55:12.998849Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "66\n"
     ]
    }
   ],
   "source": [
    "# sum elements in the array\n",
    "ex1 = np.array([[11,12],[21,22]])\n",
    "\n",
    "print(np.sum(ex1))          # add all members"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T00:55:13.663930Z",
     "start_time": "2018-10-15T00:55:13.652674Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[32 34]\n"
     ]
    }
   ],
   "source": [
    "print(np.sum(ex1, axis=0))  # columnwise sum"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T00:55:31.725971Z",
     "start_time": "2018-10-15T00:55:31.719202Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[23 43]\n"
     ]
    }
   ],
   "source": [
    "print(np.sum(ex1, axis=1))  # rowwise sum"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"font-family: Arial; font-size:1.75em;color:#2462C0; font-style:bold\"><br>\n",
    "\n",
    "Element-wise Functions: </p>\n",
    "\n",
    "For example, let's compare two arrays values to get the maximum of each."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T00:55:37.951387Z",
     "start_time": "2018-10-15T00:55:37.938584Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1.32023427, -0.49535993,  0.51381933,  1.42406093, -0.12423443,\n",
       "        1.48228654,  1.28980404,  0.69907384])"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# random array\n",
    "x = np.random.randn(8)\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T00:55:38.519207Z",
     "start_time": "2018-10-15T00:55:38.508194Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.34623504,  0.55712212, -0.43995983, -0.51044479, -1.88693066,\n",
       "        0.65471517,  1.86681241, -0.94212086])"
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# another random array\n",
    "y = np.random.randn(8)\n",
    "y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T00:55:41.804302Z",
     "start_time": "2018-10-15T00:55:41.795382Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1.32023427,  0.55712212,  0.51381933,  1.42406093, -0.12423443,\n",
       "        1.48228654,  1.86681241,  0.69907384])"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# returns element wise maximum between two arrays\n",
    "\n",
    "np.maximum(x, y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"font-family: Arial; font-size:1.75em;color:#2462C0; font-style:bold\"><br>\n",
    "\n",
    "Reshaping array:\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T00:55:49.645452Z",
     "start_time": "2018-10-15T00:55:49.638783Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19]\n"
     ]
    }
   ],
   "source": [
    "# grab values from 0 through 19 in an array\n",
    "arr = np.arange(20)\n",
    "print(arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T00:55:51.283573Z",
     "start_time": "2018-10-15T00:55:51.266863Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3,  4],\n",
       "       [ 5,  6,  7,  8,  9],\n",
       "       [10, 11, 12, 13, 14],\n",
       "       [15, 16, 17, 18, 19]])"
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# reshape to be a 4 x 5 matrix\n",
    "arr.reshape(4,5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"font-family: Arial; font-size:1.75em;color:#2462C0; font-style:bold\"><br>\n",
    "\n",
    "Transpose:\n",
    "\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T00:55:55.597186Z",
     "start_time": "2018-10-15T00:55:55.588204Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[11, 21],\n",
       "       [12, 22]])"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# transpose\n",
    "ex1 = np.array([[11,12],[21,22]])\n",
    "\n",
    "ex1.T"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"font-family: Arial; font-size:1.75em;color:#2462C0; font-style:bold\"><br>\n",
    "\n",
    "Indexing using where():</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T00:56:08.234475Z",
     "start_time": "2018-10-15T00:56:08.222397Z"
    }
   },
   "outputs": [],
   "source": [
    "x_1 = np.array([1,2,3,4,5])\n",
    "\n",
    "y_1 = np.array([11,22,33,44,55])\n",
    "\n",
    "filter = np.array([True, False, True, False, True])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T00:56:16.892078Z",
     "start_time": "2018-10-15T00:56:16.884234Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 1 22  3 44  5]\n"
     ]
    }
   ],
   "source": [
    "out = np.where(filter, x_1, y_1)\n",
    "print(out)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T00:56:51.270861Z",
     "start_time": "2018-10-15T00:56:51.254720Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.83216169, 0.92566762, 0.71429304, 0.78816526, 0.6561042 ],\n",
       "       [0.498693  , 0.75168868, 0.47453328, 0.51664945, 0.33333213],\n",
       "       [0.28151353, 0.32225807, 0.70239189, 0.73936465, 0.51438595],\n",
       "       [0.8226812 , 0.64427991, 0.34622575, 0.06283342, 0.01011396],\n",
       "       [0.39238191, 0.22309829, 0.0343571 , 0.79653874, 0.39554263]])"
      ]
     },
     "execution_count": 107,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mat = np.random.rand(5,5)\n",
    "mat"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T00:56:54.705484Z",
     "start_time": "2018-10-15T00:56:54.694160Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1000, 1000, 1000, 1000, 1000],\n",
       "       [  -1, 1000,   -1, 1000,   -1],\n",
       "       [  -1,   -1, 1000, 1000, 1000],\n",
       "       [1000, 1000,   -1,   -1,   -1],\n",
       "       [  -1,   -1,   -1, 1000,   -1]])"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.where( mat > 0.5, 1000, -1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"font-family: Arial; font-size:1.75em;color:#2462C0; font-style:bold\"><br>\n",
    "\n",
    "\"any\" or \"all\" conditionals:</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T00:57:37.774020Z",
     "start_time": "2018-10-15T00:57:37.763144Z"
    }
   },
   "outputs": [],
   "source": [
    "arr_bools = np.array([ True, False, True, True, False ])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T00:57:38.894179Z",
     "start_time": "2018-10-15T00:57:38.883458Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr_bools.any()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T00:57:40.362551Z",
     "start_time": "2018-10-15T00:57:40.355641Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 111,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr_bools.all()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"font-family: Arial; font-size:1.75em;color:#2462C0; font-style:bold\"><br>\n",
    "\n",
    "Random Number Generation:\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T00:58:14.408632Z",
     "start_time": "2018-10-15T00:58:14.399548Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 0.91480658 -1.23201039  1.64833128 -1.3554101   0.08280138]\n"
     ]
    }
   ],
   "source": [
    "Y = np.random.normal(size = (1,5))[0]\n",
    "print(Y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T00:58:43.153237Z",
     "start_time": "2018-10-15T00:58:43.137191Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[47  4 19 48]\n"
     ]
    }
   ],
   "source": [
    "Z = np.random.randint(low=2,high=50,size=4)\n",
    "print(Z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T00:59:00.750687Z",
     "start_time": "2018-10-15T00:59:00.739448Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([19,  4, 47, 48])"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.permutation(Z) #return a new ordering of elements in Z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T00:59:09.486217Z",
     "start_time": "2018-10-15T00:59:09.458888Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.72812102, 0.60855963, 0.31202846, 0.90243536])"
      ]
     },
     "execution_count": 116,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.uniform(size=4) #uniform distribution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T00:59:55.595077Z",
     "start_time": "2018-10-15T00:59:55.586276Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 2.44260177, -0.31626096,  1.8328664 ,  0.5086996 ])"
      ]
     },
     "execution_count": 117,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.normal(size=4) #normal distribution"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"font-family: Arial; font-size:1.75em;color:#2462C0; font-style:bold\"><br>\n",
    "\n",
    "Merging data sets:\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T01:00:53.779887Z",
     "start_time": "2018-10-15T01:00:53.750720Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[24 12]\n",
      " [ 8 33]]\n",
      "\n",
      "[[40 12]\n",
      " [31 42]]\n"
     ]
    }
   ],
   "source": [
    "K = np.random.randint(low=2,high=50,size=(2,2))\n",
    "print(K)\n",
    "\n",
    "print()\n",
    "M = np.random.randint(low=2,high=50,size=(2,2))\n",
    "print(M)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T01:01:08.923900Z",
     "start_time": "2018-10-15T01:01:08.913105Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[24, 12],\n",
       "       [ 8, 33],\n",
       "       [40, 12],\n",
       "       [31, 42]])"
      ]
     },
     "execution_count": 119,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.vstack((K,M))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T01:01:18.230679Z",
     "start_time": "2018-10-15T01:01:18.220583Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[24, 12, 40, 12],\n",
       "       [ 8, 33, 31, 42]])"
      ]
     },
     "execution_count": 120,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.hstack((K,M))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T01:01:25.750215Z",
     "start_time": "2018-10-15T01:01:25.743044Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[24, 12],\n",
       "       [ 8, 33],\n",
       "       [40, 12],\n",
       "       [31, 42]])"
      ]
     },
     "execution_count": 121,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.concatenate([K, M], axis = 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T01:02:29.205176Z",
     "start_time": "2018-10-15T01:02:29.185383Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[24, 12, 40, 31],\n",
       "       [ 8, 33, 12, 42]])"
      ]
     },
     "execution_count": 122,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.concatenate([K, M.T], axis = 1)"
   ]
  },
  {
   "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.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
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}