6. Functions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Functions\n",
    "Suppose you want to make 100 statues with the exact same design what will you do? Will you make each statue manually or make a mould of it? Naturally, we will create a mould, then we can put some material in the mould like cement or silicon and do some process to dry it and the statue will be ready. What is happening here is we are defining some process some structure which can be used n number of times.\n",
    " \n",
    "That is what functions are for, they are a small block of code which performs some operation on the value supplied and returns a result. In the above example material of the statue can be different (as long as it can be moulded) but every time the design of the statue will be the same.\n",
    " \n",
    "The value(s) which we pass are called `arguments` and the result is called `return value`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Declaring function\n",
    "There are different ways to declare a function in Julia\n",
    "### 1. using `function` and `end`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "greetings (generic function with 1 method)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function greetings(name)\n",
    "    println(\"Yo $name ! congrats you just called a function :D\")\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Yo shriaas ! congrats you just called a function :D\n"
     ]
    }
   ],
   "source": [
    "name = \"shriaas\"\n",
    "greetings(name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "square (generic function with 1 method)"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Another example could be\n",
    "function square(num)\n",
    "     num*num\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Square of 1233 is 1520289"
     ]
    }
   ],
   "source": [
    "print(\"Square of 1233 is $(square(1233))\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you are familiar with other programming languages you may have noticed that we have not use `return` keyword here still the `square()` function in returning `x*x`. This is because in Julia by default the value of last evaluated expression is returned. However we can still use `return` for the same."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. Using variable functions.\n",
    "\n",
    "\n",
    "Alternatively, we can declare these function just using single line:\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "greetings2 (generic function with 1 method)"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "greetings2(name) = println(\"Yo $name ! congrats you just called a function :D\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "square2 (generic function with 1 method)"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "square2(num) = num*num"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And we can call these function in the same way."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Yo shriaas ! congrats you just called a function :D\n"
     ]
    }
   ],
   "source": [
    "greetings2(\"shriaas\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1495729"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "square2(1223)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3. Using anonymous or lamda function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "#5 (generic function with 1 method)"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "greetings3 = name -> println(\"Yo $name ! congrats you just called a function :D\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "#7 (generic function with 1 method)"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "square3 = x -> x*x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Yo shriaas ! congrats you just called a function :D\n"
     ]
    }
   ],
   "source": [
    "greetings3(\"shriaas\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "149940025"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "square2(12245)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Duck-typing in Julia\n",
    "\n",
    "\"if it quacks like a duck, its probably a duck.\"\n",
    "\n",
    "For example `greetings` will work on integers too:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Yo 12334 ! congrats you just called a function :D\n"
     ]
    }
   ],
   "source": [
    "greetings(12334)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And square will work on (square) matrix."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4×5 Array{Float64,2}:\n",
       " 0.530877   0.0843614  0.740561  0.665325  0.372336\n",
       " 0.121052   0.324279   0.919054  0.180864  0.370499\n",
       " 0.0300167  0.110627   0.647003  0.852146  0.809009\n",
       " 0.0848047  0.482157   0.109274  0.206453  0.704273"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Mat = rand(4,4)\n",
    "Mat2 = rand(4,5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4×4 Array{Float64,2}:\n",
       " 0.801041  0.284761  0.106364   0.262769\n",
       " 0.296704  0.74049   0.0467148  0.347654\n",
       " 0.454762  0.476742  0.107335   0.361674\n",
       " 0.882785  0.631514  0.150843   0.5257"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "square(Mat)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "ename": "DimensionMismatch",
     "evalue": "DimensionMismatch(\"A has dimensions (4,5) but B has dimensions (4,5)\")",
     "output_type": "error",
     "traceback": [
      "DimensionMismatch(\"A has dimensions (4,5) but B has dimensions (4,5)\")",
      "",
      "Stacktrace:",
      " [1] gemm_wrapper!(::Array{Float64,2}, ::Char, ::Char, ::Array{Float64,2}, ::Array{Float64,2}, ::LinearAlgebra.MulAddMul{true,true,Bool,Bool}) at /home/buildbot/build-worker/worker/juliapro-release-centos7-0_6/build/tmp_julia/share/julia/stdlib/v1.4/LinearAlgebra/src/matmul.jl:569",
      " [2] mul! at /home/buildbot/build-worker/worker/juliapro-release-centos7-0_6/build/tmp_julia/share/julia/stdlib/v1.4/LinearAlgebra/src/matmul.jl:169 [inlined]",
      " [3] mul! at /home/buildbot/build-worker/worker/juliapro-release-centos7-0_6/build/tmp_julia/share/julia/stdlib/v1.4/LinearAlgebra/src/matmul.jl:208 [inlined]",
      " [4] * at /home/buildbot/build-worker/worker/juliapro-release-centos7-0_6/build/tmp_julia/share/julia/stdlib/v1.4/LinearAlgebra/src/matmul.jl:160 [inlined]",
      " [5] square(::Array{Float64,2}) at ./In[9]:3",
      " [6] top-level scope at In[27]:1"
     ]
    }
   ],
   "source": [
    "square(Mat2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The reason is that square of a matrix is a well defined operation i.e multiplying matrix by itself.\n",
    "But rectangular matrix can't be multiplied by itself because of matrix multiplication properties."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Mutating vs. non-mutating functions\n",
    "\n",
    "By convention, functions followed by `!` alter their contents and function without `!` do not.\n",
    "\n",
    "For example let's compare `sort` and `sort!`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7-element Array{Int64,1}:\n",
       "  7\n",
       " 12\n",
       " 10\n",
       "  1\n",
       " 11\n",
       "  7\n",
       " 18"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v = rand(1:20,7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7-element Array{Int64,1}:\n",
       "  1\n",
       "  7\n",
       "  7\n",
       " 10\n",
       " 11\n",
       " 12\n",
       " 18"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sort(v)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7-element Array{Int64,1}:\n",
       "  7\n",
       " 12\n",
       " 10\n",
       "  1\n",
       " 11\n",
       "  7\n",
       " 18"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7-element Array{Int64,1}:\n",
       "  1\n",
       "  7\n",
       "  7\n",
       " 10\n",
       " 11\n",
       " 12\n",
       " 18"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sort!(v)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7-element Array{Int64,1}:\n",
       "  1\n",
       "  7\n",
       "  7\n",
       " 10\n",
       " 11\n",
       " 12\n",
       " 18"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "See here `sort(v)` didn't changes `v` but `sort!(v)` did.\n",
    "Remember we used `push!` and `pop!` to add and delete elements in data structures?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Broadcasting\n",
    "\n",
    "We can use `.` between any function and its list of arguments to tell that function to broadcat over elements of input objects.\n",
    "\n",
    "Let's compare `f()` and  `f.()`.\n",
    "\n",
    "Lets define a matrix first:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4×4 Array{Int64,2}:\n",
       "  7  4   5  1\n",
       "  9  8   6  3\n",
       "  8  4   7  6\n",
       " 10  2  10  5"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Mat = rand(1:10,4,4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4×4 Array{Int64,2}:\n",
       " 135   82  104   54\n",
       " 213  130  165   84\n",
       " 208  104  173   92\n",
       " 218  106  182  101"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "square(Mat)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Like we saw before `square(Mat)` we just multiply `Mat` with itself i.e it treats `Mat` as a single object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4×4 Array{Int64,2}:\n",
       "  49  16   25   1\n",
       "  81  64   36   9\n",
       "  64  16   49  36\n",
       " 100   4  100  25"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "square.(Mat)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "While `square.(Mat)` will result in square of each element."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So now we can use `square()` with rectangular matrix too!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4×8 Array{Int64,2}:\n",
       " 3  4  6   7  6  10  7   1\n",
       " 4  7  1   4  8   8  3  10\n",
       " 1  3  2  10  2   8  5   7\n",
       " 4  8  3   7  4   5  6   8"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Mat2 = rand(1:10,4,8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4×8 Array{Int64,2}:\n",
       "  9  16  36   49  36  100  49    1\n",
       " 16  49   1   16  64   64   9  100\n",
       "  1   9   4  100   4   64  25   49\n",
       " 16  64   9   49  16   25  36   64"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "square.(Mat2)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Julia 1.4.1",
   "language": "julia",
   "name": "julia-1.4"
  },
  "language_info": {
   "file_extension": ".jl",
   "mimetype": "application/julia",
   "name": "julia",
   "version": "1.4.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}