You do the maths! an introduction to Numpy and Scipy.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# You Do the Maths With Numpy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Part 1: an introduction to the numpy array"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### What we already know\n",
    "- basic data types (ints, floats, strings, booleans)\n",
    "- Some functions and methods to manipulate these data types (i.e. type(), len(), str.upper())\n",
    "- where to put our data (Variables, Lists, Dictionaries\n",
    "- and how to manipulate and build these variables and lists\n",
    "- How to create, store, and use data in a dictionary\n",
    "- Use conditional statements to allow the computer to choose when to execute certain commands\n",
    "- use loops so that the computer can repeat the brilliant code you have written for it\n",
    "- Made your own functions!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "__Learning Objectives__:\n",
    "\n",
    "- learn how to use Numpy, and it's Flagship Product, the Numpy Array!\n",
    "    - Find out that it works a lot like a list\n",
    "    - It just happens to follow a few more rules\n",
    "- Learn how to slice and index numpy Arrays\n",
    "- Learn how to build multidimensional Arrays\n",
    "- Learn how Numpy adds arrays of different shapes via Broadcasting\n",
    "- Google some Numpy Methods\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Lists are kind of like excel columns Right? \n",
    "Wouldn't it be nice to just add the elements of our lists together?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# lets just add these two guys together\n",
    "xs = [1,2,3,4,5]\n",
    "ys = [100,200,300,400,500]\n",
    "xs+ys"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "uh oh! looks like + just means append the two lists together in python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "\"kind of \"+\"like\"+\" strings!\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "** We could use a for loop **"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "xs = [1,2,3,4,5]\n",
    "ys = [100,200,300,400,500]\n",
    "zs = []\n",
    "for x in range(len(xs)-1):\n",
    "    z = xs[x]+ys[x]\n",
    "    zs.append(z)\n",
    "    \n",
    "print(zs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "#or a one liner list comprehension\n",
    "z = [x+y for x, y in zip(xs,ys)]\n",
    "z"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "#### Opinion: I find that bloody annoying, and not as easy to read as a + b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- and since Python is just as much about readibility and ease\n",
    "- Much smarter people than I have invented numpy to make Python Maths Great again!!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "\n",
    "import numpy as np # Note the as np part means I have given this package a nickname"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Introducing the numpy Array"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The numpy.array() method coerces a data object into a numpy array, you can chuck a list in there to get a numpy array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "xar = np.array(xs)\n",
    "yar = np.array(ys)\n",
    "\n",
    "zar = xar+yar\n",
    "\n",
    "zar"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Numpy arrays are Python's package for doing vectorized mathematics and operations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Vector** is just an ordered stack of numbers to crunch, where as base Python can only do math with ** Scalars** or individual Numbers"
   ]
  },
  {
   "attachments": {
    "image.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![image.png](attachment:image.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**However,** numpy arrays have more rules to live by, i.e. they really need all of the same data type to be useful"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "\n",
    "test = [1,2,'3']\n",
    "test_ar = np.array(test)\n",
    "\n",
    "print('type for item 0 = ', type(test_ar[0]), 'however in the list it is still a',type(test[0]))\n",
    "print('type for item 2 = ', type(test_ar[2]),'however in the list it is still a',type(test[2]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Numpy Arrays have lots of bells and whistles, but the cost is that they must follow some more rules than a list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "** Pros**: \n",
    "- Element wise mathematics\n",
    "- Multiple Dimensions\n",
    "- smaller data file sizes usually\n",
    "\n",
    "\n",
    "** Cons **\n",
    "- Entries are coerced into one datatype\n",
    "- not  as flexible as a List\n",
    "- Numpy has its own brand of numbers and string data types, I recommend coercing everything into a numpy data type to avoid problems"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Numpy Data Types\n",
    "- int32, int64\n",
    "- float32, float64\n",
    "- np.str"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# we can force this data type to be numbers, and umpy will successfully coerce it into being a number,hurray!!\n",
    "test = [1,2,'3']\n",
    "test_ar = np.array(test, dtype = np.int64)\n",
    "type(test_ar[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "** Making of a numpy  Array**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#from a list\n",
    "a_ar = np.array([1,2,3,4])\n",
    "print('list to array', a_ar)\n",
    "#from a myriad of array generating functions in Numpy\n",
    "\n",
    "nil_ar = np.zeros(4)\n",
    "print('array of emu eggs',nil_ar, 'of shape %i and data type' %(nil_ar.shape), nil_ar.dtype)\n",
    "\n",
    "range_ar =np.arange(3,13,3)\n",
    "print('numpys version of a range with a spacing of 3',range_ar)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "** Just like lists**\n",
    "- They are mutable\n",
    "- iterable\n",
    "- indexible\n",
    "- and need to be copied properly!!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#making a new nickname for \n",
    "nil_copy = nil_ar\n",
    "\n",
    "#making an actual copy\n",
    "nil_real_copy = nil_ar.copy()\n",
    "\n",
    "nil_ar[0] = 2\n",
    "\n",
    "for nils in nil_ar:\n",
    "    if nils >0:\n",
    "        print(nils)\n",
    "\n",
    "print('original array',nil_ar)\n",
    "print('fake copy',nil_copy)\n",
    "print('real copy',nil_real_copy)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**And...** you can  slice it up just like a list, the result of each slice is a numpy array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "\n",
    "range_ar[:-1]-a_ar[0:-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### with improved slicing\n",
    "- via start:stop:step"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_range = np.arange(20)\n",
    "print('full array', test_range)\n",
    "print('every third element between the 1st and the 15th elements:', test_range[4:15:3])\n",
    "print('stepping through the entire vector every 5th element', test_range[::5])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### You can even \"slice\" with a list of indices\n",
    "\n",
    "array[[1,2,8,9]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(' full range', test_range)\n",
    "print('3rd, 7th, 11th, 13th, and 17th elements selected', test_range[[3,7,11,13,17]])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Now lets show how they are not like lists:\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### our first multidimensional array hurray!\n",
    "- THis is great for gridded data (i.e. digital photographs, GIS rasters and LiDAR data etc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# kind of like nested lists\n",
    "\n",
    "nest = [[1,2,3],[4,5,6],[7,8,9]]\n",
    "print(nest[1][2])\n",
    "\n",
    "nest_array = np.array(nest)\n",
    "print(nest_array[1,2])\n",
    "print(nest_array.shape, 'is the shape of the array')\n",
    "nest_array"
   ]
  },
  {
   "attachments": {
    "image.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### We can have almost as many dimensions as we want and essentially access them with an index along each \n",
    "basically have one set of indices for the columns and the rows (in green) in order to pick out our data\n",
    "![image.png](attachment:image.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Key syntax\n",
    " Its just like indexing or slicing a list, but each dimension needs its own slicing commands\n",
    " \n",
    "- example_array[dimension 0 index or slice, dimension 1 index or slice,....., dimension n index or slice]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(nest_array)\n",
    "nest_array[1:,0:2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Challenge set 1:\n",
    "We are going to slice up this numpy dataset a few different ways:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# numpy has a pretty nice function to upload files\n",
    "rando_data = np.loadtxt('rando_data.csv',delimiter = ',')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "rando_data.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**1.1** whats the datatype of the elements in our rando data?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**1.2** - slice the 15th row into a 1-D vector, and find the maximum value (hint look up np.max())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**1.3** - create a subarray of every 3rd row (0th dimension) and 4th column (first dimension), what is the shape?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**1.4** - create a sub-array of the 10th, 13th, and 18th row (along dimension 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**1.5** - add the sub array from 1.2 and 1.5 together, what shape is it?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Part two: Broadcasting"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "** What we know already**\n",
    "- That we pretty much know how to use numpy arrays because they are just like lists\n",
    "- just need to be cognizant of the data types we put into our arrays\n",
    "- We learned how to slice a multidimensional array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test1 = np.arange(8).reshape(2,4)\n",
    "test2 = np.arange(9,13)\n",
    "print(test1,'+', test2)\n",
    "test1+test2\n"
   ]
  },
  {
   "attachments": {
    "image.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![image.png](attachment:image.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### General Broadcasting Rules\n",
    "When operating between Two arrays, Numpy compares the length of each axis or dimension, and can proceed with calculations if:\n",
    "- 1.) The two axis lengths are equal\n",
    "- 2.) one of the axis lengths is 1\n",
    "\n",
    "These two conditions must be satisfied along every axis"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "** Our example**\n",
    "\n",
    "- test1  (2d array) 2 x 4\n",
    "- test2  (1d array) (1)  x 4\n",
    "- result (2d array) 2 X 4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "** Challenge 2:** Gain an understanding of the broadcasting rules\n",
    "For each of the examples below, tell me what the resulting axes lengths will be of the operations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **2.1** a(4x3) + b(3,)\n",
    "- **2.2** A(15x3x5) + B(15x1x5)\n",
    "- **2.3** C(2x1) + D(8x4x3)\n",
    "- **2.4** E(4x3) + F(4,)\n",
    "- **2.5** G(4x3) +H(4x1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### changing the shapes of Arrays to make the Broadcasting work\n",
    "\n",
    "- array.reshape() method - where you can specify the lengths of each dimension you need\n",
    "- np.newaxis - an operator that  inserts a new length axis\n",
    "- inserting a None to create an empty axis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Looking at problems 2.4 and 2.5\n",
    "E = np.zeros((4,3))\n",
    "print(E)\n",
    "\n",
    "F = np.arange(4)\n",
    "\n",
    "print(F)\n",
    "E+F"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"using reshape method)\",E+F.reshape(4,1))\n",
    "print('using np.newaxis', E+F[:,np.newaxis])\n",
    "print('using none',E+F[:,None])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Challange 2.6\n",
    "\n",
    "add two arrays  of dimensions (6,5,4) and of dimensions (6,4) together using broadcasting and changing shape as necessary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "I = np.zeros((6,5,4))\n",
    "J = np.random.randint(2,size=(6,4))\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# all these work\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Part 3: Filtering out data using np.where and some logic"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "L = np.array([1,2,3,4,5])\n",
    "\n",
    "L_bool = L >3\n",
    "L_bool"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#can use it to grab subsets of data, and to change parts of an array based on conditions\n",
    "L[L_bool] = 0\n",
    "\n",
    "L"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### np.where is the other way to do it but returns something slightly different"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "L_nils = np.where(L is 0)\n",
    "L_nils"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "** WTF happened here?**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python has multiple ways to do logic\n",
    "- is, and, or all do not do **elementwise** logical operations\n",
    "- you should use ==, !=. &, | (for elementwise or), ^ (for elementwise exclusive or)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# the example above didn't work so here is:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Challenge 3.1:\n",
    "\n",
    "How many 0's are there in our rando_data?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "**Note:** that the where here returns a tuple of two integer arrays, the 0th item in the tuple is a list of the 0 axis indices\n",
    "of each cell where the condition is true, and the 1st item is an array of the 1st axis indices, that way when you put this\n",
    "tuple into the brackets to slice up your array, it slices it up as two arrays of indices\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### So what about Scipy?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Scipy is just a collection of additional functions that typically use the numpy array"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- And there are Myriads of things you can do with them"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Instead of me explaining how to use them, we will figure them out ourselves!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### I can't show them all to you, but I will show you two examples"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 1.) Interpolation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# An example\n",
    "import matplotlib.pyplot as plt\n",
    "from scipy import interpolate\n",
    "%matplotlib inline\n",
    "x = np.arange(0, 10)\n",
    "y = np.exp(-x/3.0)\n",
    "f = interpolate.interp1d(x, y) #creates an interpolation function object to use"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "xnew = np.arange(0, 9, 0.1)\n",
    "ynew = f(xnew)   # use interpolation function returned by `interp1d`\n",
    "plt.plot(x, y, 'o', xnew, ynew, '-')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.) Optimization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from scipy.optimize import minimize\n",
    "\n",
    "# creating a function of two variables\n",
    "fun = lambda x: (x[0] - 1)**2 + (x[1] - 2.5)**2\n",
    "\n",
    "# and some constraints\n",
    "cons = ({'type': 'ineq', 'fun': lambda x:  x[0] - 2 * x[1] + 2},\n",
    "        {'type': 'ineq', 'fun': lambda x: -x[0] - 2 * x[1] + 6},\n",
    "        {'type': 'ineq', 'fun': lambda x: -x[0] + 2 * x[1] + 2})\n",
    "#and some boundaries\n",
    "bnds = ((0, None), (0, None))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "res = minimize(fun, (2, 0), method='SLSQP', bounds=bnds,\n",
    "               constraints=cons)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "res.x\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Activity 1: Function/ method show and tell\n",
    "I am going to give each group a bunch of methods and functions, and they will have 15 minutes to create some  examples, and come up to the class to present them"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Activity 2: Some crackin Numpy Puzzles\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**4.1** Create a 8x8 matrix of zeros and fill it with a checkerboard pattern of ones"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**4.2** Consider a random 10x2 matrix representing cartesian coordinates, convert them to polar coordinates"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**4.3** Create a 2d array with 1 on the border and 0 inside"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Activity 3: You are welcome Telstra, we are doing your work for you\n",
    "\n",
    "We are going to be given 1000 coordinate positions of homes, and we need to know the straight line distance from these positions to a set of coordinates for the Cell phone towers in the area to assess how good the coverage is\n",
    "\n",
    "** Hint** this is a good place to practice your broadcasting skills"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Home_locations = np.random.randint(0,10000,size = (2,1000)) #a (2,1000) 2-D integer\n",
    "cell_towers = np.random.randint(0,10000,size = (2,10)) #a (2,10 ) 2 -d array the 2 rows pertain to x and y respectively"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# so first part of the calculations is to find X1-Y and X2-Y2 (the two rows in the first dim) broadcasting like:\n",
    "# Home locations: 2 x (1) x 1000 *note axis in parenthesis added by new axis\n",
    "# Cell Towers:    2 x 10  x (1)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# euclidean distance = sqrt((x1-y1)**2 +(y1-y2)**2)\n",
    "# here we are squaring our (x1-x2) diff[0,:,:] and our (y1-y2) or diff[1,:,:] then summing them along the 0th axis \n",
    "# then we are taking that sum and square rooting it\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Arg min is grabbing the index (along axis 0) of the lowest distance, vis a vis the closest station\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "  #This data set would be much better as a Pandas dataframe fyi"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Activity 4: Was Crowded House full of Crap\n",
    "#### An analysis of the origins of a song using Numpy and Historic Meteorological data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Neil Finn and Tim Finn allegedly wrote the song \"Four seasons in one day\" about Melbourne's patently unpredictable weather. What we are going to do is assess that claim using some historic Meteorological data\n",
    "- We have daily minimum and maximum temperature measurements from the BOM Melbourne Regional office between 1855 and 2015\n",
    "- We also have some summary statistics about mean monthly temperatures"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Uploading our dataset\n",
    "dataset = np.loadtxt('melbs_daily_t.txt',delimiter=',')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#sorting the data into the requisite Columns\n",
    "Year = dataset[:,0].astype(np.int64)\n",
    "Month = dataset[:,1].astype(np.int64)\n",
    "day = dataset[:,2].astype(np.int64)\n",
    "min_temp = dataset[:,3].astype(np.float64)\n",
    "max_temp = dataset[:,4].astype(np.float64)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "** Hints** because I have separated out the data into 1 D vectors I would strongly suggest **not** rearranging the order of the elements in any vector as they need to be in the same order to relate to our other vectors (Hint come to our pandas class next week hint hint)\n",
    "\n",
    "** Hint number 2** - If you create a boolean mask vector on one of these arrays, you can use it on the other right?"
   ]
  },
  {
   "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.4"
  },
  "toc": {
   "colors": {
    "hover_highlight": "#DAA520",
    "navigate_num": "#000000",
    "navigate_text": "#333333",
    "running_highlight": "#FF0000",
    "selected_highlight": "#FFD700",
    "sidebar_border": "#EEEEEE",
    "wrapper_background": "#FFFFFF"
   },
   "moveMenuLeft": true,
   "nav_menu": {
    "height": "288px",
    "width": "252px"
   },
   "navigate_menu": true,
   "number_sections": false,
   "sideBar": false,
   "threshold": 4,
   "toc_cell": false,
   "toc_position": {
    "height": "40px",
    "left": "630.135px",
    "right": "20px",
    "top": "66px",
    "width": "241px"
   },
   "toc_section_display": "none",
   "toc_window_display": true,
   "widenNotebook": 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
}