LectureNotes/Class_03_22Jan2024.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "cc6657de-68b1-4332-a515-cc90c0f7cc24",
   "metadata": {},
   "source": [
    "# <span style='color:green'>   Introduction to Julia II </span>\n",
    "## 22 Jan 2024<br>\n",
    "<hr style=\"border-top: 1px solid purple; margin-top: 1px; border: 3px solid purple\"></hr>\n",
    " The goals for today:\n",
    "\n",
    "    1. Questions from last class (any issues with server or your own laptop?) \n",
    "    2. How to print output\n",
    "    3. Variables: \n",
    "            * variables: how to define, using $\\LaTeX$, and other unicode characters; naming conventions\n",
    "            * types: Strings, Characters, Integers, Floating Point, 1D Vectors, Tuples\n",
    "            * indexing arrays\n",
    "            * How to find out the type of a variable\n",
    "            * Not all unicode characters can be used as sub or superscripts.\n",
    "    4. Commenting code\n",
    "    5. Basic math, trig functions\n",
    "    \n",
    "<hr style=\"margin-bottom: 1px; border: 3px solid purple\"></hr>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7f38aaa9-2180-4bb8-b28e-032cd4a66fb7",
   "metadata": {
    "tags": []
   },
   "source": [
    "## <span style='color:purple'>   Questions from last class  </span>\n",
    "\n",
    "Q: How do I find a function to do x?<br>\n",
    "A1: Google is your friend!<br>\n",
    "A2: Julia has [great documentation](https://docs.julialang.org/en/v1/).<br>\n",
    "A3: Sites to check: [discourse.julialang.org](https://discourse.julialang.org), [the Julia Language Homepage]( https://julialang.org) <br>\n",
    "A4: Of course, this being 2024, there are absolutely fantastic AI options. We'll spend a class on them, and how to use them and remain skeptical of their sometimes incorrect solutions. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f62602e5-354e-4ab8-9897-eaf5a0659a33",
   "metadata": {},
   "outputs": [],
   "source": [
    "isodd(8)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "13472e1e-612c-405f-bcb1-3c5abe590ca5",
   "metadata": {
    "tags": []
   },
   "source": [
    "##  <span style='color:purple'>The *print()* and the *println()* functions </span>\n",
    "In the REPL (Read Evaluate Print Loop), if you want to display some message on the screen, you can use\n",
    "the *print()* **or** *println()* function. \n",
    "\n",
    "**Demonstrate this**\n",
    "\n",
    "In a Jupyter Notebook, you will typically only use the *println()* function\n",
    "because it adds a new line after printing to the screen what is requested. \n",
    "\n",
    "**Demonstrate this**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0389219d",
   "metadata": {},
   "outputs": [],
   "source": [
    "println(\"Hello\")\n",
    "\n",
    "print(\"Hello World!\")\n",
    "print(\"  <--- see! on the same line!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3572a91b-c07d-4d7f-9d3c-5a829485c883",
   "metadata": {
    "tags": []
   },
   "source": [
    "##  <span style='color:purple'>  Variable naming and assigning in Julia </span>\n",
    "### Standard naming conventions with alphanumeric labels; protected names\n",
    "In most computer languages, you are only allowed to use alphanumeric variable names such as\n",
    "x, y1, myName, x_position, yPosition1, etc... In these schemes, the only rule is that a variable cannot\n",
    "start with a number.\n",
    "So, for instance, the following are legitimate statements in Julia:\n",
    "\n",
    "```julia\n",
    "x = 2.0\n",
    "y1 = 400\n",
    "myName = \"Marie Curie\"\n",
    "x_1 = 32.7e6\n",
    "```\n",
    "\n",
    "However, the following are not allowed:\n",
    "```julia\n",
    "2x = 4.02\n",
    "72y = \"weird\"\n",
    "```\n",
    "[See the text](https://benlauwens.github.io/ThinkJulia.jl/latest/book.html#_variable_names) about *protected* variable names in Julia. \n",
    "The following keywords cannot be used, as they are a part of the Julia language: \n",
    "\n",
    "abstract type &emsp;   baremodule &emsp;  begin &emsp;     break     &emsp;  catch &emsp; \n",
    "const  &emsp;          continue   &emsp;  do &emsp;        else  &emsp;      elseif  &emsp;    export &emsp;      \n",
    "\n",
    "finally &emsp;    for   &emsp;      function &emsp;  global    &emsp;   if     &emsp;      import &emsp;    importall &emsp;  in &emsp; let      &emsp;        local   &emsp;  macro    &emsp;  module &emsp;     \n",
    "\n",
    "mutable struct &emsp;  primitive type  &emsp; quote    &emsp;    return  &emsp;   try  &emsp;       using &emsp;\n",
    "struct &emsp;          where&emsp;        while"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "73f594e1-8019-4ea3-82e5-f396e35c4536",
   "metadata": {
    "tags": []
   },
   "source": [
    "### Using Greek Letters\n",
    "One of the wonderful features of Julia is that you can use Greek Letters as variable names. In this way, the code\n",
    "you write can more closely resemble how you would write equations as a scientist. For example, you can write"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f3562191-0a42-4182-bb1b-c1ea1738a589",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "θ = 2.0 # type \"\\theta<TAB> = 2.0\n",
    "θₘ = 2π # Julia understands this means 2 times pi\n",
    "t² = 4  # in this case, the 2 is a superscript, not an operation.\n",
    "y₂ = 8\n",
    "println(θ*θₘ)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ae80d9ce",
   "metadata": {},
   "source": [
    "### Using unicode variables\n",
    "Julia also has an extensive set of available Unicode characters available. \n",
    "See [https://docs.julialang.org/en/v1/manual/unicode-input/](https://docs.julialang.org/en/v1/manual/unicode-input/)\n",
    "for a list. \n",
    "A few examples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dac94c0a",
   "metadata": {},
   "outputs": [],
   "source": [
    "ℏ = 1.0545718176461565e-34\n",
    "ϵ₀ = 8.854188e-12 \n",
    "🌲 = \"Maine State Tree\"\n",
    "🐝 = \"Maine State Insect\"\n",
    "🤷 = \"Not sure why one would use this as a variable name\";"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3a89f8a9-fafc-4ac6-a621-db936bca23f9",
   "metadata": {},
   "source": [
    "If you do not know how a unicode character is typed, you can open a Julia REPL and type a ? followed by pasting in a copy of the unicode character and the REPL will show you how to create it. Do this!\n",
    "(You can find a rather large collection of unicode characters supported in Julia at [https://docs.julialang.org/en/v1/manual/unicode-input/](https://docs.julialang.org/en/v1/manual/unicode-input/). Scroll far down to get the emoji images. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7b786a70-703b-4872-9baf-327d7b57d576",
   "metadata": {},
   "source": [
    "### Stylistic conventions\n",
    "Although Julia does not impose many restrictions on variable names (even allowing you to redefine $\\pi$ --- not recommended)\n",
    "there are some standard conventions (read more about this and more at [doc.julialang.org](https://docs.julialang.org/en/v1/manual/variables/) )\n",
    "These points are directly copied from the Julia Language documentation on variables:\n",
    "\n",
    "    a. Names of variables are in lower case\n",
    "    b. Word separation can be indicated by underscores (_) but use of underscores is discouraged unless the name would be hard to read otherwise.\n",
    "    c.  Names of Types and Modules begin with a capital letter and word separation is shown with upper camel case instead of underscores.\n",
    "    d.  Names of functions and macros are in lower case, without underscores. \n",
    "    e. Functions that write to their arguments have names that end in !. These are sometimes called \"mutating\" or \"in-place\" functions, becuase they are indended to produce changes in their arguments after the function is called, not just return a value. \n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5764a38b-8425-4be8-a929-9aa38a55feee",
   "metadata": {},
   "source": [
    "##  <span style='color:purple'>  Variable types </span>\n",
    "Computer languages generally fall into two camps; *static* type systems (all variable types must be explicitly declared before running the program)  \n",
    "or *dynamic* type systems (where the variable types are not known until execution). Julia is a dynamically typed language, but it also allows the user to \n",
    "explicitly define types. We'll see this capability later in the course. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f34c7814-9f2c-41ba-92be-4d698f8b5901",
   "metadata": {},
   "source": [
    "### Strings and Characters\n",
    "A *string* is a collection of *characters*. Strings are enclosed in double quotation marks; characters in single quotes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5cb56329-7aa9-4a71-9ed3-3e95a2835cf8",
   "metadata": {},
   "outputs": [],
   "source": [
    "name = \"Emmy Noether\"; #  responible for the insight that for every symmetry in nature there is a conserved quantity"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "58c093e1-ae2a-4630-8092-89448f8f9dac",
   "metadata": {},
   "source": [
    "You can find out info about the string such as it's length:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7e60819e-c9de-4f36-9b36-48b389b12ddb",
   "metadata": {},
   "outputs": [],
   "source": [
    "length(name)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "53ef0c3d-26d9-4c9a-a508-346c26e1e17b",
   "metadata": {},
   "source": [
    "You can also print out an individual character by referring to it's numerical location in the string; the first element has index 1, as Julia is a 1-indexed language (unlike C, C++, Python and Java, which use 0-based indexing). Most scientifically focussed languages used 1-based indexing (Fortran, Mathematica, R, Matlab). To refer to a character, enclose its index in [ ] :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2edba7f8-a732-4816-8a7e-3d10f9e404e0",
   "metadata": {},
   "outputs": [],
   "source": [
    "name[4]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9b890f39-d337-4093-b24d-4f03d25d968f",
   "metadata": {},
   "source": [
    "Notice that a *character* is enclosed in single quotes. You can refer to a range of characters using [ start:stop] like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "81423a1a-a4e4-48bd-a5b7-f1f9c0718d40",
   "metadata": {},
   "outputs": [],
   "source": [
    "firstName = name[1:4]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ecb3d46a-58c6-4829-8213-d9417fe91dcf",
   "metadata": {},
   "source": [
    "### Integers\n",
    "Integers are the set of positive or negative counting numbers with the inclusion of zero. We use the *typeof()* function to see the type of a value:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e3c08da6-378f-4c55-aacd-143810690649",
   "metadata": {},
   "outputs": [],
   "source": [
    "typeof(2)  # This is the default on a 64 bit machine "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3bae6965-d21d-4732-8815-a1222e899f87",
   "metadata": {},
   "source": [
    "There are several integer types in Julia (see  [Julia Language Documentation](https://docs.julialang.org/en/v1/manual/integers-and-floating-point-numbers/)) for more detail. \n",
    "You can define a variable to have a specific type if you want; for instance:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3b78f913-bbec-47ad-929f-aebd4e64d577",
   "metadata": {},
   "outputs": [],
   "source": [
    "x::Int8 = 22 \n",
    "typeof(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fe8ecaac-df16-4927-8871-8c7b10a016dd",
   "metadata": {},
   "outputs": [],
   "source": [
    "println(\"Max value for Int8 is \", typemax(Int8)) \n",
    "println(\"Min value for Int8 is \", typemin(Int8)) "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "62275249-a77c-4456-b236-170fc0e5774d",
   "metadata": {},
   "source": [
    " <span style='background :wheat' > Question: Why is typemax(Int8) not equal to 128?  </span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "71d088db-48ed-46a1-bc58-7aeb73a9f937",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "ebef987a-ff2c-46ae-87b2-67f5f770be94",
   "metadata": {},
   "source": [
    "### Floating Point numbers\n",
    "Floating point numbers are the real numbers you know and love from using your pocket calculator. \n",
    "The default value on all modern computers is Float64:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d2cd321c-0765-48e5-9c31-4f5aa54a28e8",
   "metadata": {},
   "outputs": [],
   "source": [
    "snowDepth = 20.5 # in cm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "84ed30ad-b9f3-441b-90f5-1783f09d8501",
   "metadata": {},
   "outputs": [],
   "source": [
    "typeof(snowDepth)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4f8a05a2-800d-47bb-a985-be56d65dbe39",
   "metadata": {},
   "outputs": [],
   "source": [
    "massElectron = 9.1093837e-31  # this is how to use scientific notation in Julia"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a32132d8-caa2-48fb-9fb2-197e835045d3",
   "metadata": {},
   "source": [
    "### 1 Dimensional Vectors\n",
    "You can define a *list* or (as a physicist would think of it) a 1D vector by using square brackets, \n",
    "with commas separating each value. For example, the $(x,y,z)$ coordinates of a point in space \n",
    "could be defined in Julia by the following statement (use the trick I discussed to see how I created the script r):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c9d4f9b7-c8cc-4b6e-95d7-93d38296eec7",
   "metadata": {},
   "outputs": [],
   "source": [
    "𝓇 = [1.0, 2.0, 5.0]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a0f45f8e-48da-4821-995f-ed8b5b8560b9",
   "metadata": {},
   "source": [
    "Another way to create a vector is "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "046b9089-6ca6-4216-be04-6306a65a4f38",
   "metadata": {},
   "outputs": [],
   "source": [
    "v = Vector{Int64}([-2, 4, 9])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "46364470-b836-42e9-9ffa-4cb8fcb857ab",
   "metadata": {},
   "source": [
    "I've noticed that if you use unicode characters, it seems problematic in jupyterlab to put more than one unicode character on a line, or put a subscript on the unicode variable name. \n",
    "There is a way around this; create the unicode character in the notebook code cell, select it, copy it to your clipboard, and open a Julia REPL. Paste in the character, and then add a subscript. That is how I created the line below. \n",
    "\n",
    "Bottom line, it would be nice if this worked more straightforwardly, and it's probably not worth the time unless you *really* like the particular unicode character."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0a742406-3e13-4072-bbe1-d91f258ab5cc",
   "metadata": {},
   "outputs": [],
   "source": [
    "𝓈₁ = [2.0, 1.0, -5.0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "01547f15-d62b-4941-a1c1-97cb10ffc42e",
   "metadata": {},
   "outputs": [],
   "source": [
    "t₁ = [5.0, -1.0, 2.0]\n",
    "s₁ = 𝓈₁"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "198a68aa-13d4-49b4-96f1-1340d92bb366",
   "metadata": {},
   "source": [
    "You can get the value of a particular element of the vector, say the y-component of $t_1$,  and assigning it to $t_1y$, by the following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6a77d239-d4ed-449e-b9a3-a6243b20060a",
   "metadata": {},
   "outputs": [],
   "source": [
    "t₁y = t₁[2]  \n",
    "println(t₁y)\n",
    "t₁[2]  = 9"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b4060651-bdaf-406f-beb5-6e732adfe9a3",
   "metadata": {},
   "source": [
    "Notice that in Julia, the elements are numbered starting from index 1; in python, the first element of a vector has index 0. Julia is said to have 1-based indexing. Personally, I find this far more intuitive, since I start counting at 1. \n",
    "\n",
    "Suppose you wanted to create a one-dimensional vector with 20 elements starting from 1 and increasing by +0.20 for each successive element. An easy way to do that in Julia is called a *list comprehension*:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "23d4bc90-dcbd-4b29-801c-2c091ed14286",
   "metadata": {},
   "outputs": [],
   "source": [
    "myList = [i + 0.20; for i in 1:20];  # deliberately incorrect---fix it!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b07fcf3e-b33e-4d1a-9061-61e58d54eb9e",
   "metadata": {},
   "source": [
    "Once you load the LinearAlgebra.jl package, you can do dot products easily in Julia by using  \\cdot <TAB> for the dot symbol; you can also use \n",
    "```julia\n",
    "dot(A,B)\n",
    "```\n",
    "where A and B are vectors."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6d41afef-cb62-4d2d-99d1-6d95f9d71de0",
   "metadata": {},
   "outputs": [],
   "source": [
    "using LinearAlgebra\n",
    "t₁ ⋅ s₁  "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9ba11503-99d2-495d-b0d9-1a001c013dd5",
   "metadata": {},
   "source": [
    "To compute the cross product of two vectors, we use\n",
    "```julia\n",
    "cross(A,B)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "50a8bab0-20be-499e-acde-367297bacad2",
   "metadata": {},
   "source": [
    "### Tuples\n",
    "In Julia (as in Python), a tuple looks like a vector, but the values cannot be changed once assigned. \n",
    "A tuple is created using ( ) instead of [ ]:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4aeb2a3a-cdfc-46f4-9cdd-7158bef2fc91",
   "metadata": {},
   "outputs": [],
   "source": [
    "r₀ = (1,2,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ed82bed8-4746-4d51-833f-fae68e078af5",
   "metadata": {},
   "outputs": [],
   "source": [
    "r₀ = (2,3,4)  # you can redefine the entire tuple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "15b4a747-ce3d-455c-928f-9f471dbd218f",
   "metadata": {},
   "outputs": [],
   "source": [
    "r₀[3] = 9  # not allowed to change the individual value"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "27516354-b260-4b24-b162-ebd506e37699",
   "metadata": {
    "tags": []
   },
   "source": [
    "Tuples (and vectors) can consist of strings, floating point numbers, lists, etc..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8397ce69-06b1-429c-ac3d-7a613c455584",
   "metadata": {},
   "outputs": [],
   "source": [
    "z = (\"Albert Einstein\", 3.14, [1,2,3])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d0293fa9-1220-428e-aed7-faaab8de8940",
   "metadata": {},
   "source": [
    "### Finding the type of an object\n",
    "Using the *typeof( )* function, we can find out the type whatever is assigned to a variable; note---you're finding out the type of what is assigned to the variable, not the type of the variable itself."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "75b3c360-500a-4989-b5e0-9a909dc80dd0",
   "metadata": {},
   "outputs": [],
   "source": [
    "typeof(z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bbb96d17-d21c-424e-aa90-8c2dba4782b1",
   "metadata": {},
   "outputs": [],
   "source": [
    "typeof(t₁)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "720f879e-3ca7-4e2f-9cb9-cc5339d22a55",
   "metadata": {},
   "source": [
    "## Commenting Code Part I\n",
    "Writing clear code is very importan, especially when others are going to use your code. As we progress through the semester, we'll continually \"up our commenting game\"\n",
    "and emphasize it's importance. For now, I'll introduce in-line comments. Invariably in computational physics, you will be defining variables for some physical quantity, so a reasonable comment\n",
    "is to mention the units associated with the quantity. To add a comment in-line with the code, you add a # symbol, and any text after that is regarded as a comment; for example:\n",
    "```julia\n",
    "m = 4.0    # in Kg\n",
    "E = 2.0e6 # in N/C\n",
    "```\n",
    "Suggestion, don't comment trivialities; for example **don't do this:**\n",
    "```julia\n",
    "F = G*m1*m2/r^2     #  Newton's law of Gravity\n",
    "```\n",
    "We assume the reader can see this line of code and has a base level of understanding rendering this comment unnecessary."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "daed363a-7ed5-4f58-916f-0c38822c6ba4",
   "metadata": {},
   "source": [
    "## Basic math functions \n",
    "Julia has a [huge list of standard mathematical functions](https://docs.julialang.org/en/v1/manual/mathematical-operations/); check out the link. \n",
    "If you need something beyond simple logarithms, exponentials, and trig functions, then you need to add the [SpecialFunctions.jl package](https://specialfunctions.juliamath.org/stable/). "
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Julia 1.10.0",
   "language": "julia",
   "name": "julia-1.10"
  },
  "language_info": {
   "file_extension": ".jl",
   "mimetype": "application/julia",
   "name": "julia",
   "version": "1.10.0"
  },
  "widgets": {
   "application/vnd.jupyter.widget-state+json": {
    "state": {},
    "version_major": 2,
    "version_minor": 0
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}