2. Julia Functions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Defining functions\n",
    "\n",
    "Julia function definitions syntax is pretty standard:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "doubler (generic function with 1 method)"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function doubler(x)\n",
    "    return 2x  # okay to have literal * variable without *\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(4,12)"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "doubler(2), doubler(6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But we can also omit some syntax in the interest of making things shorter:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tripler (generic function with 1 method)"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function tripler(x)\n",
    "    3x  # implicit return\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(10.5,6)"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tripler(3.5), tripler(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "halver (generic function with 1 method)"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "halver(x) = x//2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(5//2,2//1)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "halver(5), halver(4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And finally, for the functional crowd:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(anonymous function)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "firstelem = x -> x[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'t'"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "firstelem(\"tester\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Pass by sharing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In Python, particularly NumPy, we don't default to copies when passing function arguments. Julia works the same way."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5x5 Array{Float64,2}:\n",
       " 0.339317  0.868068  0.0285906  0.383576  0.88558  \n",
       " 0.797496  0.033205  0.206466   0.629436  0.883407 \n",
       " 0.397588  0.479591  0.295639   0.535099  0.0230995\n",
       " 0.056555  0.538183  0.204241   0.805164  0.999334 \n",
       " 0.959375  0.397445  0.922842   0.382563  0.904041 "
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = rand(5, 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "zerodiag! (generic function with 1 method)"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function zerodiag!(x)\n",
    "    for i in 1:maximum(size(x))  # it's okay (and fast!) to write a loop\n",
    "        x[i, i] = 0\n",
    "    end\n",
    "    return x\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5x5 Array{Float64,2}:\n",
       " 0.0       0.868068  0.0285906  0.383576  0.88558  \n",
       " 0.797496  0.0       0.206466   0.629436  0.883407 \n",
       " 0.397588  0.479591  0.0        0.535099  0.0230995\n",
       " 0.056555  0.538183  0.204241   0.0       0.999334 \n",
       " 0.959375  0.397445  0.922842   0.382563  0.0      "
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B = zerodiag!(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(\n",
       "5x5 Array{Float64,2}:\n",
       " 0.0       0.868068  0.0285906  0.383576  0.88558  \n",
       " 0.797496  0.0       0.206466   0.629436  0.883407 \n",
       " 0.397588  0.479591  0.0        0.535099  0.0230995\n",
       " 0.056555  0.538183  0.204241   0.0       0.999334 \n",
       " 0.959375  0.397445  0.922842   0.382563  0.0      ,\n",
       "\n",
       "5x5 Array{Float64,2}:\n",
       " 0.0       0.868068  0.0285906  0.383576  0.88558  \n",
       " 0.797496  0.0       0.206466   0.629436  0.883407 \n",
       " 0.397588  0.479591  0.0        0.535099  0.0230995\n",
       " 0.056555  0.538183  0.204241   0.0       0.999334 \n",
       " 0.959375  0.397445  0.922842   0.382563  0.0      )"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B, A"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Splatting and slurping (varargs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It can be useful to package multiple inputs to a function into an interable (cf. `*args`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "parser (generic function with 1 method)"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function parser(var, val, rest...) \n",
    "    println(\"variable name: $var\")\n",
    "    println(\"variable value: $val\")\n",
    "    println(rest)\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "variable name: x\n",
      "variable value: 5\n",
      "(7,8,\"foo\")\n"
     ]
    }
   ],
   "source": [
    "parser(:x, 5, 7, 8, \"foo\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Conversely, we'd like to be able to \"splat\" a collection into separate arguments for passing to a function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "randlike (generic function with 1 method)"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function randlike(A)\n",
    "    sizetup = size(A)\n",
    "    return rand(sizetup...)\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5-element Array{Float64,1}:\n",
       " 0.239124\n",
       " 0.946497\n",
       " 0.315101\n",
       " 0.481288\n",
       " 0.422785"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "randlike(ones(5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Defaults and keyword arguments\n",
    "\n",
    "Julia supports two common use cases we know from Python: defaults and keyword arguments. These are a little less flexible than in Python but allow for effective compilation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Lpnorm (generic function with 2 methods)"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function Lpnorm(x, p=2)\n",
    "    return sum(x.^p)^(1/p)\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note **two** methods! We'll come back to this."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1.447976030767568,1.447976030767568,3.6510042638287827)"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "aa = rand(10)\n",
    "norm(aa), Lpnorm(aa), Lpnorm(aa, 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also use keywords:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "makecircle (generic function with 2 methods)"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function makecircle(x, y, radius=1; color=\"black\", fill=color)  # later kwargs can use values of previous\n",
    "    println(\"$color circle of radius $radius centered at ($x, $y) with $fill border\")\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "black circle of radius 1 centered at (0, 0) with black border\n"
     ]
    }
   ],
   "source": [
    "makecircle(0, 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "black circle of radius 5 centered at (0, 0) with black border\n"
     ]
    }
   ],
   "source": [
    "makecircle(0, 0, 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "blue circle of radius 1 centered at (0, 0) with blue border\n"
     ]
    }
   ],
   "source": [
    "makecircle(0, 0, color=\"blue\")  # no semicolon needed"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "makecircle(0, 0, 5, \"blue\", \"green\")  # error: kwargs are keyword *only*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As we'll see, Julia is less flexible about keyword vs. positional arguments because this is required to keep multiple dispatch sane."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Multimethods, dispatch (teaser)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Each case above could basically work in Python. In fact, we can do something very like duck typing:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "lastelem (generic function with 1 method)"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lastelem(x) = x[end]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(5,6,'r')"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lastelem(1:5), lastelem([2, 4, 6]), lastelem(\"foobar\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But what if we needed some special casing:"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "doubler(\"foo\")  # will fail"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We'd like to be able to solve a few problems:\n",
    "\n",
    "- let `doubler` handle multiple cases, depending on input\n",
    "- extend `doubler` if it's not our function\n",
    "\n",
    "In Python and other object-oriented languages, this is solved with classes. Classes dispatch on instances (i.e., based on `self`). In Julia, we'll solve this problem with multiple dispatch.\n",
    "\n",
    "First, however, we need to understand how types work in Julia."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Julia 0.4.6",
   "language": "julia",
   "name": "julia-0.4"
  },
  "language_info": {
   "file_extension": ".jl",
   "mimetype": "application/julia",
   "name": "julia",
   "version": "0.4.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}