MyThinkJulia-Ch16-StructsFunctions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ch 16: Structs and Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, let's practice writing functions that take programmer-defined objects as parameters and return them as results."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "code_folding": []
   },
   "outputs": [],
   "source": [
    "mutable struct MyTime\n",
    "    \n",
    "    hour\n",
    "    minute\n",
    "    second\n",
    "    \n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 16-1\n",
    "\n",
    "Write a function called printtime that takes a MyTime object and prints it in the form hour:minute:second . The\n",
    "@printf macro of the StdLib module Printf prints an integer with the format sequence \"%02d\" using at least two\n",
    "digits, including a leading zero if necessary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "using Printf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "\\begin{verbatim}\n",
       "@printf([io::IOStream], \"%Fmt\", args...)\n",
       "\\end{verbatim}\n",
       "Print \\texttt{args} using C \\texttt{printf} style format specification string, with some caveats: \\texttt{Inf} and \\texttt{NaN} are printed consistently as \\texttt{Inf} and \\texttt{NaN} for flags \\texttt{\\%a}, \\texttt{\\%A}, \\texttt{\\%e}, \\texttt{\\%E}, \\texttt{\\%f}, \\texttt{\\%F}, \\texttt{\\%g}, and \\texttt{\\%G}. Furthermore, if a floating point number is equally close to the numeric values of two possible output strings, the output string further away from zero is chosen.\n",
       "\n",
       "Optionally, an \\href{@ref}{\\texttt{IOStream}} may be passed as the first argument to redirect output.\n",
       "\n",
       "\\section{Examples}\n",
       "\\begin{verbatim}\n",
       "julia> @printf(\"%f %F %f %F\\n\", Inf, Inf, NaN, NaN)\n",
       "Inf Inf NaN NaN\n",
       "\n",
       "\n",
       "julia> @printf \"%.0f %.1f %f\\n\" 0.5 0.025 -0.0078125\n",
       "1 0.0 -0.007813\n",
       "\\end{verbatim}\n"
      ],
      "text/markdown": [
       "```\n",
       "@printf([io::IOStream], \"%Fmt\", args...)\n",
       "```\n",
       "\n",
       "Print `args` using C `printf` style format specification string, with some caveats: `Inf` and `NaN` are printed consistently as `Inf` and `NaN` for flags `%a`, `%A`, `%e`, `%E`, `%f`, `%F`, `%g`, and `%G`. Furthermore, if a floating point number is equally close to the numeric values of two possible output strings, the output string further away from zero is chosen.\n",
       "\n",
       "Optionally, an [`IOStream`](@ref) may be passed as the first argument to redirect output.\n",
       "\n",
       "# Examples\n",
       "\n",
       "```jldoctest\n",
       "julia> @printf(\"%f %F %f %F\\n\", Inf, Inf, NaN, NaN)\n",
       "Inf Inf NaN NaN\n",
       "\n",
       "\n",
       "julia> @printf \"%.0f %.1f %f\\n\" 0.5 0.025 -0.0078125\n",
       "1 0.0 -0.007813\n",
       "```\n"
      ],
      "text/plain": [
       "\u001b[36m  @printf([io::IOStream], \"%Fmt\", args...)\u001b[39m\n",
       "\n",
       "  Print \u001b[36margs\u001b[39m using C \u001b[36mprintf\u001b[39m style format specification string, with some\n",
       "  caveats: \u001b[36mInf\u001b[39m and \u001b[36mNaN\u001b[39m are printed consistently as \u001b[36mInf\u001b[39m and \u001b[36mNaN\u001b[39m for flags \u001b[36m%a\u001b[39m,\n",
       "  \u001b[36m%A\u001b[39m, \u001b[36m%e\u001b[39m, \u001b[36m%E\u001b[39m, \u001b[36m%f\u001b[39m, \u001b[36m%F\u001b[39m, \u001b[36m%g\u001b[39m, and \u001b[36m%G\u001b[39m. Furthermore, if a floating point number is\n",
       "  equally close to the numeric values of two possible output strings, the\n",
       "  output string further away from zero is chosen.\n",
       "\n",
       "  Optionally, an \u001b[36mIOStream\u001b[39m may be passed as the first argument to redirect\n",
       "  output.\n",
       "\n",
       "\u001b[1m  Examples\u001b[22m\n",
       "\u001b[1m  ≡≡≡≡≡≡≡≡≡≡\u001b[22m\n",
       "\n",
       "\u001b[36m  julia> @printf(\"%f %F %f %F\\n\", Inf, Inf, NaN, NaN)\u001b[39m\n",
       "\u001b[36m  Inf Inf NaN NaN\u001b[39m\n",
       "\u001b[36m  \u001b[39m\n",
       "\u001b[36m  \u001b[39m\n",
       "\u001b[36m  julia> @printf \"%.0f %.1f %f\\n\" 0.5 0.025 -0.0078125\u001b[39m\n",
       "\u001b[36m  1 0.0 -0.007813\u001b[39m"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "?@printf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "code_folding": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "printtime (generic function with 1 method)"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function printtime(time)\n",
    "    @printf(\"%02d:%02d:%02d\", time.hour, time.minute, time.second)\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "02:30:40"
     ]
    }
   ],
   "source": [
    "mt = MyTime(2, 30, 40)\n",
    "\n",
    "printtime(mt)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 16-2\n",
    "\n",
    "Write a boolean function called isafter that takes two MyTime objects, t1 and t2 , and returns true if t1 follows t2\n",
    "chronologically and false otherwise. Challenge: don’t use an if statement."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Relational operators work with tuples and other sequences.  Julia starts by comparing the first element from each sequence.  If they are equal, then it goes on to the next element, and so on, until it finds elements that differ.  Subsequent elements are not considered."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "code_folding": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "isafter (generic function with 1 method)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function isafter(t1, t2)\n",
    "  (t1.hour, t1.minute, t1.second) > (t2.hour, t2.minute, t2.second)\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "false"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mt1 = MyTime(10, 20, 30)\n",
    "mt2 = MyTime(10, 21, 29)\n",
    "isafter(mt1, mt2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Pure function and Modifiers\n",
    "\n",
    "* A pure function does not modify any of the objects passed to it as arguments and it has no effects other than returning a value.\n",
    "\n",
    "* A modifier changes the objects it gets as arguments."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 16-3\n",
    "\n",
    "In a development plan called prototype and patch, which is a way of tackling a complex problem by starting with a simple prototype and incrementally dealing with the complications.\n",
    "\n",
    "The following function is a prototype intended to increment time of a MyTime instance:\n",
    "\n",
    "```\n",
    "function increment!(time,seconds)\n",
    "    \n",
    "    time.second += seconds\n",
    "    \n",
    "    if time.second >= 60\n",
    "        time.second -= 60\n",
    "        time.minute += 1\n",
    "    end\n",
    "    \n",
    "    if time.minute >= 60\n",
    "        time.minute -= 60\n",
    "        time.hour += 1\n",
    "    end\n",
    "    \n",
    "end\n",
    "```\n",
    "\n",
    "Is this function correct? What happens if seconds is much greater than 60?  In that case, it is not enough to carry once; we have to keep doing it until time.second is less than sixty. One solution is to replace the if statements with while statements. That would make the function correct, but not very efficient.\n",
    "\n",
    "Write a correct version of increment! that doesn’t contain any loops."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "search: \u001b[0m\u001b[1md\u001b[22m\u001b[0m\u001b[1mi\u001b[22m\u001b[0m\u001b[1mv\u001b[22m\u001b[0m\u001b[1mr\u001b[22m\u001b[0m\u001b[1me\u001b[22m\u001b[0m\u001b[1mm\u001b[22m\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "\\begin{verbatim}\n",
       "divrem(x, y)\n",
       "\\end{verbatim}\n",
       "The quotient and remainder from Euclidean division. Equivalent to \\texttt{(div(x,y), rem(x,y))} or \\texttt{(x÷y, x\\%y)}.\n",
       "\n",
       "\\section{Examples}\n",
       "\\begin{verbatim}\n",
       "julia> divrem(3,7)\n",
       "(0, 3)\n",
       "\n",
       "julia> divrem(7,3)\n",
       "(2, 1)\n",
       "\\end{verbatim}\n"
      ],
      "text/markdown": [
       "```\n",
       "divrem(x, y)\n",
       "```\n",
       "\n",
       "The quotient and remainder from Euclidean division. Equivalent to `(div(x,y), rem(x,y))` or `(x÷y, x%y)`.\n",
       "\n",
       "# Examples\n",
       "\n",
       "```jldoctest\n",
       "julia> divrem(3,7)\n",
       "(0, 3)\n",
       "\n",
       "julia> divrem(7,3)\n",
       "(2, 1)\n",
       "```\n"
      ],
      "text/plain": [
       "\u001b[36m  divrem(x, y)\u001b[39m\n",
       "\n",
       "  The quotient and remainder from Euclidean division. Equivalent to \u001b[36m(div(x,y),\n",
       "  rem(x,y))\u001b[39m or \u001b[36m(x÷y, x%y)\u001b[39m.\n",
       "\n",
       "\u001b[1m  Examples\u001b[22m\n",
       "\u001b[1m  ≡≡≡≡≡≡≡≡≡≡\u001b[22m\n",
       "\n",
       "\u001b[36m  julia> divrem(3,7)\u001b[39m\n",
       "\u001b[36m  (0, 3)\u001b[39m\n",
       "\u001b[36m  \u001b[39m\n",
       "\u001b[36m  julia> divrem(7,3)\u001b[39m\n",
       "\u001b[36m  (2, 1)\u001b[39m"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "?divrem"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "code_folding": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "increment! (generic function with 1 method)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function increment!(time,seconds)\n",
    "    \n",
    "    (add_to_minute, new_second) = divrem(time.second + seconds, 60)\n",
    "    (add_to_hour, new_minute) = divrem(time.minute + add_to_minute, 60)\n",
    "    \n",
    "    time.second = new_second\n",
    "    time.minute = new_minute\n",
    "    time.hour += add_to_hour\n",
    "    \n",
    "end \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "MyTime(10, 24, 30)"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mt3 = MyTime(10,20,50)\n",
    "increment!(mt3, 220)\n",
    "mt3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Anything that can be done with modifiers can also be done with pure functions. In fact, some programming languages only allow pure functions. There is some evidence that programs that use pure functions are faster to develop and less errorprone than programs that use modifiers. But modifiers are convenient at times, and functional programs tend to be less efficient.\n",
    "\n",
    "In general, you are recommended to write pure functions whenever it is reasonable and resort to modifiers only if there is a\n",
    "compelling advantage. This approach might be called a *functional programming style*."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 16-4\n",
    "\n",
    "Write a “pure” version of increment that creates and returns a new MyTime object rather than modifying the parameter."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "code_folding": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "increment (generic function with 1 method)"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function increment(time,seconds)\n",
    "    \n",
    "    (add_to_minute, new_second) = divrem(time.second + seconds, 60)\n",
    "    (add_to_hour, new_minute) = divrem(time.minute + add_to_minute, 60)\n",
    "    \n",
    "    MyTime(time.hour + add_to_hour, new_minute, new_second)\n",
    "    \n",
    "end "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "MyTime(10, 24, 30)"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mt4 = MyTime(10,20,50)\n",
    "mt5 = increment(mt4, 220)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Prototyping Versus Planning\n",
    "\n",
    "“Prototype and patch” approach can be effective, especially if you don’t yet have a deep understanding of the problem. But incremental corrections can generate code that is unnecessarily complicated—since it deals with many special cases—and unreliable — since it is hard to know if you have found all the errors.\n",
    "\n",
    "An alternative is designed development, in which high-level insight into the problem can make the programming much\n",
    "easier. In this case, the insight is that a Time object is really a three-digit number in base 60.\n",
    "\n",
    "This observation suggests another approach to the whole problem—we can convert MyTime objects to integers and take\n",
    "advantage of the fact that the computer knows how to do integer arithmetic.\n",
    "\n",
    "Ironically, sometimes making a problem harder (or more general) makes it easier (because there are fewer special cases and fewer opportunities for error)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 16-5\n",
    "\n",
    "Now, let's rewrite the function \"increment!\" using functions that covert a mytime to an integer and vice versa."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "code_folding": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "inttotime (generic function with 1 method)"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function timetoint(time)\n",
    "    \n",
    "    minutes = time.hour * 60 + time.minute\n",
    "    seconds = minutes * 60 + time.second\n",
    "    \n",
    "end\n",
    "\n",
    "\n",
    "function inttotime(seconds)\n",
    "    \n",
    "    (minutes, second) = divrem(seconds, 60)\n",
    "    (hour, minute) = divrem(minutes, 60)\n",
    "    MyTime(hour, minute, second)\n",
    "    \n",
    "end\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1240"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "timetoint(inttotime(1240))  # consistency check"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "code_folding": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "increment2! (generic function with 1 method)"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function increment2!(time, seconds)\n",
    "    \n",
    "    new_time = inttotime( timetoint(time) + seconds )\n",
    "    \n",
    "    #(time.hour, time.minute, time.second) = (new_time.hour, new_time.minute, new_time.second)\n",
    "    \n",
    "    # I wanted to do it in a bit fancier way\n",
    "    for f in propertynames(time)\n",
    "        setproperty!( time, f, getproperty(new_time,f) )\n",
    "    end\n",
    "    \n",
    "    #time = new_time # This does NOT work as a modifier as the new assignment simply creates a new MyTime instance\n",
    "    \n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(:hour, :minute, :second)"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fieldnames(MyTime)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "MyTime(10, 24, 30)"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mt6 = MyTime(10,20,50)\n",
    "increment2!(mt6, 220)\n",
    "mt6"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Debugging\n",
    "\n",
    "A MyTime object is well-formed if the values of minute and second are between 0 and 60 (including 0 but not 60) and if hour is positive. hour and minute should be integral values, but we might allow second to have a fraction part.\n",
    "\n",
    "Requirements like these are called invariants because they should always be true. To put it a different way, if they are not true, something has gone wrong. Writing code to check invariants can help detect errors and find their causes. For example, you might have a function like isvalidtime that takes a MyTime object and returns false if it violates an invariant:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "isvalidtime (generic function with 1 method)"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function isvalidtime(time)\n",
    "    \n",
    "    if time.hour < 0 || time.minute < 0 || time.second < 0\n",
    "        return false\n",
    "    end\n",
    "    \n",
    "    if time.minute >= 60 || time.second >= 60\n",
    "        return false\n",
    "    end\n",
    "    \n",
    "    true\n",
    "    \n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "At the beginning of each function you could check the arguments to make sure they are valid:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "addtime (generic function with 1 method)"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function addtime(t1, t2)\n",
    "    \n",
    "    if !isvalidtime(t1) || !isvalidtime(t2)\n",
    "        error(\"invalid MyTime object in add_time\")\n",
    "    end\n",
    "    \n",
    "    seconds = timetoint(t1) + timetoint(t2)\n",
    "    inttotime(seconds)\n",
    "    \n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Or you could use an @assert macro, which checks a given invariant and throws an exception if it fails:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "addtime (generic function with 1 method)"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function addtime(t1, t2)\n",
    "    \n",
    "    @assert(isvalidtime(t1) && isvalidtime(t2), \"invalid MyTime object in add_time\")\n",
    "    seconds = timetoint(t1) + timetoint(t2)\n",
    "    inttotime(seconds)\n",
    "    \n",
    "end"
   ]
  }
 ],
 "metadata": {
  "@webio": {
   "lastCommId": null,
   "lastKernelId": null
  },
  "kernelspec": {
   "display_name": "Julia 1.2.0",
   "language": "julia",
   "name": "julia-1.2"
  },
  "language_info": {
   "file_extension": ".jl",
   "mimetype": "application/julia",
   "name": "julia",
   "version": "1.2.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}