Intro to Julia.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction to Julia\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Julia is a programming language, suitable for a wide range of things, but especially well-developed for scientific applications. You are currently using a `Jupyter` notebook. Jupyter notebooks are an interactive interface for **ju**lia, **pyt**hon, and **r**, i.e. give it commands, look at the output, give new commands, etc.. Jupyter notebooks are a browser-based interface that can render text, code, and plots in one file, making it possible to produce documents that explain how you develop your model, how your code works, and what the results are. The text cells use [Markdown](https://daringfireball.net/projects/markdown/syntax) for formatting, which is an efficient mark-up language that is now integrated in many platforms.\n",
    "\n",
    "A Jupyter notebook has different types of cells (you can look at the drop down menu above to see what they are). You will mostly use Markdown and Code. Markdown is what you use for formatted text. Code is what you use for, well, code. In either case, using `Shift + Enter` will evaluate the cell (in the case of Markdown, it will format your text). NB RawConvert is for code that's not evaluated. Hitting Enter by itself will start a new line in the same cell.\n",
    "\n",
    "Click on this cell to see the code that produced it. \n",
    "\n",
    "Now evaluate the cell by pressing `Shift + Enter`\n",
    "\n",
    "Now type in the cell below: `this is my first *markdown line*`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also use $\\LaTeX$ in the notebook. Here's an example: $\\int_{x=0}^{x=1} f(x)dx$. Here's a $\\LaTeX$ expression in its own line: $$\\sum_{n=1}^\\inf 1/n$$\n",
    "Here's more about using [Markdown in Jupyter](http://jupyter-notebook.readthedocs.io/en/latest/examples/Notebook/Working%20With%20Markdown%20Cells.html)\n",
    "\n",
    "Ok, let's write some code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# define a variable (in Python, # is the symbol for comments, i.e., stuff that comes after # is not evaluated)\n",
    "x = 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Now when we call up x, Python will give us its value that we just assigned\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element Array{Int64,1}:\n",
       " 6\n",
       " 9\n",
       " 4"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# We can do operations on x (here: multiplication, power, increase by)\n",
    "[2*x, x^2, x+=1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The square brackets `[]` in Julia denote a list, which is a list of things. \n",
    "\n",
    "You can define an array as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2×3 Array{Float64,2}:\n",
       " 0.0  0.0  0.0\n",
       " 0.0  0.0  0.0"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "zeros(Float64, 2, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8×16 Array{Int64,2}:\n",
       " 1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1\n",
       " 1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1\n",
       " 1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1\n",
       " 1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1\n",
       " 1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1\n",
       " 1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1\n",
       " 1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1\n",
       " 1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = ones(Int, 2*x, x^2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Arrays are useful because you can conduct operations on all elemements simultaneously."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8×16 Array{Int64,2}:\n",
       " 2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2\n",
       " 2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2\n",
       " 2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2\n",
       " 2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2\n",
       " 2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2\n",
       " 2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2\n",
       " 2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2\n",
       " 2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2*a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8×16 Array{Int64,2}:\n",
       " 4  4  4  4  4  4  4  4  4  4  4  4  4  4  4  4\n",
       " 4  4  4  4  4  4  4  4  4  4  4  4  4  4  4  4\n",
       " 4  4  4  4  4  4  4  4  4  4  4  4  4  4  4  4\n",
       " 4  4  4  4  4  4  4  4  4  4  4  4  4  4  4  4\n",
       " 4  4  4  4  4  4  4  4  4  4  4  4  4  4  4  4\n",
       " 4  4  4  4  4  4  4  4  4  4  4  4  4  4  4  4\n",
       " 4  4  4  4  4  4  4  4  4  4  4  4  4  4  4  4\n",
       " 4  4  4  4  4  4  4  4  4  4  4  4  4  4  4  4"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(a .+ 1).^ 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that we write `.+` and `.^`. The dot indicates that the operation (addition and power) are performed to each element of `a`. \n",
    "\n",
    "You can also set up an array manually:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2×3 Array{Int64,2}:\n",
       " 2  3  7\n",
       " 4  5  8"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b = [2 3 7; 4 5 8]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can querry elements of arrays using the square brackets:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b[1,3] # return value in row 1 and column 3 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element Array{Int64,1}:\n",
       " 4\n",
       " 5\n",
       " 8"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b[2,:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that the `:` indicates that we want to retrieve all values of row `2`. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ok, now let's model something. Simplest model: geometric population growth, the trajectory of a population growing geormetrically for 100 generations  starting from an initial value 1000, and increasing each generation by a factor of 1.01."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6-element Array{Float64,1}:\n",
       " 1000.0      \n",
       " 1010.0      \n",
       " 1020.1      \n",
       " 1030.301    \n",
       " 1040.60401  \n",
       " 1051.0100501"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pop_hist = zeros(100); # make an array with zeros of length 100 \n",
    "pop_hist[1] = 1000; # set the first element of the array to your initial population size\n",
    "for i in 2:100 # this makes a loop, using the index i, and for each successive value of it from 1 to 99 evaluating what comes after\n",
    "    pop_hist[i] = pop_hist[i-1]*1.01 # takes the previous element of the array (i.e. pop size last time step), multiplies it with 1.01 and assigns that value to the curret position in the array\n",
    "end\n",
    "pop_hist[1:6]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's plot it. To that we need to load the plotting environment Plotly."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "#using Pkg\n",
    "#using Plots\n",
    "#plotlyjs() # Choose the Plotly.jl backend for web interactivity"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "#PlotlyJS.plot(pop_hist)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Done! We have produced a population model, be it simple, in Julia. Note that we could have done this more easily in one line using the fact that Julia knows how to automatically distribute many operations on elements of an array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6-element Array{Float64,1}:\n",
       " 1000.0            \n",
       " 1010.0            \n",
       " 1020.1            \n",
       " 1030.3010000000002\n",
       " 1040.60401        \n",
       " 1051.0100501000002"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pop_hist1 = 1000 .* (1.01 .^ (0:100));\n",
    "pop_hist1[1:6]"
   ]
  }
 ],
 "metadata": {
  "@webio": {
   "lastCommId": null,
   "lastKernelId": null
  },
  "kernelspec": {
   "display_name": "Julia 0.7.0",
   "language": "julia",
   "name": "julia-0.7"
  },
  "language_info": {
   "file_extension": ".jl",
   "mimetype": "application/julia",
   "name": "julia",
   "version": "0.7.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}