5. Conditions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Conditional Statements\n",
    "\"if this then that\"\n",
    "\n",
    "To make any decision in life we first analyze conditions and depending on that we take actions. For eg. **if** you want great performance with simplicity in writing code, **then** learn Julia.\n",
    "\n",
    "There are multiple ways of checking conditions in Julia\n",
    "1. `if`-`elseif`-`else`\n",
    "2. Ternary operator `?:`\n",
    "3. Short-Circuit evaluation `&&`,`||` and chained comparisons.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## if-else-if\n",
    "This the simplest mechanisim which is used by most of the languages.\n",
    "Syntax: \n",
    "```julia\n",
    "if *condition1*\n",
    "    #do something\n",
    "elseif *condition2*\n",
    "    #do something\n",
    "else\n",
    "   #do something\n",
    "end\n",
    "\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "23 is less than 42\n"
     ]
    }
   ],
   "source": [
    "# Example to compare 2 numbers\n",
    "a = 23\n",
    "b = 42\n",
    "\n",
    "if a > b\n",
    "    println(\"$a is greater than $b\")\n",
    "elseif a < b\n",
    "    println(\"$a is less than $b\")\n",
    "else\n",
    "    println(\"$a is equal to $b\")\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `elseif` and `else` blocks are optional, and as many `elseif` blocks as desired can be used. The condition expressions in the `if`-`elseif`-`else` construct are evaluated until the first one evaluates to true, after which the associated block is evaluated, and no further condition expressions or blocks are evaluated.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ternary operator\n",
    "ternary operator  `?:` is closely related to the `if`-`elseif`-`else` syntax, but is used where a conditional choice between single expression values is required, as opposed to conditional execution of longer blocks of code.\n",
    "\n",
    "Syntax:\n",
    "```julia\n",
    "x ? y : z\n",
    "```\n",
    "Here expression `x` before `?` is a condition.\n",
    "If `x` is true expression `y` which is before `:` is evaluated otherwise `z` which is after `:` is evaluated."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "less than\n",
      "equal to\n"
     ]
    }
   ],
   "source": [
    "# We can write the first example as:\n",
    "println(a < b ? \"less than\" : \"not less than\")\n",
    "\n",
    "# Or like\n",
    "a = b = 7\n",
    "println(a < b ? \"less than\" : (a > b ? \"greater than\" : \"equal to\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here if `a < b` evaluates to false control will go over to expression after `:` which is another ternary operator."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " Ternary operators can come handy many times. For example suppose we have a counter variable to store seconds which resets to 0 after reaching 59.\n",
    " We can just write:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "29"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#some code\n",
    "counter = 28\n",
    "counter = counter == 59 ? 0 : counter+1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "counter = 59\n",
    "counter = counter == 59 ? 0 : counter+1\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Short-Circuit Evaluation\n",
    "\n",
    "A fun related trick is short-circuit evaluation with syntax.\n",
    "\n",
    "`x && y`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20 is less than 34\n"
     ]
    }
   ],
   "source": [
    "a, b = 20,34\n",
    "(a > b) && println(\"$a is greater than $b\")\n",
    "(a < b) && println(\"$a is less than $b\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You may have seen `&&` in languages like C or Java etc.\n",
    "`y` will only be executed if `x` is evaluated  to `true`.\n",
    "So in this case print statement will only be executed if the condition preceeding it is true"
   ]
  }
 ],
 "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
}