Topic1b Functions and Basic Operations.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Topic 1b: Functions and Basic Operations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Basics Operations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that we know the basic data structures, now what can we do with them.  \n",
    "\n",
    "There are some basic logic structures that are useful: are things equal"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5==4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5==5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[1,2,3]==[3,2,1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[1,2,3]==[1,2,3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Inequalities are also very useful.  Both >,<, >=, and <= do the obvious thing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True False True True\n"
     ]
    }
   ],
   "source": [
    "print(5>3, 5>5, 5>=5, 5<=5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The value of the equals operation shall be pretty clear when you start running over long lists of numbers looking for something in particular."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Already, you might also have noticed that I cheated you: True and False are data types we didn't discuss yet!  True and False are the outputs of logical operations, but are also things we can save for later use:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The simplest possible version is if statements, which mean can be understood as \"if True: do something\":"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Get a haircut!\n"
     ]
    }
   ],
   "source": [
    "Is_my_hair_too_long=True\n",
    "if Is_my_hair_too_long:\n",
    "    print('Get a haircut!')\n",
    "else:\n",
    "    print('continue on')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We also have our basic and / or statements:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "print(1==1 and 2==2)\n",
    "print(1==1 and 2==1)\n",
    "print(1==1 or 2==1)\n",
    "print(1==1 or 2==2) # notice that OR is inclusive True or True is True."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Truth statements are particularly useful in if statements in combination with loops.  For example, we can run through a list of objects but then do something only under certain conditions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "list1=range(1,10)  # this automatically makes a list of 1,9"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To see how this works, let's just make a for loop and print what is happening:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "for item in list1:\n",
    "    print(item)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Okay - so our for loop just picks an elements from the list, one at a time and then lets us do something with it.  Now let's see what happens when we put an if statment inside the loop: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "nay\n",
      "nay\n",
      "Yay!!\n",
      "nay\n",
      "nay\n",
      "nay\n",
      "nay\n",
      "nay\n",
      "nay\n"
     ]
    }
   ],
   "source": [
    "for item in list1:\n",
    "    if item==3:\n",
    "        print('Yay!!')\n",
    "    else:\n",
    "        print('nay')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "nay\n",
      "nay\n",
      "hmmm\n",
      "hmmm\n",
      "yay\n",
      "yay\n",
      "yay\n",
      "yay\n",
      "yay\n"
     ]
    }
   ],
   "source": [
    "for item in list1:\n",
    "    if item>4:\n",
    "        print('yay')\n",
    "    elif item >2:\n",
    "        print('hmmm')\n",
    "    else:\n",
    "        print('nay')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We also have a bunch of basic math operations.  The least obvious is powers:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "16 4096 4096\n"
     ]
    }
   ],
   "source": [
    "print(2**4, 2**(12), 2**12)  #using backets with ** isn't necessary but highly encouraged."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.4142135623730951\n"
     ]
    }
   ],
   "source": [
    "print(2**(1/2.))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are also some nice tricks built for tasks you will use a lot.  For example if I want to add up something, I can do += instead of x=x+y (which looks confusing)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "19.1\n"
     ]
    }
   ],
   "source": [
    "costs=[1.2,3.4,4.5,4.,6.]\n",
    "total=0\n",
    "for cost in costs:\n",
    "    total+=cost\n",
    "print(total)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also do the same with substraction, multiplication or divisions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "80.89999999999999\n"
     ]
    }
   ],
   "source": [
    "cash=100\n",
    "for cost in costs:\n",
    "    cash-=cost\n",
    "print(cash)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Aside: Notice that we have a nice example of numerical error here!  It should have been 80.1, but because of the way our floating point number is stored it isn't.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.10000000000000142"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "19.1-19"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*What is happening here?  A pretty good guess is that your computer wants to store information in binary form, which means that it works in powers of 2.  I.e. $1=2^0$, $2=2^1$, $3 = 2^1 + 2^0$, $4=2^2$.  For decimals, then we might expect it is storing it in terms of fractions $1/2 =2^{-1}$, $1/4 = 2^{-2}$. So we can check that is what is happening if we pick nice fractions of 2 writen as a decimal:*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.5"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "19.5-19"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.25"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "19.25-19"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.125"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "19.125-19"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Now we can look up the definition of a floating point number in python and find out that it is a 64 bit number, meaning that it contains 64 binary numbers or can represent from 1 to $2^{63}$*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.8446744073709551"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2**(64)/10**19"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*We see it is pretty close to our 16 decimal places from before.  To udnerstand why it isn't exactly 16, we should also remember that we need to store the overall power as well (because it can store numbers much bigger or smaller than $2^{64}$, so it must be using some of the 64 bits for that as well.  There is clearly a bit more going on under the hood too*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10715086071862673209484250490600018105614048117055336074437503883703510511249361224931983788156958581275946729175531468251871452856923140435984577574698574803934567774824230985421074605062371141877954182153046474983581941267398767559165543946077062914571196477686542167660429831652624386837205668069376"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2**(1000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*End of Aside*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, for multiplication and division, we have to be very careful not to accidently multiply or divide by zero:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n"
     ]
    }
   ],
   "source": [
    "factorial=1\n",
    "for i in range(5):\n",
    "    factorial*=i\n",
    "print(factorial)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "120\n"
     ]
    }
   ],
   "source": [
    "factorial=1\n",
    "for i in range(5):\n",
    "    factorial*=i+1\n",
    "print(factorial)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For division, we have to worry about division by zero:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "ename": "ZeroDivisionError",
     "evalue": "division by zero",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mZeroDivisionError\u001b[0m                         Traceback (most recent call last)",
      "\u001b[0;32m/var/folders/vh/rcz751b57355h3qzj37sc3080000gp/T/ipykernel_6604/3237423217.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0minverse_factorial\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mi\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m5\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m     \u001b[0minverse_factorial\u001b[0m\u001b[0;34m/=\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      4\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minverse_factorial\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mZeroDivisionError\u001b[0m: division by zero"
     ]
    }
   ],
   "source": [
    "inverse_factorial=1\n",
    "for i in range(5):\n",
    "    inverse_factorial/=i\n",
    "print(inverse_factorial)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.008333333333333333 120.0\n"
     ]
    }
   ],
   "source": [
    "inverse_factorial=1\n",
    "for i in range(5):\n",
    "    inverse_factorial/=(i+1)\n",
    "print(inverse_factorial,1/inverse_factorial)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Aside: Notice that I have been running through lists of numbers using range. In Python 2, you were told not to do this (but to use something called xrange) to avoid creating a list that is saved to memory for no reason.  Range in python 3 is basically what xrange used to be an they removed the function xrange  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Range is often useful when you running through things in a list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "box\n",
      "car\n",
      "keys\n"
     ]
    }
   ],
   "source": [
    "short_list=['box','car','keys']\n",
    "for i in range(3):\n",
    "    print(short_list[i])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now if you just wanted the elements in the list, you can also just call them one by one:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "box\n",
      "car\n",
      "keys\n"
     ]
    }
   ],
   "source": [
    "for item in short_list:\n",
    "    print(item)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And, sometimes, you want both: you want the item in the list but you also want to know the element it came frmo.  For that, you have enumerate:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 0 1\n",
      "box\n",
      "1 1 2\n",
      "car\n",
      "2 4 3\n",
      "keys\n"
     ]
    }
   ],
   "source": [
    "for i,item in enumerate(short_list):\n",
    "    print(i, i**2, i+1) # look I can do math with the index from which each entry came\n",
    "    print(item) # I also have actual entry in the list available to use"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That we have enough basic tools, we can start defining our own functions for our specific problems.  The simpliest way to proceed is by example."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The basic setup is as follows: we define it using def and put in some information we want to use in the function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "def say_hi(name):\n",
    "    print('Hi '+name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hi Professor Green\n"
     ]
    }
   ],
   "source": [
    "say_hi('Professor Green')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As written, the above function looks fine, but will not work if we don't put the exact right kind of input."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "can only concatenate str (not \"int\") to str",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m/var/folders/vh/rcz751b57355h3qzj37sc3080000gp/T/ipykernel_6604/892123741.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0msay_hi\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m5\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m/var/folders/vh/rcz751b57355h3qzj37sc3080000gp/T/ipykernel_6604/2903403830.py\u001b[0m in \u001b[0;36msay_hi\u001b[0;34m(name)\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0msay_hi\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mname\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m     \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'Hi '\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0mname\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: can only concatenate str (not \"int\") to str"
     ]
    }
   ],
   "source": [
    "say_hi(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is usually a good habit to either (a) force the data to be the kind we want or (b) send a warning"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "def say_hi_2(name):\n",
    "    print('Hi '+str(name))\n",
    "def say_hi_3(name):\n",
    "    if type(name)==str:\n",
    "        print('Hi '+name)\n",
    "    else:\n",
    "        print('Error: not a string')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hi 5\n",
      "Error: not a string\n"
     ]
    }
   ],
   "source": [
    "say_hi_2(5)\n",
    "say_hi_3(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's try another example: we saw above that we can make our own verion of a factorial.  So we can just define a function that does this automatically"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "def factorial(n):\n",
    "    out=1\n",
    "    if n>0: # We are going to force n>0 so that it is well defined\n",
    "        for i in range(int(n)): ## notice that I am forcing n to be an integer to avoid problems\n",
    "            out*=(i+1)\n",
    "\n",
    "    return out\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "120 5040 1\n"
     ]
    }
   ],
   "source": [
    "print(factorial(5), factorial(7), factorial(-6.6))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We notice a few things in this way I have implemented the code: it allows me to input non-integers but gives a integer answer.  I also wrote it in this slightly awkward way of multiplying everything in a loop."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now here is where we get to some of the fun of coding!  Just like writing, there can be more than one way to write something that accomplishes the same basic goals, but one might be far better or more elegant than the other."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can think about factorial by a different definition.  In fact, it is the same defining feature of the Gamma function $$\\Gamma[x] = (x-1) \\Gamma[x-1]$$ and $$\\Gamma[1]=1$$ so that $\\Gamma(n) = (n-1)!$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "def Gamma(n):\n",
    "  \n",
    "  if n<=1:\n",
    "      #If n=0, or any value it can't determine, set to 1\n",
    "    return 1\n",
    "  else:\n",
    "      #If it is greater than one, call again iteratively by definition\n",
    "    return (n-1)*Gamma(n-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "24 0.5280000000000006\n"
     ]
    }
   ],
   "source": [
    "print(Gamma(5),Gamma(3.2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that this isn't actually the true gamma function because we defined $\\Gamma(x<1) =1$ rather than just $\\Gamma(1)=1$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Regardless, this is a clever implementation, because it defines the factorial recursively, rather than by brute force."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As our last example, we are going to make a sorting function.  We want to take a list of numbers are reorder them from largest to smallest.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "def dumb_sort(alist):\n",
    "    b=[] # I am making a place to put my numbers in order\n",
    "    \n",
    "    c=alist[:] # I am making a copy of the list so that I don't ruin my original list\n",
    "    \n",
    "    while len(c)>0: # I am going to loop over c and remove the largest each time.  I stop when there is nothing left\n",
    "        \n",
    "        largest=c[0] # assume the first element is the largest\n",
    "        \n",
    "        for item in c: #now run over all the elements in the remaining list \n",
    "            if item>largest: # and check if any are bigger\n",
    "                largest=item # when you get somethign bigger, store it the biggest and continue\n",
    "        \n",
    "        b.append(largest) # after running through all the elements, add the largest to the output list\n",
    "        \n",
    "        c.pop(c.index(largest)) #remove the largest from c and repeat\n",
    "    \n",
    "    return b #when you have all the numbers in b, c=[] and the while loop will end.  Output b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "unordered=[3,5,1,5,2,4,5,2,1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[5, 5, 5, 4, 3, 2, 2, 1, 1]"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dumb_sort(unordered)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I called the \"dumb_sort\" for a reason: it is really inefficient.  I had to make multiple copies of my list and looped over the elements a lot of times.  If I have a list of lenght N, I would take at least 3N space in memory and would run look at roughy N^2/2 elements in the list (I keep looking at them over and over again to compare them to the new biggest number)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[9, 8, 7, 5, 2, 1, 1]\n"
     ]
    }
   ],
   "source": [
    "def mysort(a):\n",
    "    for n in range(1,len(a)):\n",
    "    #Read in one element at a time, starting with second (first is sorted)\n",
    "        value=a[n]\n",
    "    #set marker for previous\n",
    "        i=n-1\n",
    "        while i>=0 and (value > a[i]):\n",
    "        #if i is not past the first element, but value > previous element swith the two\n",
    "            a[i+1]=a[i]\n",
    "            a[i] = value\n",
    "      #now move the marker one to the left and repeat\n",
    "            i-=1\n",
    "#1st element is sorted.  When we get to the nth element, the n-1 previous elements are sorted.  Just need to place it in the right spot\n",
    "\n",
    "b=[1,5,7,8,1,9,2]\n",
    "mysort(b)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that if we give it an ordered list, it only has to check N-numbers instead of N^2/2.  I.e. once we sort part of the list, we don't keep checking it. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A very useful thing about functions is that you can given them options that come with defaults.  To see this in action, suppose we want to know the position of a particle subject to an constant external force:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "def position(t,x0,v,a):\n",
    "    pos=x0+v*t+a*t**2/2. # solution for motion under constant acceleration\n",
    "    return pos # return position"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "490.00000000000006"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "position(10,0,0,9.8)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But maybe there are some standard choices we like, e.g. a=9.8 m/s$^2$ or x0=0.  If that is a case we consider a lot, maybe we just want to assume those values, unless otherwise stated:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "def pos_short(t,x0=0,v=0,a=9.8):\n",
    "    pos=x0+v*t+a*t**2/2. # solution for motion under constant acceleration\n",
    "    return pos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "490.00000000000006"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pos_short(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The good part about doing it this way is that I can always put back the values if I want"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "505.00000000000006"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pos_short(10,x0=15)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python Scripts"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that you have defined a function and have it working properly might want to do two things: (a) move it somewhere so that you don't accidently mess it up (b) have it available for other projects you might be working on."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sort"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[9, 8, 7, 5, 2, 1, 1]\n"
     ]
    }
   ],
   "source": [
    "b2=[1,5,7,8,1,9,2]\n",
    "sort.mysort(b2)\n",
    "print(b2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that I can save all kinds of information this way.  E.g. I can just save lists of numbers or specific numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.141592653589793\n"
     ]
    }
   ],
   "source": [
    "print(sort.my_fav_number)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is the same structure we use for all kinds of things. We can make our lift easier by importing a file under a shorted name.  E.g."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import sort as s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.5403023058681398"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.cos(1.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[9, 8, 7, 5, 2, 1, 1]\n"
     ]
    }
   ],
   "source": [
    "b3=[1,5,7,8,1,9,2]\n",
    "s.mysort(b3)\n",
    "print(b3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We have more than one option for how to important information.  We could just import as single function, in which case you can just use the name:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [],
   "source": [
    "from numpy import cos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.5403023058681398"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cos(1.)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you want to import all of the functions this way, you can use *, but PLEASE don't do this for things like numpy that have a LOT of functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sort import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.141592653589793"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_fav_number"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Summary"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We have run through a lot of the basic functionality of python.  At this level, you have all the functionality you need to do anything.  You have all the basic logical and mathematical operations at your disposal and all the objects you need to store the input and output.\n",
    "\n",
    "Now, in practice, converting these basic operations into more advanced algorithms is a lot of work.  You have the power to do it, but it would run very slow and take a lot of your time.  Luckily, more skilled users of python have written a lot of that code using more advanced and elegant techniques.  They probably do the same basic thing that you might, but it will run way faster and have a lot more versality (and is already debugged).  From here, we are going to start learning about some of these software packages and how to understand what they are doing and why they are useful.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}