Classes/dayone.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# **Julia** workshop"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**How to proceed with the course?**\n",
    "\n",
    "1. Clone this repository ```git clone https://github.com/Leticia-maria/Introduction.jl.git```\n",
    "2. In the folder called ```classes``` you will find the notebooks for each class\n",
    "3. Open the notebooks and follow the instructions\n",
    "4. In the folder ```practice``` you will find exercises to practice what you have learned\n",
    "5. In the ```issues``` tab you will find the questions and answers for each class (open yours there :smile:)\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Level of this workshop: **Beginner**\n",
    "\n",
    "### __(You are all welcome to work together and learn)__"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> ## In this workshop, you will see:\n",
    "\n",
    "- ### a brief background of Julia Language\n",
    "- ### what are the advantages implemented in Julia\n",
    "- ### some applications in chemistry\n",
    "- ### some applications in machine learning\n",
    "- ### a brief and fun hands-on\n",
    "- ### how the julia community works"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The objective of this workshop is **not** to make you an expert in Julia, but to inspire you starting applying julia in your projects, studies or research!"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![History](../assets/JuliaHistory.png)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Julia language is a compiled programming language released in 2012!"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Julia Repository](https://github.com/JuliaLang/julia)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **Curious fact** \n",
    "\n",
    "#### Why the programming language is called Julia?"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](../assets/WhyJulia.png)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Some good points about Julia"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](../assets/Paper.png)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- ### Speed \n",
    "- ### Multiple dispatch\n",
    "- ### Dynamic type system\n",
    "- ### Metaprogramming\n",
    "- ### Built-in package manager\n",
    "- ### Built-in test\n",
    "- ### Built-in documentation\n",
    "- ### Built-in parallelism\n",
    "- ### Built-in distributed computing\n",
    "- ### Built-in GPU support\n",
    "- ### Built-in multithreading"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## **Julia poll (version installed)**"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **Configuring Julia**\n",
    "- show the REPL\n",
    "- show ```config``` folder"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Julia configuration file ```.julia/config/startup.jl```"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## How to use libraries in Julia (showing Package Manager)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Speed can become important when you are trying to solve many body problem in Physics and Chemistry."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **Just in time compilation**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "pos (generic function with 1 method)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "pos(x) = x < zero(x) ? zero(x) : x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.0"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "pos(-1.0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[90m;  @ /Users/leticiamadureira/Introduction.jl/Classes/dayone.ipynb:1 within `pos`\u001b[39m\n",
      "\u001b[95mdefine\u001b[39m \u001b[36mdouble\u001b[39m \u001b[93m@julia_pos_3125\u001b[39m\u001b[33m(\u001b[39m\u001b[36mdouble\u001b[39m \u001b[0m%0\u001b[33m)\u001b[39m \u001b[0m#0 \u001b[33m{\u001b[39m\n",
      "\u001b[91mtop:\u001b[39m\n",
      "  \u001b[0m%.inv \u001b[0m= \u001b[96m\u001b[1mfcmp\u001b[22m\u001b[39m \u001b[96m\u001b[1molt\u001b[22m\u001b[39m \u001b[36mdouble\u001b[39m \u001b[0m%0\u001b[0m, \u001b[33m0.000000e+00\u001b[39m\n",
      "  \u001b[0m%1 \u001b[0m= \u001b[96m\u001b[1mselect\u001b[22m\u001b[39m \u001b[36mi1\u001b[39m \u001b[0m%.inv\u001b[0m, \u001b[36mdouble\u001b[39m \u001b[33m0.000000e+00\u001b[39m\u001b[0m, \u001b[36mdouble\u001b[39m \u001b[0m%0\n",
      "  \u001b[96m\u001b[1mret\u001b[22m\u001b[39m \u001b[36mdouble\u001b[39m \u001b[0m%1\n",
      "\u001b[33m}\u001b[39m\n"
     ]
    }
   ],
   "source": [
    "@code_llvm pos(-1.0)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Runnning a for loop in python (scaling at ($O(n^2)$))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```python\n",
    "import numpy as np\n",
    "import timeit\n",
    "np.random.seed(0)\n",
    "values = np.random.randint(1, 100, size=1000000)\n",
    "def getReciprocal(values):\n",
    "    output = np.empty(len(values))\n",
    "    \n",
    "    for i in range(len(values)):\n",
    "        output[i] = 1.0/values[i]\n",
    "\n",
    "duration = timeit.repeat(\n",
    "    \"getReciprocal(values)\", - \n",
    "    \"from __main__ import getReciprocal, values\",\n",
    "    number=1,\n",
    "    repeat=7\n",
    ")\n",
    "\n",
    "print(duration)\n",
    "1.73 s +- 16.5 ms per loop\n",
    "```"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```julia\n",
    "function getReciprocal2(values)\n",
    "    output = Vector{Float64}(undef, length(values))\n",
    "    \n",
    "    for i in eachindex(values)\n",
    "        @inbounds output[i] = 1.0 / values[1]\n",
    "    end\n",
    "    \n",
    "    return output\n",
    "end\n",
    "\n",
    "@btime getReciprocal2(values)\n",
    "\n",
    "--------------\n",
    "minimum time:    1.099 microseconds (0.00% GC)\n",
    "--------------\n",
    "```"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```julia\n",
    "import Pkg\n",
    "Pkg.add(\"BenchmarkTools\")\n",
    "using BenchmarkTools\n",
    "using Random\n",
    "using LinearAlgebra\n",
    "Random.seed!(0)\n",
    "values =  rand(1:100, 1, 1000000)\n",
    "function getReciprocal(values)\n",
    "    output = zeros(1, 1000000)\n",
    "    for i in 1:length(values)\n",
    "        output[i] = 1.0/values[i]\n",
    "    end\n",
    "end\n",
    "\n",
    "@btime getReciprocal(values)\n",
    "\n",
    "--------------\n",
    "minimum time:     1.931 ms (0.00% GC)\n",
    "--------------\n",
    "```"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Julia **can be** 1 million times FASTER than Python!"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- ### Syntax"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### high level syntax >> faster to code and learn"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **Purposeful**: \n",
    "- #### numerical programming\n",
    "- #### scientific programming\n",
    "- #### machine learning"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### 1.2. **Print** method "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Julia is a fast language!"
     ]
    }
   ],
   "source": [
    "print(\"Julia is a fast language!\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Now it is your **turn to practice**!"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Activity 1** : Print your own name."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Leticia\n",
      "I am 21 years old\n"
     ]
    }
   ],
   "source": [
    "println(\"Leticia\")\n",
    "println(\"I am 21 years old\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Leticia\n"
     ]
    }
   ],
   "source": [
    "name = \"Leticia\"\n",
    "typeof(name)\n",
    "println(name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Leticia Madureira\n"
     ]
    }
   ],
   "source": [
    "firstname = \"Leticia\"\n",
    "lastname = \"Madureira\"\n",
    "println(firstname*\" \"*lastname)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Activity 2** : Make the computer spell your name with a ```for``` loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Leticia"
     ]
    }
   ],
   "source": [
    "for letter in name\n",
    "    print(letter)\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "L\n",
      "e\n",
      "t\n",
      "i\n",
      "c\n",
      "i\n",
      "a\n"
     ]
    }
   ],
   "source": [
    "for letter in name\n",
    "    println(letter)\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6.283185307179586"
     ]
    }
   ],
   "source": [
    "using LaTeXStrings\n",
    "print(π * 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"I am learning Python!\""
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "sentence = \"I am learning Python!\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4-element Vector{SubString{String}}:\n",
       " \"I\"\n",
       " \"am\"\n",
       " \"learning\"\n",
       " \"Python!\""
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "split(sentence)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "String"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "typeof(\"!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"I am learning Python\""
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "strip(sentence, ['!'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "false"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "occursin(\"Julia\", sentence)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"I am learning Julia!\""
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "replace(sentence, \"Python\" => \"Julia\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "String"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "age = \"21\"\n",
    "typeof(age)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I am 23 years old.\n"
     ]
    }
   ],
   "source": [
    "println(\"I am $(age + 2) years old.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "21"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "age = parse(Int64, age)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Int64"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "typeof(age)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [],
   "source": [
    "using Printf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "π to 3 decimal places is 3.1415926535897931159979634685441851615905761718750000000000000000000000000000000000000000000000000000\n"
     ]
    }
   ],
   "source": [
    "formatted_string = @sprintf(\"π to 3 decimal places is %.100f\", π)\n",
    "println(formatted_string)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- ### Multiple dispatch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Int64"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "integernumber = 2\n",
    "typeof(integernumber)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Float64"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "decimalnumber = 2.5\n",
    "typeof(decimalnumber)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numbertest_deprecated (generic function with 1 method)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "function numbertest_deprecated(N::Int64)\n",
    "    print(N)\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5"
     ]
    }
   ],
   "source": [
    "numbertest(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Float64"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "typeof(3.2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "ename": "MethodError",
     "evalue": "MethodError: no method matching numbertest(::Float64)\n\nClosest candidates are:\n  numbertest(!Matched::Int64)\n   @ Main ~/Introduction.jl/Classes/dayone.ipynb:1\n",
     "output_type": "error",
     "traceback": [
      "MethodError: no method matching numbertest(::Float64)\n",
      "\n",
      "Closest candidates are:\n",
      "  numbertest(!Matched::Int64)\n",
      "   @ Main ~/Introduction.jl/Classes/dayone.ipynb:1\n",
      "\n",
      "\n",
      "Stacktrace:\n",
      " [1] top-level scope\n",
      "   @ ~/Introduction.jl/Classes/dayone.ipynb:1"
     ]
    }
   ],
   "source": [
    "numbertest(3.2)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Julia is a strongly typed language, to read its errors you need to understand how these type system is handled."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "ename": "MethodError",
     "evalue": "MethodError: no method matching numbertest(::Float64)\n\nClosest candidates are:\n  numbertest(!Matched::Int64)\n   @ Main ~/Introduction.jl/Classes/dayone.ipynb:1\n",
     "output_type": "error",
     "traceback": [
      "MethodError: no method matching numbertest(::Float64)\n",
      "\n",
      "Closest candidates are:\n",
      "  numbertest(!Matched::Int64)\n",
      "   @ Main ~/Introduction.jl/Classes/dayone.ipynb:1\n",
      "\n",
      "\n",
      "Stacktrace:\n",
      " [1] top-level scope\n",
      "   @ ~/Introduction.jl/Classes/dayone.ipynb:1"
     ]
    }
   ],
   "source": [
    "numbertest(2.5)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> There is support for ```Int16```, ```Int32```, ```Int64```. (The difference is the usage of bits to allocate it). In the data structures in Julia, all these types are subtypes of ```Integer```."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "Int64 <: Integer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numbertest (generic function with 4 methods)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "function numbertest(N::T) where T <: Integer\n",
    "    print(N)\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numbertest (generic function with 4 methods)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "function numbertest(N::Float64)\n",
    "    print(N)\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.7"
     ]
    }
   ],
   "source": [
    "numbertest(3.7)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **Practice** an example on REPL! >> Let's do it together!"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- print ```integer``` if Int; \n",
    "- print ```float``` if Float."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "Float32 <: Number"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "Integer <: Number"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "It is an integer number!"
     ]
    }
   ],
   "source": [
    "function typeofnumber(N::V) where V <: Number \n",
    "    if typeof(N) <: Integer\n",
    "        print(\"It is an integer number!\")\n",
    "    else\n",
    "        print(\"It is a float!\")\n",
    "    end\n",
    "end\n",
    "\n",
    "typeofnumber(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "typeofnumber (generic function with 5 methods)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "function typeofnumber(N::Int64)\n",
    "    print(\"It is an integer\")\n",
    "end\n",
    "\n",
    "function typeofnumber(N::Float64)\n",
    "    print(\"It is a float\")\n",
    "end\n",
    "\n",
    "function typeofnumber(N::String)\n",
    "    print(\"It is a string, not a number!\")\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "It is a float"
     ]
    }
   ],
   "source": [
    "typeofnumber(4.0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "It is an integer"
     ]
    }
   ],
   "source": [
    "typeofnumber(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "It is a float"
     ]
    }
   ],
   "source": [
    "typeofnumber(4.0)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Julia is flexible, you can create your own types!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.0 + 2.0i It is a complex number!"
     ]
    }
   ],
   "source": [
    "abstract type AbstractComplex end\n",
    "\n",
    "struct Complex <: AbstractComplex\n",
    "    real::Float64\n",
    "    imag::Float64\n",
    "end \n",
    "\n",
    "function typeofnumber(N::Complex)\n",
    "    print(\"$(N.real) + $(N.imag)i It is a complex number!\")\n",
    "end\n",
    "\n",
    "typeofnumber(Complex(3,2))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Reminder \n",
    "- how to submit discussions and answers? "
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **Math** notation"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> You can use Julia with inline expressions."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "def NAME_OF_FUNCTION(ARGS):\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "f (generic function with 1 method)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "function f(x)\n",
    "    y = x + 2\n",
    "    return y\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "f (generic function with 1 method)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "f(x) = x+2 ## this is an expression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "f(2)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Julia also support UNICODES! (what is so fun!)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "f (generic function with 1 method)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "f(θ) = α + β"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "α = 2\n",
    "β = 3\n",
    "A₂ = 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "∏ (generic function with 1 method)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "∑(x) = sum(x) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Σ (generic function with 1 method)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "Σ(x) = sum(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "∏(x) = prod(x) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5-element Vector{Int64}:\n",
       " 1\n",
       " 2\n",
       " 3\n",
       " 4\n",
       " 5"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "values = [1,2,3,4,5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5-element Vector{Int64}:\n",
       " 1\n",
       " 2\n",
       " 3\n",
       " 4\n",
       " 5"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "values = [i for i in 1:5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {},
   "outputs": [
    {
     "ename": "BoundsError",
     "evalue": "BoundsError: attempt to access 5-element Vector{Int64} at index [0]",
     "output_type": "error",
     "traceback": [
      "BoundsError: attempt to access 5-element Vector{Int64} at index [0]\n",
      "\n",
      "Stacktrace:\n",
      " [1] getindex(A::Vector{Int64}, i1::Int64)\n",
      "   @ Base ./essentials.jl:13\n",
      " [2] top-level scope\n",
      "   @ ~/Introduction.jl/Classes/dayone.ipynb:1"
     ]
    }
   ],
   "source": [
    "values[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "values[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "15"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "∑(values)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "120"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "∏(values)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Julia 1.9.0",
   "language": "julia",
   "name": "julia-1.9"
  },
  "language_info": {
   "file_extension": ".jl",
   "mimetype": "application/julia",
   "name": "julia",
   "version": "1.9.0"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}