Python_Introduction.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "# A jupyter notebook is a browser-based environment that integrates:\n",
    "- A Kernel (python)\n",
    "- Text\n",
    "- Executable code\n",
    "- Plots and images\n",
    "- Rendered mathematical equations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "## Cell"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "The basic unit of a jupyter notebook is a `cell`. A `cell` can contain any of the above elements. \n",
    "\n",
    "In a notebook, to run a cell of code, hit `Shift-Enter`. This executes the cell and puts the cursor in the next cell below, or makes a new one if you are at the end.  Alternately, you can use:\n",
    "    \n",
    "- `Alt-Enter` to force the creation of a new cell unconditionally (useful when inserting new content in the middle of an existing notebook).\n",
    "- `Control-Enter` executes the cell and keeps the cursor in the same cell, useful for quick experimentation of snippets that you don't need to keep permanently."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "## Hello World"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
    "print(\"Hello World!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
    "# lines that begin with a # are treated as comment lines and not executed\n",
    "\n",
    "# print(\"This line is not printed\")\n",
    "\n",
    "print(\"This line is printed\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "## Create a variable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
    "my_variable = 3.0 * 2.0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "## Print out the value of the variable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
    "print(my_variable)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "## or even easier:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
    "my_variable"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "# Datatypes\n",
    "\n",
    "In computer programming, a data type is a classification identifying one of various types that data\n",
    "can have. \n",
    "\n",
    "The most common data type we will see in this class are:\n",
    "\n",
    "* **Integers** (`int`): Integers are the classic cardinal numbers: ... -3, -2, -1, 0, 1, 2, 3, 4, ...\n",
    "    \n",
    "* **Floating Point** (`float`): Floating Point are numbers with a decimal point: 1.2, 34.98, -67,23354435, ...\n",
    "\n",
    "  - Floating point values can also be expressed in scientific notation: 1e3 = 1000\n",
    "  \n",
    "  \n",
    "* **Booleans** (`bool`): Booleans types can only have one of two values: `True` or `False`. In many languages 0 is considered `False`, and any other value is considered `True`.\n",
    "\n",
    "* **Strings** (`str`): Strings can be composed of one or more characters: ’a’, ’spam’, ’spam spam eggs and spam’. Usually quotes (’) are used to specify a string. For example ’12’ would refer to the string, not the integer.\n",
    "\n",
    "## Collections of Data Types\n",
    "\n",
    "* **Scalar**: A single value of any data type.\n",
    "\n",
    "* **List**: A collection of values. May be mixed data types. (1, 2.34, ’Spam’, True) including lists of lists: (1, (1,2,3), (3,4))\n",
    "\n",
    "* **Array**: A collection of values. Must be same data type. [1,2,3,4] or [1.2, 4.5, 2.6] or [True, False, False] or [’Spam’, ’Eggs’, ’Spam’]\n",
    "\n",
    "* **Matrix**: A multi-dimensional array: [[1,2], [3,4]] (an array of arrays)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
    "my_var_a = 1\n",
    "my_var_b = 2.3\n",
    "my_var_c = 2.3e4\n",
    "my_var_d = True\n",
    "my_var_e = \"Spam\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
    "type(my_var_a), type(my_var_b), type(my_var_c), type(my_var_d), type(my_var_e)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
    "my_var_a + my_var_b, type(my_var_a + my_var_b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
    "my_var_c + my_var_d, type(my_var_c + my_var_d)    # True = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
    "my_var_a + my_var_e"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
    "str(my_var_a) + my_var_e"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "# NumPy (Numerical Python) is the fundamental package for scientific computing with Python."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "### Load the numpy library:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "  + - * /     Standard math functions (add, subtract, multiply, divide)\n",
    "\n",
    "  **   <-- for exponentiation  (e.g. 2 ** 4 = 16)\n",
    "\n",
    "  % for remainder or modulo, 400%360 = 40\n",
    "\n",
    "  ==  equal to                      !=  not equal to\n",
    "  >   greater than                  <   less than\n",
    "  >=  greater than or equal to      <=  less than or equal to\n",
    "\n",
    "  x += 2 same as x = x + 2\n",
    "\n",
    "  can also use  -=  *=  /=  **="
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "#### pi and e are  built-in constants:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
    "np.pi, np.e"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "## Here is a link to all [Numpy math functions](https://docs.scipy.org/doc/numpy/reference/routines.math.html)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "# Arrays\n",
    "\n",
    "* Each element of the array has a **Value**\n",
    "* The *position* of each **Value** is called its **Index**\n",
    "\n",
    "![Image of Index](./images/PosIndex_sm.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "## Our basic unit will be the NumPy array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
    "my_array = np.array([7, 4, 8, 5, 7, 3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
    "my_array"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "## Indexing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
    "my_array[0]    # The Value at Index = 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
    "my_array[-1]    # The last Value in the array"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "![Image of Index](./images/NegIndex_sm.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "## Slices\n",
    "\n",
    "`x[start:stop:step]`\n",
    " \n",
    "- `start` is the first Index that you want [default = first element]\n",
    "- `stop`  is the first Index that you **do not** want [default = last element]\n",
    "- `step`  defines size of `step` and whether you are moving forwards (positive) or backwards (negative) [default = 1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
    "my_array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
    "my_array[0:4]           # first 4 items"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
    "my_array[:4]            # same"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
    "my_array[0:4:2]         # first four item, step = 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
    "my_array[3::-1]         # first four items backwards, step = -1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
    "my_array[::-1]          # Reverse the array x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
    "print(my_array[-3:])    # last 3 elements of the array x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "## There are lots of different `methods` that can be applied to a NumPy array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
    "my_array.size                   # Number of elements in x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
    "my_array.mean()                 # Average of the elements in x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
    "my_array.sum()                  # Total of the elements in x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
    "my_array[-3:].sum()              # Total of last 3 elements in x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
    "my_array.cumsum()                # Cumulative sum"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
   ],
   "source": [
    "my_array.cumsum()/my_array.sum()        # Cumulative percentage"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "my_array.[TAB] will give you all of the possibilites as a drop-down menu."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
    "my_array."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "## Help about a function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
    "?my_array.min"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "## NumPy math works over an entire array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
    "my_array * 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
    "sin(my_array)     # need to Numpy's math functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
    "np.sin(my_array)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "## Masking - The key to fast programs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
    "mask1 = np.where(my_array > 5)\n",
    "my_array, mask1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
    "my_array[mask1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
    "mask2 = np.where((my_array>3) & (my_array<6))\n",
    "my_array[mask2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "## Fancy masking"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
    "mask3 = np.where(my_array >= 5)\n",
    "my_array[mask3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
    "# Set all values of x that match mask3 to 0\n",
    "\n",
    "my_array[mask3] = 0\n",
    "my_array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
    "mask4 = np.where(my_array != 0)\n",
    "mask4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
    "#Add 10 to every value of x that matches mask4:\n",
    "\n",
    "my_array[mask4] += 100\n",
    "my_array"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "## Sorting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
    "my_array = np.array([7, 4, 8, 5, 7, 3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
    "np.sort(my_array)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
    "np.sort(my_array)[0:3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "# Control Flow\n",
    "\n",
    "Like all computer languages, Python supports the standard types of control flows including:\n",
    "\n",
    "* IF statements\n",
    "* FOR loops"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
    "my_variable = -1\n",
    "\n",
    "if my_variable > 0:\n",
    "    print(\"This number is positive\")\n",
    "else:\n",
    "    print(\"This number is NOT positive\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
    "my_variable = 0\n",
    "\n",
    "if my_variable > 0:\n",
    "    print(\"This number is positive\")\n",
    "elif my_variable == 0:\n",
    "    print(\"This number is zero\")\n",
    "else:\n",
    "    print(\"This number is negative\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "## `For loops` are different in python.\n",
    "\n",
    "You do not need to specify the beginning and end values of the loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
    "my_array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
    "for value in my_array:\n",
    "    print(value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
    "for idx,val in enumerate(my_array):\n",
    "    print(idx,val)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
    "for idx,val in enumerate(my_array):\n",
    "    if (val >= 5):\n",
    "        my_array[idx] = 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
    "for idx,val in enumerate(my_array):\n",
    "    print(idx,val)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "## Loops are slow in Python. Do not use them if you do not have to!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
    "np.random.seed(42)\n",
    "my_BIG_Array = np.random.randint(0,10,10000)    # 10,000 value array\n",
    "my_BIG_Array[:10]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
    "# This is slow!\n",
    "\n",
    "for Idx,Val in enumerate(my_BIG_Array):\n",
    "    if (Val >= 5):\n",
    "        my_BIG_Array[Idx] = 0\n",
    "\n",
    "my_BIG_Array[:10]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
    "%%timeit\n",
    "\n",
    "for Idx,Val in enumerate(my_BIG_Array):\n",
    "    if (Val >= 5):\n",
    "        my_BIG_Array[Idx] = 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
    "# Masks are MUCH faster\n",
    "\n",
    "mask_BIG = np.where(my_BIG_Array >= 5)\n",
    "my_BIG_Array[mask_BIG] = 0\n",
    "\n",
    "my_BIG_Array[:10]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
    "%%timeit -o\n",
    "\n",
    "mask_BIG = np.where(my_BIG_Array >= 0.5)\n",
    "my_BIG_Array[mask_BIG] = 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "# Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "In computer science, a `function` (also called a `procedure`, `method`, `subroutine`, or `routine`) is a portion\n",
    "of code within a larger program that performs a specific task and is relatively independent of the\n",
    "remaining code. The big advantage of a `function` is that it breaks a program into smaller, easier\n",
    "to understand pieces. It also makes debugging easier. A `function` can also be reused in another\n",
    "program.\n",
    "\n",
    "The basic idea of a `function` is that it will take various values, do something with them, and `return` a result. The variables in a `function` are local. That means that they do not affect anything outside the `function`.\n",
    "\n",
    "Below is an example of a `function` that solves the equation:\n",
    "\n",
    "$ f(a,b,x) = b\\cos(a\\pi x) + b^{2}\\cos(a^{2}\\pi x)$\n",
    "\n",
    "In the example the name of the `function` is **find_f** (you can name `functions` what ever you want). The `function` **find_f** takes three arguments `a`, `b` and `y`, and returns the value of the equation to the main program. In the main program a variable named `value_f` is assigned the value returned by **find_f**. Notice that in the main program the `function` **find_f** is called using the arguments `scalar_a`, `scalar_b` and `array_x`. Since the variables in the `function` are local, you do not have name them `a`, `b` and `x` in the main program."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
    "def find_f(my_a, my_b, my_x):\n",
    "\n",
    "    result = (my_b * np.cos(my_a * np.pi * my_x) +\n",
    "              my_b **2 * np.cos(my_a **2 * np.pi * my_x))           # assign the variable result the value of the function\n",
    "    return result                                                   # return the value of the function to the main program"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "`np.linspace` -  create a new array filled with evenly spaced numbers over a specified interval `(start, stop, num)`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
    "scalar_a = 7\n",
    "scalar_b = 0.5\n",
    "array_x = np.linspace(0,2*np.pi,20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
    "scalar_a, scalar_b, array_x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
    "value_f = find_f(scalar_a, scalar_b, array_x)\n",
    "\n",
    "value_f"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "### The results of one function can be used as the input to another function\n",
    "\n",
    "$$ g(z) = \\frac{z}{e^{z}}$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
    "def find_g(my_z):\n",
    "\n",
    "    result = my_z / np.exp(my_z)\n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
    "find_g(value_f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
    "find_g(find_f(scalar_a, scalar_b, array_x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "# Creating Arrays\n",
    "\n",
    "## Numpy has a wide variety of ways of creating arrays: [Array creation routines](https://docs.scipy.org/doc/numpy-1.13.0/reference/routines.array-creation.html)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
    "# a new array filled with zeros\n",
    "\n",
    "array_0 = np.zeros(10)\n",
    "\n",
    "array_0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
    "# a new array filled with ones\n",
    "\n",
    "array_1 = np.ones(10)\n",
    "\n",
    "array_1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
    "# a new array filled with evenly spaced values within a given interval\n",
    "\n",
    "array_2 = np.arange(10,20)\n",
    "\n",
    "array_2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
    "# a new array filled with evenly spaced numbers over a specified interval (start, stop, num)\n",
    "\n",
    "array_3 = np.linspace(10,20,5)\n",
    "\n",
    "array_3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
    "# a new array filled with evenly spaced numbers over a log scale. (start, stop, num, base)\n",
    "\n",
    "array_4 = np.logspace(1,2,5,10)\n",
    "\n",
    "array_4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {
  },
  "kernelspec": {
   "display_name": "Python 3 (Anaconda 5)",
   "env": {
    "LD_LIBRARY_PATH": "/ext/anaconda5/lib",
    "PROJ_LIB": "/ext/anaconda-2019.03/share/proj",
    "PYTHONHOME": "/ext/anaconda5/lib/python3.5",
    "PYTHONPATH": "/ext/anaconda5/lib/python3.5:/ext/anaconda5/lib/python3.5/site-packages"
   },
   "language": "python",
   "metadata": {
    "cocalc": {
     "description": "Python/R distribution for data science",
     "priority": -1,
     "url": "https://www.anaconda.com/distribution/"
    }
   },
   "name": "anaconda5"
  },
  "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.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}