Solution - Bootcamp 1 - Intro to Julia.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "ccdfcdd8-5bc2-4e06-b373-c5f7c382c78c",
   "metadata": {},
   "source": [
    "<h1>Scientific coding bootcamp notebook 1: Intro to Julia.</h1>\n",
    "Welcome to Julia!  This notebook will give you a very rapid overview of the main features of the language.  It presumes you are already familiar with basic programming concepts in some other language. \n",
    "\n",
    "A very useful feature to know about up front is the \"help mode\", which you access by typing ? at the beginning of a cell, followed by anything you want to know more about.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "ee076178-13dc-49f4-9796-060c8ee09a63",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.141592653589793"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# This is a comment.  Any line that starts with # is a comment. \n",
    "# Defining variables:\n",
    "x = 2\n",
    "y = pi\n",
    "x + y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "c6379270-7d58-4b9e-812e-822e836b6a0c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "search: \u001b[0m\u001b[1mp\u001b[22m\u001b[0m\u001b[1mi\u001b[22m \u001b[0m\u001b[1mP\u001b[22m\u001b[0m\u001b[1mi\u001b[22mpe \u001b[0m\u001b[1mp\u001b[22m\u001b[0m\u001b[1mi\u001b[22mpeline \u001b[0m\u001b[1mP\u001b[22m\u001b[0m\u001b[1mi\u001b[22mpeBuffer tan\u001b[0m\u001b[1mp\u001b[22m\u001b[0m\u001b[1mi\u001b[22m sin\u001b[0m\u001b[1mp\u001b[22m\u001b[0m\u001b[1mi\u001b[22m cos\u001b[0m\u001b[1mp\u001b[22m\u001b[0m\u001b[1mi\u001b[22m cis\u001b[0m\u001b[1mp\u001b[22m\u001b[0m\u001b[1mi\u001b[22m get\u001b[0m\u001b[1mp\u001b[22m\u001b[0m\u001b[1mi\u001b[22md rem2\u001b[0m\u001b[1mp\u001b[22m\u001b[0m\u001b[1mi\u001b[22m mod2\u001b[0m\u001b[1mp\u001b[22m\u001b[0m\u001b[1mi\u001b[22m\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "\\begin{verbatim}\n",
       "π\n",
       "pi\n",
       "\\end{verbatim}\n",
       "The constant pi.\n",
       "\n",
       "Unicode \\texttt{π} can be typed by writing \\texttt{{\\textbackslash}pi} then pressing tab in the Julia REPL, and in many editors.\n",
       "\n",
       "See also: \\href{@ref}{\\texttt{sinpi}}, \\href{@ref}{\\texttt{sincospi}}, \\href{@ref}{\\texttt{deg2rad}}.\n",
       "\n",
       "\\section{Examples}\n",
       "\\begin{verbatim}\n",
       "julia> pi\n",
       "π = 3.1415926535897...\n",
       "\n",
       "julia> 1/2pi\n",
       "0.15915494309189535\n",
       "\\end{verbatim}\n"
      ],
      "text/markdown": [
       "```\n",
       "π\n",
       "pi\n",
       "```\n",
       "\n",
       "The constant pi.\n",
       "\n",
       "Unicode `π` can be typed by writing `\\pi` then pressing tab in the Julia REPL, and in many editors.\n",
       "\n",
       "See also: [`sinpi`](@ref), [`sincospi`](@ref), [`deg2rad`](@ref).\n",
       "\n",
       "# Examples\n",
       "\n",
       "```jldoctest\n",
       "julia> pi\n",
       "π = 3.1415926535897...\n",
       "\n",
       "julia> 1/2pi\n",
       "0.15915494309189535\n",
       "```\n"
      ],
      "text/plain": [
       "\u001b[36m  π\u001b[39m\n",
       "\u001b[36m  pi\u001b[39m\n",
       "\n",
       "  The constant pi.\n",
       "\n",
       "  Unicode \u001b[36mπ\u001b[39m can be typed by writing \u001b[36m\\pi\u001b[39m then pressing tab in the Julia REPL,\n",
       "  and in many editors.\n",
       "\n",
       "  See also: \u001b[36msinpi\u001b[39m, \u001b[36msincospi\u001b[39m, \u001b[36mdeg2rad\u001b[39m.\n",
       "\n",
       "\u001b[1m  Examples\u001b[22m\n",
       "\u001b[1m  ≡≡≡≡≡≡≡≡\u001b[22m\n",
       "\n",
       "\u001b[36m  julia> pi\u001b[39m\n",
       "\u001b[36m  π = 3.1415926535897...\u001b[39m\n",
       "\u001b[36m  \u001b[39m\n",
       "\u001b[36m  julia> 1/2pi\u001b[39m\n",
       "\u001b[36m  0.15915494309189535\u001b[39m"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "?pi"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "33aed804-26e0-4365-9ea9-ebab3fb9ab47",
   "metadata": {},
   "source": [
    "&nbsp;\n",
    "\n",
    "&nbsp;\n",
    "\n",
    "The last output of a cell is printed.  You can suppress this by putting a semicolon after the last line.  You can print an intermediate result using the function \"println\". "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "9d51545a-cc06-4459-a34b-6eb2f13d280f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6.283185307179586\n"
     ]
    }
   ],
   "source": [
    "println(y*2)\n",
    "#= This is a multi line comment. starts a multi line comment. \n",
    "The variable c below is a single character, made via single quotes. \n",
    "The variable s below is a string, made with double quotes.\n",
    "Multiline comments end with =#\n",
    "c = '!'\n",
    "s = \"Hello friend!\"; "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "de870f73-62ff-474f-80d6-c03da26b6e11",
   "metadata": {},
   "source": [
    "You can get unicode symbols by typing \\ followed by the symbol name and hitting the tab key.  Try this below. Make the π symbol.  Print it and see what value it gives. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "eea34163-1732-4f72-9405-114feb2370fb",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Your code here."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0e3fbe66-ca26-4cbd-85f1-b8889dc6e20a",
   "metadata": {},
   "source": [
    "Here are some other useful data types. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "71e13cb6-6571-49c3-91c0-3d22e5dca0c5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4×4 Matrix{Float64}:\n",
       "  1.0    2.0    3.0        4.0\n",
       " -1.0   -2.0   -3.14159  -12.0\n",
       "  0.0    0.0    0.0        0.0\n",
       "  1.0  NaN    -Inf        Inf"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Boolean\n",
    "b = true\n",
    "\n",
    "# Dictionary\n",
    "d = Dict(\"hello\"=>\"foo\",2=>\"baz\")\n",
    "\n",
    "# Vector\n",
    "v = [1 , 2 , 3.7 , -12.6]\n",
    "\n",
    "# Matrix\n",
    "M = [1 2 3 4 ; -1 -2 -pi -12 ; 0 0 0 0 ; 1 NaN -Inf Inf]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "b02dd40c-0d6b-4cfd-b77e-3750ed68f77c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.0\n",
      "3.7\n",
      "foo\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "3-element Vector{Float64}:\n",
       " 2.0\n",
       " 3.0\n",
       " 4.0"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Access elements of vectors, matrices, and dictionaries with square brackets [...], like this:\n",
    "println(M[1,2])\n",
    "println(v[3])\n",
    "println(d[\"hello\"])\n",
    "M[1,2:4]   # This is called slicing.  It gives a range of values of the matrix."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1e0fe2ac-bb97-46a1-9761-6ccfa0302cdb",
   "metadata": {},
   "source": [
    "Your turn: Try multiplying the matrix M with vector v using the * operator.  \n",
    "Then multiply the two with the .* operator.  \n",
    "Can you tell what is the difference between these two operators? "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dddc53ff-da89-448c-ad79-ad68521d90bb",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Your work here."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0aff38e3-a376-4a75-9b71-f7a43f776c21",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "7fe26ae6-895c-417f-9c5a-50147877c7f0",
   "metadata": {},
   "source": [
    "Now onto control flow.  Here are examples of if statements, for loops, and while loops."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "65c1809b-9b0b-457c-8ee4-925ebcc9f7d8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Alpha\n",
      "Charlie\n",
      "i==1\n",
      "i==2\n",
      "i==3\n",
      "i==4\n",
      "H\n",
      "e\n",
      "l\n",
      "l\n",
      "o\n",
      " \n",
      "f\n",
      "r\n",
      "i\n",
      "e\n",
      "n\n",
      "d\n",
      "idx == 13 and s[idx] == !\n"
     ]
    }
   ],
   "source": [
    "if 1 == 1\n",
    "    println(\"Alpha\")\n",
    "else\n",
    "    println(\"Bravo\")\n",
    "end\n",
    "\n",
    "if M[1,1] != 2.0\n",
    "    println(\"Charlie\")\n",
    "else\n",
    "    println(\"Delta\")\n",
    "end\n",
    "\n",
    "for i=1:4\n",
    "    println(\"i==\",i)\n",
    "end\n",
    "\n",
    "idx = 1\n",
    "while s[idx] != c   # Look above to see what we defined c and s as.  \n",
    "    println(s[idx])\n",
    "    idx += 1        # This increments idx by 1. \n",
    "end\n",
    "println(\"idx == \",idx,\" and s[idx] == \",s[idx])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b7a3624d-0ba0-4853-84c5-09b6bc332dab",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "d7a81fa8-fe75-42f9-be04-79f53097ba9d",
   "metadata": {},
   "source": [
    "A very useful way to construct objects like vectors is with \"comprehension\":"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "bb518da2-d60c-401a-914d-e26e4822b7c8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4-element Vector{Int64}:\n",
       "  1\n",
       "  4\n",
       "  9\n",
       " 16"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[i^2 for i=1:4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "e68fc4f9-b698-4697-a8a8-250f61719887",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4×4 Matrix{Int64}:\n",
       "  0  -3  -8  -15\n",
       "  3   0  -5  -12\n",
       "  8   5   0   -7\n",
       " 15  12   7    0"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[i^2-j^2 for i=1:4,j=1:4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "85a56e41-1e99-474f-b224-f5010f5814e1",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "90e513d7-a34a-4a42-a323-fd165eb1fda6",
   "metadata": {},
   "source": [
    "Here are two examples of functions.  The first is the \"usual way\" to define a function, and the second is the short way (typically only used for very simple functions)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "e8239748-687e-4c6d-a5c0-15e6ae0dbd0b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "elementwiseSquare (generic function with 1 method)"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function customTranspose(M::Matrix)\n",
    "    # This function transposes a matrix.  \n",
    "    m,n = size(M)   # Get the size of M in both dimensions\n",
    "    M_transposed = zeros(Float64,n,m)   # Make an array of zeros\n",
    "    for i=1:m\n",
    "        for j=1:n\n",
    "            M_transposed[j,i] = M[i,j]\n",
    "        end\n",
    "    end\n",
    "    return M_transposed\n",
    "end\n",
    "\n",
    "elementwiseSquare(M::Matrix) = [M[i,j]^2 for i=1:size(M,1),j=1:size(M,2)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "4dc8b109-e7bd-405c-a90c-a13e0e75186e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4×4 Matrix{Float64}:\n",
       "  1.0    1.0     0.0    1.0\n",
       "  4.0    4.0     0.0  NaN\n",
       "  9.0    9.8696  0.0   Inf\n",
       " 16.0  144.0     0.0   Inf"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "customTranspose(elementwiseSquare(M))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e1d3e3f9-c23d-4109-89a7-ce10d36907da",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "bf8a1f20-f484-405d-acf1-ba3e03522366",
   "metadata": {},
   "source": [
    "The last basic concept to understand is types and methods. 1 is an Int64 type, whereas 1.0 is a Float64 type.  You can see the type of an object via the function typeof:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "3ca2826f-58c7-41f4-b9bd-160b6d440b42",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Int64\n",
      "Float64\n",
      "String\n",
      "Matrix{Float64}\n"
     ]
    }
   ],
   "source": [
    "println(typeof(1))\n",
    "println(typeof(1.0))\n",
    "println(typeof(s))\n",
    "println(typeof(M))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "93431559-dcf4-4980-9f7c-0a8a9aa769e1",
   "metadata": {},
   "source": [
    "The type of M is more complicated, because it contains other variables within it, which themselves have a type. \n",
    "\n",
    "You can define your own custom types using the keyword struct.  A custom struct contains \"fields\" which you access via the dot syntax \"structname\".\"fieldname\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "556a7d04-048d-4cfd-bf89-9139a0fcefb9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"Wabbit\""
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "struct MyType\n",
    "    x::Int\n",
    "    y::Float64\n",
    "    name::String\n",
    "end\n",
    "\n",
    "x = MyType(12,pi,\"Wabbit\")\n",
    "x.name"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "63196c9d-bcdb-4864-aa2f-a8dff92af0c9",
   "metadata": {},
   "source": [
    "One of the most powerful features of Julia is the ability to make functions behave differently for different combinations of input types.  This is called \"multiple dispatch\".  Each different definition of a function for different combinations of arguments is called a \"method\" for that function. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "8c8ca5a0-5eae-45bb-a778-cea5290ab692",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.0\n",
      "1.5\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "test (generic function with 2 methods)"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function test(x::Int)\n",
    "    return floor(x/2)\n",
    "end\n",
    "function test(x::Float64)\n",
    "    return x/2\n",
    "end\n",
    "println(test(3))\n",
    "println(test(3.0))\n",
    "test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "26d36596-9e87-4ad4-a6e2-ba270477ab24",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "b4f3806a-32d6-4352-9714-7fbf4ce55026",
   "metadata": {},
   "source": [
    "Your turn!  You're going to make a custom type representing a quaternion, and then you're going to define addition and multiplication for this type. \n",
    "\n",
    "A quaternion is a like a 4-dimensional complex number.  Instead of just one imaginary unit i, it has three imaginary units i,j,k, which satisfy i^2 == j^2 == k^2 == -1.  They also have multiplication rules among themselves: \n",
    "ij = k\n",
    "jk = i \n",
    "ki = j\n",
    "ji = -k\n",
    "kj = -i\n",
    "ik = -j\n",
    "\n",
    "Make a quaternion struct with fields r, i, j, and k for the real part and each complex part, respectively.  Then define a new methods for the + and * functions which handle two quaternions.  You get starter code below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "52beed8f-703a-4543-928f-3591b15c0cb9",
   "metadata": {},
   "outputs": [],
   "source": [
    "struct ...\n",
    "\n",
    "end\n",
    "\n",
    "function +(x::Quaternion,y::Quaternion)\n",
    "\n",
    "end\n",
    "\n",
    "function *(x::Quaternion,y::Quaternion)\n",
    "\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f41af226-ea3a-4f32-b645-999544bf08ba",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "279a5268-061e-40d7-8683-95f912b8bb35",
   "metadata": {},
   "source": [
    "A couple miscellaneous useful things:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "3a4950bd-f588-462a-a930-8647c254fc0a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "144"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# A way to make an \"anonymous function\", i.e. one without a name:\n",
    "(x -> x^2)\n",
    "# You can assign an anonymous function to a variable:\n",
    "f = (x -> x^2)\n",
    "# Apply an anonymous function just as a regular function:\n",
    "println(f(10))\n",
    "(x -> x^2)(12)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "e118a99f-f685-42b7-85be-6b72aad5f86e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "256"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Functions can be applied using the operator |>\n",
    "# Whether you use this or regular function composition is purely a matter of taste.\n",
    "println(10 |> f)\n",
    "4 |> f |> f"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "d7bfc178-71a3-451f-8a92-b96b638edb96",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4×4 Matrix{Float64}:\n",
       " 1.0    4.0   9.0      16.0\n",
       " 1.0    4.0   9.8696  144.0\n",
       " 0.0    0.0   0.0       0.0\n",
       " 1.0  NaN    Inf       Inf"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Any function can be applied elementwise to an array by putting a dot after the function. \n",
    "f.(M)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "6d07ea2f-dff1-47d6-be27-f451cd39d2ca",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2024-07-26T16:34:38.336"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Packages are imported with the using keyword.\n",
    "# If you get \"ArgumentError: Package Date not found in current path.\" then\n",
    "# type \"]add Date\" to automatically download the package. \n",
    "using Dates\n",
    "now()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "80f69a16-6968-4616-9f31-451579842c31",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\u001b[32m\u001b[1m   Resolving\u001b[22m\u001b[39m package versions...\n",
      "\u001b[32m\u001b[1m    Updating\u001b[22m\u001b[39m `C:\\Users\\anonc\\.julia\\environments\\v1.10\\Project.toml`\n",
      "  \u001b[90m[ade2ca70] \u001b[39m\u001b[92m+ Dates\u001b[39m\n",
      "\u001b[32m\u001b[1m  No Changes\u001b[22m\u001b[39m to `C:\\Users\\anonc\\.julia\\environments\\v1.10\\Manifest.toml`\n"
     ]
    }
   ],
   "source": [
    "]add Dates"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "697213e5-1d50-4260-b6f3-078f37e15d7e",
   "metadata": {},
   "source": [
    "Play around with the output of now().  See what it's type is, and see what its field names are using the \"fieldnames\" function.  Use help mode to figure out how this function works."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "194abea2-13f2-4d85-b077-04c28904bfd9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "14"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# A very useful special operator is the three dots \"...\", which is called the splat in Julia.  \n",
    "# It allows you to unpack the contents of a list or vector into function arguments.  Here are some examples: \n",
    "function splatTest1(a,b,c)\n",
    "    return a+b*c\n",
    "end\n",
    "splatTest1([2,3,4]...)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "146643fe-7e73-4a66-aa36-63cae621dc6c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "You input a=Hello\n",
      "You input b=(\" there\", \" friend.\")\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "\" there\""
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# The splat also is used in defining \"varargs functions\", i.e. functions which can take different numbers of arguments.\n",
    "function splatTest2(a,b...)\n",
    "    println(\"You input a=\",a)\n",
    "    println(\"You input b=\",b)\n",
    "    return b[1]\n",
    "end\n",
    "splatTest2(\"Hello\", \" there\", \" friend.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "57683e9d-92f7-4c27-8279-02c72823b389",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello Hello Hello Hello Hello Hello Hello Hello Hello Hello \n"
     ]
    }
   ],
   "source": [
    "# You can provide keyword arguments to functions like this.  Note that you cannot do multiple dispatch on keyword arguments. \n",
    "function keywordTest(s::String; num::Int=1)\n",
    "    println( *([s for i=1:num]...))                 # Think about this line.  What is going on here?\n",
    "end\n",
    "keywordTest(\"Hello \"; num=10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6f592768-212a-4262-8913-b5e9d62af0a3",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Julia 1.10.3",
   "language": "julia",
   "name": "julia-1.10"
  },
  "language_info": {
   "file_extension": ".jl",
   "mimetype": "application/julia",
   "name": "julia",
   "version": "1.10.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}