EE4.07.2021.Coursework0.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Coursework 0\n",
    "\n",
    "The coursework will involve programming using Julia language, and reporting using Jupyter Notebook. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 0.1 Coursework Schedule\n",
    "\n",
    "| Task             | Due Date           |\n",
    "| ------------     | ----------------   |\n",
    "| **Coursework 1** |                    |\n",
    "| Assignment       | (Week 3) 18/10     |\n",
    "| Due              | (Week 5) 01/11 9:00    |\n",
    "| Peer Marking Due | (Week 6) 08/11 9:00    |\n",
    "| Feedback         | (Week 7) 15/11     |\n",
    "| **Coursework 2** |                    |\n",
    "|   Assignment     | (Week 5) 01/11     |\n",
    "| Due              | (Week 7) 15/11 9:00    |\n",
    "| Peer Marking Due | (Week 8) 22/11 9:00    |\n",
    "| Feedback         | (Week 9) 29/11     |\n",
    "| **Form Group**   |                    |\n",
    "| 1st Choice       | (Week 7) 15/11     |\n",
    "| 2nd Choice       | (Week 7) 17/11     |\n",
    "| **Coursework 3** |                    |\n",
    "|   Assignment     |   (Week 7) 15/11   |\n",
    "| Due              | (Week 10) 06/12 9:00   |\n",
    "| Peer Marking Due | (Week 11) 13/12 9:00   |\n",
    "| Feedback         | **20/12**          |\n",
    "| **Coursework 4** |                    |\n",
    "|   Assignment     |   (Week 7) 15/11   |\n",
    "| Topic Decided    | (Week 8) 17/11     |\n",
    "| Due              | (Week 11) 13/12 9:00   |\n",
    "| Peer Marking Due | (Week 11) 15/12 23:59  |\n",
    "| Feedback         | **20/12**          |\n",
    "\n",
    "* Coursework 1: 10%\n",
    "* Coursework 2: 26%\n",
    "* Coursework 3: 26%\n",
    "* Coursework 4: 30%\n",
    "* Peer Marking: 8%"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 0.1.1 Steps\n",
    "\n",
    "#### Coursework 1-3\n",
    "* For coursework 1 and 2, find your group allocation from MS Teams `General > Files > Class Materials > Coursework Assignment`. Find and talk to your teammates. \n",
    "* Download the coursework file (.ipynb Jupyter Notebook file) from MS Teams `General > Files > Class Materials > Coursework Assignment`. Change the file name to `Your Group ID.ipynb'. Work on the downloaded file directly with your group. \n",
    "* Before **the deadline (beginning of the lecture on the due date)**, upload the file to MS Teams `General > Files > Class Materials > Coursework#Submission` where the symbol # denotes the number of coursework. Note that each group submits only one file. \n",
    "  \n",
    "#### Peer Marking\n",
    "* The main purpose of peer marking include\n",
    "  * To learn from each other;\n",
    "  * To provide feedback from your own point of view.\n",
    "* GTA will send you an online storage folder. This folder can be seen **only** by you, GTAs and me. Peer marking files will be put there. **Make a record** of the folder and make sure you can always find it.\n",
    "* You will need to mark at least the next 5 groups of yours. For example, if you are in Group 1, you will need to mark reports for Groups 2-6. If you are in Group 10 and there are 11 groups in total, you need to mark Groups 11, 1-4. \n",
    "* See the peer marking form to understand what information is needed for peer marking. \n",
    "* After peer marking, upload your file to the private online folder. \n",
    "\n",
    "#### Feedback from Others\n",
    "We will put a file `Feedback.xlsx` to your private online folder.    \n",
    "* We will not give you the raw marks. Instead, we will give you the range of your marks (to 10%), for example, 60%-70%.    \n",
    "* We will list all the comments received as they are. Note that some comments may not be correct.    \n",
    "* We will not provide feedback on how your teammates rate your contributions unless there is a serious concern.   \n",
    "* We will not provide feedback on your performance on peer-marking unless there is a serious issue.   \n",
    "\n",
    "#### Coursework 3/4: Group Formation\n",
    "* You form your own group for coursework 3 and 4. A group should include 3-4 persons.   \n",
    "* Once you form your group, you simply put the following key information to `Grouping.xlsx`: group id, the title of your coursework 4, and key references.  \n",
    "\n",
    "#### Coursework 4: Paper Study and Presentation\n",
    "* Each group will have 12-15 minutes for presentation, ~5 minutes for Q&A, $\\lessapprox$ 20 minutes in total. \n",
    "* Presentation material format: it can be poster, or slides, or your own article (at most 3 pages). The key point is to give a good overview of the subject that you are going to talk about, as well as necessary details for others to follow you. Make sure that your presentation is pedagogical. \n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 0.2 Software for Coursework Reporting\n",
    "\n",
    "The software that you need to install/have    \n",
    "\n",
    "* Package management software *Anaconda*. By default, it will install Python and Jupyter Notebook to your system. \n",
    "* Programming language *Julia*. \n",
    "* Coursework reporting tool *Jupyter Notebook*. \n",
    "\n",
    "See [this article](https://www.geeksforgeeks.org/how-to-work-with-julia-on-jupyter-notebook/) for instructions on installing the necessary software step by step. \n",
    "\n",
    "Or see below for a brief summary    \n",
    "1. Download and install `Anaconda` from [here](https://www.anaconda.com/products/individual) and use its default setting. By default, it will install `Python` and `Jupyter Notebook` to your system.    \n",
    "2. Download and install the current stable version of Julia from [here](https://julialang.org/downloads/)     \n",
    "   1. Run Julia interactive session (a.k.a. **REPL**) by following the instructions at [the getting started webpage](https://docs.julialang.org/en/v1/manual/getting-started/).    \n",
    "   2. In REPL, type `using Pkg` and enter, then type `Pkg.add(\"IJulia\")` and enter. This will install a Julia package `IJulia`, which establishes the connection between Julia and Jupyter Notebook.   \n",
    "3. Run `Anaconda.Navigator`, click at `Jupyter Notebook`, and then in Jupyter Notebook you can create a new file or open an existing file that contains Julia codes.   \n",
    "4. (Optional) I personally prefer to use `VSCode` for Jupyter Notebook editing rather than the default browser interface of Jupyter Notebook. If you would try out this option, see the part `VSCode for Editing` below.    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 0.2.1 Julia for Programming"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Introduction to Julia\n",
    "\n",
    "**What is Julia Language**\n",
    "\n",
    "See [Wikipedia page](https://en.wikipedia.org/wiki/Julia_(programming_language))\n",
    "and [Julia Language Website](https://julialang.org/) for details. \n",
    "\n",
    "**Why Julia**\n",
    "\n",
    "See [a Nature article](https://www.nature.com/articles/d41586-019-02310-3).\n",
    "\n",
    "**Install and run Julia**\n",
    "\n",
    "Download the current stable version [here](https://julialang.org/downloads/)\n",
    "\n",
    "Run Julia interactive session (a.k.a. **REPL**) by following the instructions at [the getting started webpage](https://docs.julialang.org/en/v1/manual/getting-started/).\n",
    "\n",
    "**Getting Started with Julia**\n",
    "\n",
    "* A very nice tutorial on Julia in pdf format [here](https://www.sas.upenn.edu/~jesusfv/Chapter_HPC_8_Julia.pdf)\n",
    "* The documentation of the Julia package `JuMP` (for optimization) contains nice tutorial materials for Julia beginners [here](https://jump.dev/JuMP.jl/stable/tutorials/Getting%20started/an_introduction_to_julia/). "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 0.2.1.1 Julia Packages\n",
    "\n",
    "For the coursework, we will need several Julia packages. \n",
    "\n",
    "In the Julia REPL, enter the package manager by pressing `]`.   \n",
    "To get back to the Julia REPL, press backspace or ^C. \n",
    "\n",
    "Upon entering the package manager environment, you can \n",
    "\n",
    "* use `status` to get all the package information\n",
    "* use `add LinearAlgebra` to add the package `LinearAlgebra`\n",
    "* use `rm LinearAlgebra` to remove the package `LinearAlgebra`\n",
    "* use `update LinearAlgebra` to update the package `LinearAlgebra`\n",
    "\n",
    "The following contains packages that you may need for the coursework\n",
    "\n",
    "* IJulia\n",
    "* JLD2\n",
    "* LinearAlgebra\n",
    "* Random\n",
    "* Plots\n",
    "* StatsBase\n",
    "* ... (More to add)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 0.2.1.2 Tips in Julia Programming\n",
    "\n",
    "##### Matrix Operations\n",
    "\n",
    "Julia has native support for matrices and arrays. The following example gives several frequently used commands and some commands that may be confused for beginners. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "b = randn(Float64, 2) = [0.2972879845354616, 0.3823959677906078]\n",
      "A = randn(Float64, 2, 2) = [-0.5976344767282311 -0.839026854388764; -0.01044524463737564 0.31111133849833383]\n",
      "x = A \\ b = [-2.122965560745141, 1.1578526031568297]\n",
      "A = [0.2 -0.839026854388764; -0.01044524463737564 0.31111133849833383]\n",
      "B = [0.2 -0.839026854388764; -0.01044524463737564 0.31111133849833383]\n",
      "C = [0.2 -0.839026854388764; -0.01044524463737564 0.31111133849833383]\n",
      "a = A[:] = [0.2, -0.01044524463737564, -0.839026854388764, 0.31111133849833383]\n",
      "Indx = findall(a .< 0) = [2, 3]\n",
      "v = StepRange{Int64, Int64}[1:2:9]\n",
      "u = 1:2:9\n",
      "w = [1, 3, 5, 7, 9]\n"
     ]
    }
   ],
   "source": [
    "using Random\n",
    "Random.seed!(1);\n",
    "\n",
    "@show b = randn(Float64,2);\n",
    "@show A = randn(Float64,2,2);\n",
    "@show x = A\\b;\n",
    "\n",
    "B = A;          # Here B is actually only a pointer to the matrix A\n",
    "B[1,1] = 0.2;   # This command change the content of A! \n",
    "C = copy(A);    # Use copy to duplicate the matrix A to a new matrix C\n",
    "C[1,1] = 0.2;\n",
    "@show A;\n",
    "@show B;\n",
    "@show C;\n",
    "\n",
    "@show a = A[:];\n",
    "@show Indx = findall( a .< 0);\n",
    "\n",
    "v = [1:2:9];    # This command may look familar for Matlab users. But the output of the command is quite different from that in Matlab. In Matlab, [1:2:9] produces a vector [1,3,5,7,9]. In Julia, it does not. In order to produce [1:2:9], one needs to write collect(1:2:9), as shown below.  \n",
    "@show v; \n",
    "u = 1:2:9\n",
    "@show u; \n",
    "w = collect(u);\n",
    "@show w;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Input Unicode\n",
    "\n",
    "Type `\\sigma`, then hit `TAB` and it should change to `σ`. One nice feature of Julia is that it allows unicode characters to define variables. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "α = sqrt(2) = 1.4142135623730951\n",
      "area = π * (r / α) ^ 2 = 25.132741228718338\n"
     ]
    }
   ],
   "source": [
    "@show α = sqrt(2);\n",
    "r = 4; \n",
    "@show area = π * (r/α)^2;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Writing/Programming Style\n",
    "\n",
    "* Modular programming whenever possible to make your code easier to read and test.\n",
    "* Separate the parts for numerical tests and result illustration.\n",
    "\n",
    "##### Deactivate Time-Consuming Codes\n",
    "\n",
    "Parts of your code may take a long time to run. To allow efficient assessment, you need to deactivate the time-consuming parts of the code, but still show assessors your results. This can be achieved by the following three steps. \n",
    "\n",
    "1. Run your code which will generate simulation results. \n",
    "2. Save your results to files. Write code to load the simulation results from the files and do result illustration. \n",
    "3. Deactivate the time-consuming parts of your code and the code to save data. \n",
    "\n",
    "An example is shown below. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10×2 Matrix{Float64}:\n",
       " 3.9989e-6   4.00175e-6\n",
       " 0.00305614  0.00307752\n",
       " 0.00306488  0.00309889\n",
       " 0.00307121  0.00312332\n",
       " 0.00314018  0.00313284\n",
       " 0.00316953  0.00317481\n",
       " 0.00318638  0.00319895\n",
       " 0.00320859  0.00323231\n",
       " 0.0032281   0.00324399\n",
       " 0.00325515  0.00325368"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "using JLD2\n",
    "using LinearAlgebra\n",
    "\n",
    "MatD = 1000;\n",
    "RepN = 20;\n",
    "allow_run = false; \t# set to true for time-consuming simulations; and false for coursework assessment\n",
    "\n",
    "if allow_run\n",
    "    # time-consuming simulations\n",
    "    Aeig = Array{Float64,2}(undef,MatD,RepN);\n",
    "    for n in 1:RepN\n",
    "        A=rand(MatD,MatD);\n",
    "        A = A'*A;\n",
    "        Aeig[:,n] = eigvals(inv(A));\n",
    "    end\n",
    "\n",
    "    # save simulation results\n",
    "    @save \"example.jld2\" Aeig\n",
    "else \n",
    "    # load Aeig from a file to avoid time-consuming simulations\n",
    "    @load \"example.jld2\" Aeig\n",
    "end\n",
    "\n",
    "Aeig[1:10,1:2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 0.2.2 Jupyter Notebook for Reporting\n",
    "\n",
    "Jupyter notebook files are with extension `.ipynb`.\n",
    "\n",
    "There are two key terms in Jupyter Notebook: *cells* and *kernels*:\n",
    "\n",
    "* A kernel is a “computational engine” that executes the code. For coursework, we set kernel to Julia. \n",
    "* A cell is a container for text to be displayed in the notebook or code to be executed by the notebook’s kernel. \n",
    "\n",
    "There are two cell types in Jupyter Notebook: \n",
    "\n",
    "* A code cell contains code to be executed in the kernel. \n",
    "* A Markdown cell contains text formatted using Markdown. The article [here](https://towardsdatascience.com/write-markdown-latex-in-the-jupyter-notebook-10985edb91fd) discusses how to write markdown in the Jupyter notebook.\n",
    "\n",
    "I use Jupyter Notebook in VS Code. Please see [here](https://code.visualstudio.com/docs/datascience/jupyter-notebooks) for details. \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 0.2.3 VSCode for Editing\n",
    "\n",
    "VSCode is one of the most popular developer editor (see [Wikipedia Page](https://en.wikipedia.org/wiki/Visual_Studio_Code#:~:text=In%20the%20Stack%20Overflow%202019,reporting%20that%20they%20use%20it.)). \n",
    "\n",
    "1. Download and install VSCode [here](https://code.visualstudio.com/).\n",
    "2. We need to install extensions for VSCode. See [here](https://code.visualstudio.com/docs/editor/extension-marketplace) for how to install VSCode extensions. \n",
    "3. Anaconda should have automatically installed VSCode Extensions `Python` and `Pylance` for you. If not, install them. \n",
    "4. Install extension `Julia` for Julia programming in VSCode. See [here](https://www.julia-vscode.org/) and [here](https://www.julia-vscode.org/docs/stable/) for more details. \n",
    "5. Install `Jupyter` extension to allow Jupyter Notebook writing in VSCode. See [detailed instructions](https://code.visualstudio.com/docs/datascience/jupyter-notebooks). "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 0.3 Exercise (Will not be marked)\n",
    "\n",
    "Write a function `isprime` which checks whether a positive integer is a prime or not by simple exhaustive testing  \n",
    "Input: a positive integer $n$\n",
    "Output: true if $n$ is a prime number and false otherwise. "
   ]
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "a707b6ce8c685eb936424fcc3009d4b4b7a52543c4db09380a3fc49186ceb509"
  },
  "kernelspec": {
   "display_name": "Julia 1.6.3",
   "language": "julia",
   "name": "julia-1.6"
  },
  "language_info": {
   "file_extension": ".jl",
   "mimetype": "application/julia",
   "name": "julia",
   "version": "1.6.3"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}