Week1_9-Functions2.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<link href='http://fonts.googleapis.com/css?family=Alegreya+Sans:100,300,400,500,700,800,900,100italic,300italic,400italic,500italic,700italic,800italic,900italic' rel='stylesheet' type='text/css'>\n",
       "<link href='http://fonts.googleapis.com/css?family=Arvo:400,700,400italic' rel='stylesheet' type='text/css'>\n",
       "<link href='http://fonts.googleapis.com/css?family=PT+Mono' rel='stylesheet' type='text/css'>\n",
       "<link href='http://fonts.googleapis.com/css?family=Shadows+Into+Light' rel='stylesheet' type='text/css'>\n",
       "<link href='http://fonts.googleapis.com/css?family=Philosopher:400,700,400italic,700italic' rel='stylesheet' type='text/css'>\n",
       "\n",
       "<style>\n",
       "\n",
       "@font-face {\n",
       "    font-family: \"Computer Modern\";\n",
       "    src: url('http://mirrors.ctan.org/fonts/cm-unicode/fonts/otf/cmunss.otf');\n",
       "}\n",
       "\n",
       "#notebook_panel { /* main background */\n",
       "    background: #ddd;\n",
       "    color: #000000;\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "/* Formatting for header cells */\n",
       ".text_cell_render h1 {\n",
       "    font-family: 'Philosopher', sans-serif;\n",
       "    font-weight: 400;\n",
       "    font-size: 2.2em;\n",
       "    line-height: 100%;\n",
       "    color: rgb(0, 80, 120);\n",
       "    margin-bottom: 0.1em;\n",
       "    margin-top: 0.1em;\n",
       "    display: block;\n",
       "}\t\n",
       ".text_cell_render h2 {\n",
       "    font-family: 'Philosopher', serif;\n",
       "    font-weight: 400;\n",
       "    font-size: 1.9em;\n",
       "    line-height: 100%;\n",
       "    color: rgb(200,100,0);\n",
       "    margin-bottom: 0.1em;\n",
       "    margin-top: 0.1em;\n",
       "    display: block;\n",
       "}\t\n",
       "\n",
       ".text_cell_render h3 {\n",
       "    font-family: 'Philosopher', serif;\n",
       "    margin-top:12px;\n",
       "    margin-bottom: 3px;\n",
       "    font-style: italic;\n",
       "    color: rgb(94,127,192);\n",
       "}\n",
       "\n",
       ".text_cell_render h4 {\n",
       "    font-family: 'Philosopher', serif;\n",
       "}\n",
       "\n",
       ".text_cell_render h5 {\n",
       "    font-family: 'Alegreya Sans', sans-serif;\n",
       "    font-weight: 300;\n",
       "    font-size: 16pt;\n",
       "    color: grey;\n",
       "    font-style: italic;\n",
       "    margin-bottom: .1em;\n",
       "    margin-top: 0.1em;\n",
       "    display: block;\n",
       "}\n",
       "\n",
       ".text_cell_render h6 {\n",
       "    font-family: 'PT Mono', sans-serif;\n",
       "    font-weight: 300;\n",
       "    font-size: 10pt;\n",
       "    color: grey;\n",
       "    margin-bottom: 1px;\n",
       "    margin-top: 1px;\n",
       "}\n",
       "\n",
       ".CodeMirror{\n",
       "        font-family: \"PT Mono\";\n",
       "        font-size: 100%;\n",
       "}\n",
       "\n",
       "</style>\n",
       "\n"
      ],
      "text/plain": [
       "HTML{ASCIIString}(\"<link href='http://fonts.googleapis.com/css?family=Alegreya+Sans:100,300,400,500,700,800,900,100italic,300italic,400italic,500italic,700italic,800italic,900italic' rel='stylesheet' type='text/css'>\\n<link href='http://fonts.googleapis.com/css?family=Arvo:400,700,400italic' rel='stylesheet' type='text/css'>\\n<link href='http://fonts.googleapis.com/css?family=PT+Mono' rel='stylesheet' type='text/css'>\\n<link href='http://fonts.googleapis.com/css?family=Shadows+Into+Light' rel='stylesheet' type='text/css'>\\n<link href='http://fonts.googleapis.com/css?family=Philosopher:400,700,400italic,700italic' rel='stylesheet' type='text/css'>\\n\\n<style>\\n\\n@font-face {\\n    font-family: \\\"Computer Modern\\\";\\n    src: url('http://mirrors.ctan.org/fonts/cm-unicode/fonts/otf/cmunss.otf');\\n}\\n\\n#notebook_panel { /* main background */\\n    background: #ddd;\\n    color: #000000;\\n}\\n\\n\\n\\n/* Formatting for header cells */\\n.text_cell_render h1 {\\n    font-family: 'Philosopher', sans-serif;\\n    font-weight: 400;\\n    font-size: 2.2em;\\n    line-height: 100%;\\n    color: rgb(0, 80, 120);\\n    margin-bottom: 0.1em;\\n    margin-top: 0.1em;\\n    display: block;\\n}\\t\\n.text_cell_render h2 {\\n    font-family: 'Philosopher', serif;\\n    font-weight: 400;\\n    font-size: 1.9em;\\n    line-height: 100%;\\n    color: rgb(200,100,0);\\n    margin-bottom: 0.1em;\\n    margin-top: 0.1em;\\n    display: block;\\n}\\t\\n\\n.text_cell_render h3 {\\n    font-family: 'Philosopher', serif;\\n    margin-top:12px;\\n    margin-bottom: 3px;\\n    font-style: italic;\\n    color: rgb(94,127,192);\\n}\\n\\n.text_cell_render h4 {\\n    font-family: 'Philosopher', serif;\\n}\\n\\n.text_cell_render h5 {\\n    font-family: 'Alegreya Sans', sans-serif;\\n    font-weight: 300;\\n    font-size: 16pt;\\n    color: grey;\\n    font-style: italic;\\n    margin-bottom: .1em;\\n    margin-top: 0.1em;\\n    display: block;\\n}\\n\\n.text_cell_render h6 {\\n    font-family: 'PT Mono', sans-serif;\\n    font-weight: 300;\\n    font-size: 10pt;\\n    color: grey;\\n    margin-bottom: 1px;\\n    margin-top: 1px;\\n}\\n\\n.CodeMirror{\\n        font-family: \\\"PT Mono\\\";\\n        font-size: 100%;\\n}\\n\\n</style>\\n\\n\")"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Setting up a custom stylesheet in IJulia\n",
    "file = open(\"style.css\") # A .css file in the same folder as this notebook file\n",
    "styl = readall(file) # Read the file\n",
    "HTML(\"$styl\") # Output as HTML"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Functions in Julia II"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "<h2>In this lecture</h2>\n",
    "\n",
    "- [Outcome](#Outcome)\n",
    "- [One-line function definition](#One-line-function-definition)\n",
    "- [Multi-line function definition](#Multi-line-function-definition)\n",
    "- [Functions with multiple methods](#Functions-with-multiple-methods)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n",
    "<h2>Outcome</h2>\n",
    "\n",
    "After this lecture, you will be able to: \n",
    "\n",
    "- Define a function using the \"functionname(varlist) = ...\" one-line syntax\n",
    "- Define a function using the \"function name(varlist) ... end\" multiline syntax\n",
    "- Define an additional method for an existing user-defined function\n",
    "- Specify types for input values in a user-defined function\n",
    "- Use workspace() to clear the notebook of all values so that function signatures can be redefined."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Back to the top](#In-this-lecture)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2>One-line function definition</h2>\n",
    "\n",
    "This has an extremely simple form. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "myfunc (generic function with 1 method)"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myfunc(firstvar) = 20*firstvar  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The rules are for defining one-line function are: \n",
    "- the name of the function must be a valid variable name (in this case \"myfunc\" is the name)\n",
    "- the arguments of the function must be valid variable names\n",
    "- the argument must be in parentheses (and as we'll see, multiple arguments must be separated by values)\n",
    "- the name, with arguments in parentheses goes on the left of an assignment\n",
    "- the code for evaluating the function goes on the right.\n",
    "\n",
    "By the way, it's not quite accurate that the code must always fit on one line---it must be a single statement, but so-called compound statements are often written with line breaks, to help the human reader. We will not be using compound statements in one-line functions in this course."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6664.4439999999995"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myfunc(333.2222)       # then we just call it like any other function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here is an illustration of a two-argument function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "addxtoy (generic function with 1 method)"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "addxtoy(x,y) = x + y   # not supposed to be useful! it just shows how the job is done"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10.8"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "addxtoy(33, -22.2)     # mixed types: illustrates that for quick and dirty code, we can (mostly) ignore types"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Back to the top](#In-this-lecture)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2>Multi-line function definition</h2>\n",
    "\n",
    "Let's face it, computing should not be all be done with one-liners. Julia supplies the following syntax for functions that take up multiple lines:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "nextfunc (generic function with 1 method)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function nextfunc(a, b, c)  # this line names your function and specifies the inputs\n",
    "    a*b + c                # here go your (usually quite a few) lines\n",
    "\n",
    "    #  ... just illustrating the possiblity of using white space and additional comments \n",
    "end\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "38"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nextfunc(7,5,3)           # again, just call it like any other function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To illustrate multi-line functions a bit more, here's a useful device for debugging: a line inside a function that gives you the value and the type of a variable. \n",
    "\n",
    "It relies on the escape character \"$\" in strings, which you recall DOESN'T create a dollar sign, but instead modifies how the string is built.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "showdebugprintln (generic function with 1 method)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function showdebugprintln(testvar)\n",
    "    println(\"inside the showdebubprint() now\")   #this line announces where the report is coming from\n",
    "    println(\"The type of testvar is $(typeof(testvar)) and the value of testvar is $testvar\")\n",
    "    #                  and this line reports what value, and hence what type, testvar actually has here\n",
    "end\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "inside the showdebubprint() now\n",
      "The type of testvar is Array{Any,1} and the value of testvar is Any['1',2.0]\n"
     ]
    }
   ],
   "source": [
    "a = ['1',2.]\n",
    "showdebugprintln(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Back to the top](#In-this-lecture)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2>Functions with multiple methods</h2>\n",
    "\n",
    "As we saw in Lecture 8, many code bodies can share one function name. Julia knows which of them is relevant via the type signature. The type signature is simply the list of types of all the variables that are used to call the function. \n",
    "\n",
    "Here is a function that basically parallels the cos function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "mycos (generic function with 1 method)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mycos(x) = cos(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "mycos(.7)  # standard value of cos (angle in radians, of course)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we extend mycos() by providing a function for computing the cosine from the hypotenuse and adjacent side: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "mycos(adj, hyp) = adj/hyp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9230769230769231"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mycos(12, 13)  # the cosine of the larger angle in a standard 5, 12, 13 triangle"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "2 methods for generic function <b>mycos</b>:<ul><li> mycos(x) at In[11]:1<li> mycos(hyp, adj) at In[23]:1</ul>"
      ],
      "text/plain": [
       "# 2 methods for generic function \"mycos\":\n",
       "mycos(x) at In[11]:1\n",
       "mycos(hyp, adj) at In[23]:1"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "methods(mycos)  #Check this carefully!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Again, methods() is your friend. Note especially that each method is given in terms of its input variables."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As with every user-defined function, it is easy for these to go wrong. Suppose we want to make sure the mycos(x) is never called for integer values. We can require the input to be Float64 as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "mycos (generic function with 3 methods)"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mycos(thet::Float64) = cos(thet)   # note  the use of :: to force Julia to check the type "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However, there are now three methods, and integers can still be passed (check this for yourself). We actually intended to replace mycos(x) with mycos(thet::Float64). To do so, first we must clear the old version. Unfortunately, the only way to clear a notebook is to clear everything, by using workspace(). \n",
    "\n",
    "Everything is cleared, so we have to redefine not only mycos(x) but also mycos(adj, hyp):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "mycos (generic function with 1 method)"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "workspace()        # no argument, please!  \n",
    "#        ... clears all the results\n",
    "mycos(thet::Float64) = cos(thet)  # so passing mycos() an integer will now cause Julia to throw an error\n",
    "mycos(hyp, adj)      = adj/hyp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "ename": "LoadError",
     "evalue": "LoadError: MethodError: `mycos` has no method matching mycos(::Int64)\nwhile loading In[47], in expression starting on line 1",
     "output_type": "error",
     "traceback": [
      "LoadError: MethodError: `mycos` has no method matching mycos(::Int64)\nwhile loading In[47], in expression starting on line 1",
      ""
     ]
    }
   ],
   "source": [
    "mycos(1)     # ... this shouldn't work now ..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Back to the top](#In-this-lecture)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Julia 0.4.5",
   "language": "julia",
   "name": "julia-0.4"
  },
  "language_info": {
   "file_extension": ".jl",
   "mimetype": "application/julia",
   "name": "julia",
   "version": "0.4.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}