{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "142e919b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World"
     ]
    }
   ],
   "source": [
    "print(\"Hello World\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "5658f7e6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.3333333333333333"
     ]
    }
   ],
   "source": [
    "print(1/3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "ffca3d9c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "parse(Int64, \"2\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "ae2d0d7f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "add (generic function with 1 method)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function add(x, y)\n",
    "    return x+y\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "b5779c61",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "add(2, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "c717f71d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "func (generic function with 1 method)"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "func(x) = x^2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "cc3b8114",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "func(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "id": "9566b762",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "map(x -> x^2, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "d06e898b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World\n",
      "Terminal"
     ]
    }
   ],
   "source": [
    "println(\"Hello World\")\n",
    "print(\"Terminal\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3e9b41b5",
   "metadata": {},
   "source": [
    "## function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "e672a0ea",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "name (generic function with 1 method)"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function name()\n",
    "    # tasks\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "846ea11c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "multi (generic function with 1 method)"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# initial type is any\n",
    "# string concatenation is doing using stars\n",
    "function multi(a,b)\n",
    "    return a*b\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "f6bc24bf",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"Hello Julia\""
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Hello \" * \"Julia\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "30cd4721",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "multi(2,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "850a8d41",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6.0"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "multi(2.0,3.0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "82dd0293",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "multi2 (generic function with 1 method)"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# suppose you want to only take specific type arguments\n",
    "function multi(a::Int64, b::Int64)\n",
    "    a*b\n",
    "end\n",
    "\n",
    "function multi2(a::Int64, b::Int64)\n",
    "    a*b\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "6d066f0c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6.0"
     ]
    }
   ],
   "source": [
    "print(multi(2.0,3.0))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "acc4a1c8",
   "metadata": {},
   "outputs": [
    {
     "ename": "LoadError",
     "evalue": "MethodError: no method matching multi2(::Float64, ::Float64)",
     "output_type": "error",
     "traceback": [
      "MethodError: no method matching multi2(::Float64, ::Float64)",
      "",
      "Stacktrace:",
      " [1] top-level scope",
      "   @ In[35]:1",
      " [2] eval",
      "   @ ./boot.jl:373 [inlined]",
      " [3] include_string(mapexpr::typeof(REPL.softscope), mod::Module, code::String, filename::String)",
      "   @ Base ./loading.jl:1196"
     ]
    }
   ],
   "source": [
    "print(multi2(2.0,3.0))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "98cf43ea",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "mutli_one (generic function with 1 method)"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# one liner syntax\n",
    "mutli_one(a::Float64, b::Float64) = a*b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "8a67cbd5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6.0"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mutli_one(3.0,2.0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "10d6a0c3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(36, 2.25, 1)"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function multi(a::Int64, b::Int64)\n",
    "    a*b, a/b, a%b\n",
    "end\n",
    "\n",
    "# returns tuple\n",
    "multi(9,4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "943afd2a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "36 2.25 1"
     ]
    }
   ],
   "source": [
    "mutliplication, division, modulo = multi(9,4)\n",
    "print(\"$mutliplication $division $modulo\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "5016b998",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "var_args (generic function with 1 method)"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# variable argument function\n",
    "function var_args(x,y,args...)\n",
    "    println(\"$x $y\")\n",
    "    print(\"$args\")\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "32ec1809",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 20\n",
      "()"
     ]
    }
   ],
   "source": [
    "var_args(10,20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "d9202f26",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 20\n",
      "(1, 2, 3, 4)"
     ]
    }
   ],
   "source": [
    "var_args(10,20,1,2,3,4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "49c4e1a9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 20\n",
      "([1, 2, 3, 4], [3, 4, 5])"
     ]
    }
   ],
   "source": [
    "var_args(10,20, [1,2,3,4],[3,4,5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "a426676d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "nre (generic function with 4 methods)"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function nre(d,u::Float64, ρ=1000, μ=0.001)\n",
    "    d*u*ρ/μ\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "42f8e049",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "50000.0"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nre(5e-3,10.0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "49d660a4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "nre (generic function with 4 methods)"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nre(d,u::Float64, ρ=1000, μ=0.001) = d*u*ρ/μ"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "2d6da1dc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "50000.0"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nre(5e-3,10.0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "id": "6c0e1e24",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "key_args (generic function with 1 method)"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function key_args(x,y; length, width)\n",
    "    println(\"$x $y\")\n",
    "    print(\"$length $width\")\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "8543ea41",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 20\n",
      "15 12"
     ]
    }
   ],
   "source": [
    "# can pass in any order\n",
    "key_args(10,20,length=15, width=12)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "id": "2caf38ab",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "key_args (generic function with 1 method)"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# keep initial value if you do not want to sned every time\n",
    "function key_args(x,y; length=10, width=20)\n",
    "    println(\"$x $y\")\n",
    "    print(\"$length $width\")\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "id": "fadb936b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 20\n",
      "10 20"
     ]
    }
   ],
   "source": [
    "key_args(10,20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "id": "c6482ed2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 20\n",
      "20 20"
     ]
    }
   ],
   "source": [
    "key_args(10,20, length=20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "id": "44567245",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "func1 (generic function with 1 method)"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function func1(x::Array{Float64},y::Array{Int64})\n",
    "    x = x*2\n",
    "    y = y*2\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "id": "61aaf920",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element Vector{Int64}:\n",
       " 2\n",
       " 4\n",
       " 6"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#  julia returns the last statement\n",
    "x = [1.0,2.0]\n",
    "y = [1,2,3]\n",
    "func1(x,y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "id": "d6c018b6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "([1.0, 2.0], [1, 2, 3])"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# values have not changed\n",
    "x, y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "id": "ba8bdec3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "func1! (generic function with 1 method)"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# use the \".\" inplace operator to modify the arguments\n",
    "# also use \"!\" to signify that input values have been modified\n",
    "function func1!(x::Array{Float64},y::Array{Int64})\n",
    "    x .= x*2\n",
    "    y .= y*2\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "id": "2fc595f9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "([2.0, 4.0], [2, 4, 6])"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "func1!(x,y)\n",
    "x, y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "id": "1a250f1f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element Vector{Int64}:\n",
       "  4\n",
       "  8\n",
       " 12"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "func1(x,y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "id": "0589cec1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element Vector{Int64}:\n",
       " 2\n",
       " 4\n",
       " 6"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "id": "63d07dca",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "#10 (generic function with 1 method)"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b = function (x)\n",
    "    x*2\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "id": "5e1a22bc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "id": "e84c88a9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "#12 (generic function with 1 method)"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(x,y)-> x*y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "id": "26c79a1c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# the first term in map can be anonymous like above\n",
    "map((x,y)-> x*y, 2, 4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "id": "5c48dcf6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5-element Vector{String}:\n",
       " \"CH4(g)\"\n",
       " \"CO(g)\"\n",
       " \"H(s)\"\n",
       " \"O(s)\"\n",
       " \"N2(g)\""
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "species = [\"CH4(g)\", \"CO(g)\", \"H(s)\", \"O(s)\", \"N2(g)\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "id": "111b2352",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element Vector{String}:\n",
       " \"CH4(g)\"\n",
       " \"CO(g)\"\n",
       " \"N2(g)\""
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "filter(sp->occursin(\"g\",sp), species)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "id": "8a140c99",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10-element Vector{Int64}:\n",
       "   1\n",
       "   4\n",
       "   9\n",
       "  16\n",
       "  25\n",
       "  36\n",
       "  49\n",
       "  64\n",
       "  81\n",
       " 100"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# list comprehension\n",
    "x = [i^2 for i in 1:10]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "fcf56291",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dfdx (generic function with 1 method)"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# pass a function to another function\n",
    "function dfdx(f::Function, x, dx)\n",
    "    return (f(x+dx)-f(x-dx))/2dx\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "5953d0b3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10.999999844329977"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "func = x-> 2x^2+3x+5\n",
    "dfdx(func, 2, 1e-8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "0dfc7945",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "11.000000000294106"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dfdx(x-> 2x^2+3x+5, 2, 1e-5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "02aec001",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "derivative (generic function with 1 method)"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# function returning a function\n",
    "function derivative(f::Function)\n",
    "    return function func(x)\n",
    "        dx = sqrt(eps(Float64))\n",
    "        f1 = f(x+dx)\n",
    "        f2 = f(x)\n",
    "        return (f1-f2)/dx\n",
    "    end\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "1bb03bbe",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "23.0"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "derivative(x-> 2x^2+3x+5)(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "9777b5ee",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "addall (generic function with 1 method)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function addall(a)\n",
    "    return function add(b)\n",
    "        return a+b\n",
    "    end\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "5d355789",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "addall(3)(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "24251cba",
   "metadata": {},
   "outputs": [
    {
     "ename": "LoadError",
     "evalue": "syntax: incomplete: \"function\" at In[8]:1 requires end",
     "output_type": "error",
     "traceback": [
      "syntax: incomplete: \"function\" at In[8]:1 requires end",
      "",
      "Stacktrace:",
      " [1] top-level scope",
      "   @ In[8]:1",
      " [2] eval",
      "   @ ./boot.jl:373 [inlined]",
      " [3] include_string(mapexpr::typeof(REPL.softscope), mod::Module, code::String, filename::String)",
      "   @ Base ./loading.jl:1196"
     ]
    }
   ],
   "source": [
    "function plug(p,y,x)\n",
    "    function residual(f, dfdx)\n",
    "        \n",
    "    end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "7f02b10b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "sumall (generic function with 1 method)"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# recursion\n",
    "sumall(n) = n == 1 ? 1 : n+sumall(n-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "9e9bcd9b",
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "15"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sumall(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "f9946837",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "factall (generic function with 1 method)"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "factall(n) = n == 0 ? 1 : factall(n-1)*n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "5fb81ffa",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "24"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "factall(4)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3b155e1d",
   "metadata": {},
   "source": [
    "## Broadcasting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "a9f7cd5b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element Vector{Float64}:\n",
       " 0.02159097572609596\n",
       " 0.945783999449539\n",
       " 0.8414709848078965"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# broadcasting, using '.'\n",
    "a = [3.12,1.24,1.0]\n",
    "sin.(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "0a346329",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element Vector{Float64}:\n",
       " 0.02159097572609596\n",
       " 0.945783999449539\n",
       " 0.8414709848078965"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# one more way\n",
    "@. sin(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "b8c09f4e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "sumtwo (generic function with 1 method)"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function sumtwo(a::Int64, b::Int64)\n",
    "    a+b\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "66fb7f69",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4-element Vector{Int64}:\n",
       "  6\n",
       "  8\n",
       " 10\n",
       " 12"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = [1,2,3,4]\n",
    "b = [5,6,7,8]\n",
    "sumtwo.(a,b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "584d051d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "check (generic function with 4 methods)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# julia stores mulitple methods of the function in a table and upon function call, chooses the one with the\n",
    "# corresponding argument type and description\n",
    "check(a,b) = println(\"Base method\")\n",
    "check(a::Int64,b::Int64) = println(\"Integer method\")\n",
    "check(a::Float64,b::Float64) = println(\"Float method\")\n",
    "check(a::Int64,b::Float64) = println(\"Mixed method\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "f838af45",
   "metadata": {},
   "outputs": [
    {
     "ename": "ErrorException",
     "evalue": "syntax: character literal contains multiple characters",
     "output_type": "error",
     "traceback": [
      "syntax: character literal contains multiple characters\n",
      "\n",
      "Stacktrace:\n",
      " [1] top-level scope\n",
      "   @ ~/Documents/Chemical Reactor Modelling/Introduction to Julia.ipynb:1"
     ]
    }
   ],
   "source": [
    "s = '(-1)22'\n",
    "s.split('')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ce8a8f5d",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Julia 1.7.3",
   "language": "julia",
   "name": "julia-1.7"
  },
  "language_info": {
   "file_extension": ".jl",
   "mimetype": "application/julia",
   "name": "julia",
   "version": "1.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}