Programming_Flows.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# IV. Programming Flows"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can implement basic control structures in your code. Here we'll cover the most important ones: the __if__ statement, the __for__ loop, and the __while__ loop."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The basic structure of the **if** statement is <br>\n",
    "<br>\n",
    "__if__ *expression* <br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;*statements* <br>\n",
    "__end__ <br>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a is greater than b\n"
     ]
    }
   ],
   "source": [
    "a = 4; b = 3;\n",
    "\n",
    "if a > b\n",
    "    println(\"a is greater than b\")\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can add an additional branch using __else__:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a is greater than b\n"
     ]
    }
   ],
   "source": [
    "if a > b\n",
    "    println(\"a is greater than b\")\n",
    "else\n",
    "    println(\"b is greater than or equal to a\")\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you need more than two branches you can add (multiple) __elseif__ statements:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "b is greater than a\n"
     ]
    }
   ],
   "source": [
    "a = 2; b = 4;\n",
    "\n",
    "if a > b\n",
    "    println(\"a is greater than b\")\n",
    "elseif b > a\n",
    "    println(\"b is greater than a\")\n",
    "else\n",
    "    println(\"a and b are equal\")\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We'll next look at the __for__ loop and for that we'll use Julia's *Distributions.jl* package to generate some randomn numbers from the Poisson distribution."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "#using Pkg; Pkg.add( \"Distributions\" )\n",
    "using Random, Distributions\n",
    "\n",
    "#=\n",
    "First set the seed\n",
    "Then generate 20 random numbers from a Poisson distribution with rate parameter 2 \n",
    "And multiply by 1 or -1 element-wise.\n",
    "=#\n",
    "\n",
    "Random.seed!(723) # Setting the seed\n",
    "x = rand(Poisson(2), 20) .* rand([-1, 1], 20); \n",
    "#x = [-4, -3, 1, 1, 1, 5, -5, -3, -3, 2, -2, 0, 2, 0, -2, -4, -3, -2, 2, 2];"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-1, 4, 1, 1, 0, 0, 1, -2, 0, -4, -1, -1, 1, 0, 1, -2, 2, 0, -3, -2]\n"
     ]
    }
   ],
   "source": [
    "println(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The basic structure of the **for** loop is <br>\n",
    "<br>\n",
    "__for__ *variable = expression* <br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;*statements* <br>\n",
    "__end__ <br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The __for__ loop is convenient for iterating over a block of code. Let's suppose we wanted to create a new array called __y__ which was equal to the exponentiation of each element of the array __x__. We could use a __for__ loop to do this."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "y = zeros(length(x));\n",
    "\n",
    "for j in 1:length(x)\n",
    "    y[j] = exp(x[j])\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.36787944117144233, 54.598150033144236, 2.718281828459045, 2.718281828459045, 1.0, 1.0, 2.718281828459045, 0.1353352832366127, 1.0, 0.01831563888873418, 0.36787944117144233, 0.36787944117144233, 2.718281828459045, 1.0, 2.718281828459045, 0.1353352832366127, 7.38905609893065, 1.0, 0.049787068367863944, 0.1353352832366127]\n"
     ]
    }
   ],
   "source": [
    "println(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Related to the __for__ loop is something called an *array comprehension*. It can be a convenient syntax for doing something iteratively. Julia has array comprehensions built into it. To do something like the above for loop using an array comprehension you would do:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.36787944117144233, 54.598150033144236, 2.718281828459045, 2.718281828459045, 1.0, 1.0, 2.718281828459045, 0.1353352832366127, 1.0, 0.01831563888873418, 0.36787944117144233, 0.36787944117144233, 2.718281828459045, 1.0, 2.718281828459045, 0.1353352832366127, 7.38905609893065, 1.0, 0.049787068367863944, 0.1353352832366127]\n"
     ]
    }
   ],
   "source": [
    "z = [exp(el) for el in x]\n",
    "\n",
    "println(z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note you could've also done the same thing using dot notation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.36787944117144233, 54.598150033144236, 2.718281828459045, 2.718281828459045, 1.0, 1.0, 2.718281828459045, 0.1353352832366127, 1.0, 0.01831563888873418, 0.36787944117144233, 0.36787944117144233, 2.718281828459045, 1.0, 2.718281828459045, 0.1353352832366127, 7.38905609893065, 1.0, 0.049787068367863944, 0.1353352832366127]\n"
     ]
    }
   ],
   "source": [
    "u = exp.(x)\n",
    "println(u)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The last control structure we'll cover here is the __while__ loop. It's basic structure is <br>\n",
    "<br>\n",
    "__while__ *expression* <br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;*statements* <br>\n",
    "__end__ <br>\n",
    "\n",
    "The __while__ loop is used to iterate over a block of code while the *expression* is __true__."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iter 20 : true\n",
      "Iter 19 : false\n",
      "Iter 18 : true\n",
      "Iter 17 : true\n",
      "Iter 16 : true\n",
      "Iter 15 : true\n",
      "Iter 14 : false\n",
      "Iter 13 : true\n",
      "Iter 12 : false\n",
      "Iter 11 : false\n",
      "Iter 10 : true\n",
      "Iter 9 : false\n",
      "Iter 8 : true\n",
      "Iter 7 : false\n",
      "Iter 6 : true\n",
      "Iter 5 : false\n",
      "Iter 4 : true\n",
      "Iter 3 : false\n",
      "Iter 2 : false\n",
      "Iter 1 : false\n"
     ]
    }
   ],
   "source": [
    "x = randn(20);\n",
    "count = 20\n",
    "\n",
    "while count > 0\n",
    "    println(\"Iter $count : \", x[count] > 0)\n",
    "    count -= 1 \n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exercise 4\n",
    "* Generate a one-dimensional array of 30 numbers using rand called *a*.\n",
    "* Use a for loop to create a new array called *b* that is the log of each element of *a*.\n",
    "* Use an array comprehension to create a new array called *c* that is the square of element of *b*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this lesson we covered:\n",
    "\n",
    "* Common programming flows: if statement, for loops, while loops\n",
    "* Array comprehensions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Julia 1.8.0",
   "language": "julia",
   "name": "julia-1.8"
  },
  "language_info": {
   "file_extension": ".jl",
   "mimetype": "application/julia",
   "name": "julia",
   "version": "1.8.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}