Checkpoints/Checkpoint4.ipynb

 %% Cell type:markdown id:d5db6b1d tags:
 
 ## Checkpoint 4
 
-### Aim
+![ch4.jpg](ch4.jpg)
 
-To write a Python program to read in data from a text file in a specified format, perform some simple processing and display the output using pyplot.
+***“In the middle of the journey of our life I found myself within a dark woods where the straight way was lost.”***
+― Dante Alighieri, Inferno
 
-From a computing viewpoint this checkpoint demonstrates how to read data from a text file into suitable lists, perform some processing on these lists and then graphically display the results.
-
-
-### Dataset
-
-The voltage and current in an electronic circuit are sampled at a rate of 25kHz and the sampled data are written to a text file with the following format:
-
-- The first three lines are comments detailing the equipment used and are not useful for plotting, these lines start with the "#" character.
-- The following (several hundred) lines contain the data in the two floats separated by a " , ". The first data entry being voltage and the second the current.
-
-### Task
-
-The computing task is to write a Python program to read in data from the supplied file for voltage, V(t), and current, I(t), and to plot, via pyplot, the log power, being, p(t)=log(V(t)I(t)) where log is natural log to base e.
-
-Your program should:
-
-- Prompt for the filename to be read.
-- Read in the required data from sample.txt file and display p(t) over the supplied range of t with suitable titles and axis labels.
-
-- You must use a function of the form logpower(voltage,current) to form the p(t), and a main() program.
-
-### Background
-
-To successfully complete this checkpoint you should read carefully [Parsing Input](../CourseNotes/ParsingInput.ipynb).
-
-### Input files
-
-For this checkpoint there are 2 input files with which to test, and then run your code.
-These are [short.txt](short.txt) for testing and [sample.txt](sample.txt) for the real run.
-Both of these are in the current folder, so they can be read in and executed upon directly here. ***Be very careful not to WRITE into these files, as you may lose the measured data and will have to go to great lengths to recover it!***
-
-### Checkpoint
-
-- Test your program with both files, and make sure for each that the output is correcly displayed.
-- You should prompt the user for the filename to use.
-- Call a demonstrator, show them your code, and run your program for the two different datasets.
-
-### Assessment
-
-To pass this checkpoint:
-- The programme works correctly for both input files.
-- The programme uses a function of the form logpower(voltage,current) to form the p(t), and has a main() function.
-- The program is well structured and laid out.
-- It has sensible variable names that make clear their purpose.
-The output graph has correct title and labels.
-
->Think carefully about what you are reading from the file and what you want to plot. Also, to deal with the comment line, remember that comment lines start with a ```#``` which you can test for. Look up on the web what the string function ```str.startswith()``` does, it may be useful!
-
-
-### Next steps
-Once you have completed this checkpoint, please continue with the [Week4](../WeeklyTasks/Week4.ipynb) tasklist.
+Attempting to finish the course by jumping directly to the checkpoints may seem like a good idea, until it isn't. To get back on track, you may want to return to the [Week 4 tasklist](../WeeklyTasks/Week4.ipynb).
 
 %% Cell type:code id:c3ccaba4 tags:
 
 ``` python
 ```

CourseNotes/FunctionsAndLists.ipynb

-%% Cell type:markdown id: tags:
-
-We have seen in that functions basically *do what you expect*, and in
-particular the variables *inside* the function are seperate from those
-in the program. This is true for the basic build-in types (, , and ),
-but you have to be *very careful* when you pass s into functions.
-
-Consider what happend in the following code where the function sets a
-given with random numbers.
-
-def set_random_list(lst): """ Function to set a list full of random
-numbers. """ for i in range(0,len(lst)): lst\[i\] = random.random()
-
-def main(): xdata = \[0.0\]\*100 set_random_list(xdata)
-
-main()
-
-Now consider what happens,
-
--   in the program we create a list of 100 s, all set to zero,
-
--   then this is passed to the function the is sent to the function,
-
--   inside the function the data *held* in the is the same as the data
-    in the , so if you change the values of the elements of the list
-    inside then they *will* change in .
-
--   in , after the call to the *elements* of the list will be set to
-    random numbers.
-
-This operation of functions *is* typically what you want to happen, but
-you have to be very careful that you really intend to modify the
-contents of a list inside the function.
-
-The way that numbers operate need a bit of through on how they work, if
-you have a function as below that a ,
-
-def complex_value_compare( a , b): if a.real \> b.real and a.imag \>
-b.imag: return a + b else: return a - b
-
-then this will work exactly as you expect and you can *read* the real
-and imaginary parts of the arguments with the and syntax. *BUT* beacuse
-of the way the number is passed you are not able to write to the real
-and imaginary parts by this route, this means that althought a complex
-number looks like a of two numbers, it cannot be changed inside a
-function.
-
-webonly
-
-The There is a variant on the list called a which holds multiple
-elements just like a , is indexed by the same syntax for read *but*
-cannot be wrtten to, so its values are *fixed*. This is not frequently
-used in normal *user* programs, but is used inside complex libraries to
-implement constants.
-
-You have now completed sufficient to attempt which is the last
-checkpoint of the course.

CourseNotes/GetPython.ipynb

-%% Cell type:markdown id: tags:
+%% Cell type:markdown id:e766b8cd tags:
 
 This pages gives recipes on how to get  working on your own machine. It
 is a based on *best effort* local experience and comes with no support.
 
 While we encourage you to get  working on your own machine and *play*,
 remember that we will **only** marks checkpoints on the CPLab machines
 and not your own laptops.
 
 You must transfer any code to the CPLab system (by USB Key or e-mail),
 and make sure it works there before getting it marked.
 
 The best supported and comprehensive  environments is currently Anaconda
 
 This is free to download and install for *Windows* *Mac* or *Linux*.
 This inclues a full  3.7 kit, the IDE *Spyder* and all the additional
 libraries to could even want. It also includes *Juypter* and
 *Juypter-Lab* and *VS Code* which you will not need in this course.
 
 The download and install is fully doumented in the above and should
 basically *just work*. The download is very large and expands to a
 couple of couple of GByte, but this is well with the capability of most
 modern laptops / desktops.
 
 For *Windows* or *Mac* user we strongly recommend the *Spyder*
 development environment; this given an editor to edit code and a console
 to run code, this is actually a *IPython* console, but if you just *run*
 it will work. *Spyder* also reads and write files is standard text so
 you can easily transfer to/from CPLab with USB key.
 
-The *Spyder* environment has also been installed on the CPLab, but at
-the moment it is still being developed, so it not recommended yet.
+The *Spyder* environment has also been installed on the CPLab.
 
 The Mac is fundamentally a Unix machine, so you can tailor it to looks
 very much like the CPLab Linux machines. Do do this you have t do the
 following:
 
 ## Install the X11 environment
 
 This is not installed by default, but is a free download from the Mac
 Store and will autoinstall.
 
 -   In the Finder select Applications $\rightarrow$ Utilities
     $\rightarrow$ X11.
     If this is installed it will start, if not it will take you to the
     Apple Store and will take you through the install, this is a large
     install as it includes other programming development tools.
 
 -   This is needed to display the Matlibplot graphics and it also gives
     you an *xterminal* which is just about identical to the terminal on
     the CPLab machines. You start this click on the X11 logo in the
     Toobar, then Aplication $\rightarrow$ Terminal in the topbar.
 
 X11 is needed for all the orther free Unix utilities you may also wish
 to install, for example XMGrace, xfig, gnuplot. You will find there on
 your favourite download site.
 
 ## Installing an Editor
 
 The default version of emacs in the Mac is *very limited* and only works
 within the terminal window, so you will want to install something
 *better*. Here you have choice…
 
 Emacs for X11: This gives you the same emacs as on the CPLab.
 
 -   Download from for example [a](http://emacsformacosx.com/)s a dmg and
     do the install.
 
 Emacs for Aqua: This gives you emacs but running via the Mac OSX own
 window system (Aqua), rather than X11.
 
 -   Download from [.](http://aquamacs.org/)
 
 To run either of these select them from the Applications or Launchpad
 screen and then Open File. If you want to run from the terminal as you
 do in the CPlab, you will have to learn about `.bachrc` files and
 `alias`, ask if you want to go there.
 
 Other Editors There are *many* other editors, play, talk to friends etc;
 but remember some require *real money* or have limited *free trial*
 periods after which you have to pay!
 
 A useful alternative is Xcode which is the full Apple development
 environment which is free to download from the Mac Store. It is *huge*
 and really designed to develop apps for *iPad*, *iPhone*, *iWatch* etc,
 but it will also work as a simple  editor. xCode is however very
 resource intensive and it only really works on a new fast Mac with lots
 of memory, it also takes up about 3 Gbyte of disc!
 
 If you are already running Linux on your own machine then you already
 have everything to need, or can simply add it with what ever package
 manager come with your distribution. Here you also have an almost
 infinite choice of editors, but again most people will want to
 `emacs-X11` on their system.
 
 Note that some Linux distributions that follow the newest updates are
 now using as the default, for example Fedora, but if you are that close
 to the *bleeding*-edge you will already know this !

CourseNotes/HowtoWriteaComputerProgramfromScratch.ipynb

 %% Cell type:markdown id:57457292 tags:
 
 # Checkpoint 4 Step-by-step guide to Writing a Computer Program
 
 This checkpoint is different from the others to give you a break. You just have to work through it and make sure you understand and can run it. Then ask a demonstrator to check you off when you have completed it.
 
-## The problem
+## The first problem
 We want to write a program to display trignometric functions (sin, cos, tan, cot) and their first derivatives over their fundamental periods. The user should be allowed to choose interactively which function to plot.
 
 ## First steps
 Before writing any computer code, it is worth first thinking about how the logic of our program should work.
 
 For this task, one may do the following:
 
 - Prompt the user to choose between sin/cos/tan/cot
 - For the function the user has chosen, determine fundamental period.
 - For the chosen function, calculate derivative.
 - Plot chosen function and derivative.
 
 The logic of this whole program will look as below:
 
 ```python
 1. User chooses function, and we assign a value to each choice: sin=1, cos=2, tan=3, cot=4.
 
 2. Calculation and Plotting
 if user chose 1:
     determine fundamental period of sin(x)
     cos(x) is derivative of sin(x)
     plot sin(x) and cos(x) over the fundamental period
 else if user chose 2:
     determine fundamental period of cos(x)
     -sin(x) is derivative of cos(x)
     plot cos(x) and -sin(x) over the fundamental period
 else if user chose 3:
     determine fundamental period of tan(x)
     1/cos^2(x) is derivative of tan(x) #we worked out math separately
     plot tan(x) and 1/cos^2(x) over the fundamental period
 else: #this is the only possible remaining option for the user, that is to choose 4
     determine fundamental period of cot(x)
     -1/sin^2(x) is derivative of cot(x) [we worked out math separately]
     plot cot(x) and -1/sin^2(x) over the fundamental period
 
 3. Done!
 
 ````
 
 >***Note***: For more complex programs it is worth doing this structure pen-and-paper before starting to write down any code in ```Python```. This style is called ***writing in pseudocode***, that is a universally understandable human-readable version of the logic of the program. There is an entire field called algorithmics which deals with this!
 
 Let us now attempt to implement the above algorithm in ```Python```, below:
 
 %% Cell type:code id:2da1b363 tags:
 
 ``` python
 # Import necessary libraries and make our axes fonts and labels bold for a visually pleasing plot
 import numpy as np
 from matplotlib import pyplot as plt
 plt.rcParams["font.weight"] = "bold"
 plt.rcParams["axes.labelweight"] = "bold"
 
 # Allow user to choose which function to plot and also print a short description of what the program aims to achieve
 print("This is a short program to calculate and plot sin/cos/tan/cot and their derivatives over the fundamental period. \n")
 user_choice = int(input("Please select your desired function: \n 1. sin(x) \n 2. cos(x) \n 3. tan(x) \n 4. cot(x) \n User choice: "))
 
 # Calculate and plot
 # Choice of sin
 if user_choice == 1:
     # Determine fundamental period of sin(x)
     period = np.arange(0, 2*np.pi, 0.001)
     # Calculate sin(x) over the period
     function = np.sin(period)
     # Calculate derivative over the period
     derivative = np.cos(period)
     # Plot the results
     plt.figure(figsize=(10,6))
     plt.plot(period, function, label='sin(x)')
     plt.plot(period, derivative, label='cos(x)')
     plt.title("sin(x) and its derivative", fontsize='large', fontweight='bold')       # Add title/lables
     plt.xlabel("Angle (radians)")
     plt.ylabel("f(x)")
     plt.legend()
     plt.grid()
     plt.show()
 
 # Choice of cos
 elif user_choice == 2:
     # Determine fundamental period of cos(x)
     period = np.arange(0, 2*np.pi, 0.001)
     # Calculate cos(x) over the period
     function = np.cos(period)
     # Calculate derivative over the period
     derivative = -np.sin(period)
     # Plot the results
     plt.figure(figsize=(10,6))
     plt.plot(period, function, label='cos(x)')
     plt.plot(period, derivative, label='-sin(x)')
     plt.title("cos(x) and its derivative", fontsize='large', fontweight='bold')       # Add title/lables
     plt.xlabel("Angle (radians)")
     plt.ylabel("f(x)")
     plt.legend()
     plt.grid()
     plt.show()
 
 #Choice of tan
 elif user_choice == 3:
     # Determine fundamental period of tan(x) [note this is different from that of sin & cos]
     period = np.arange(0, np.pi, 0.001)
     # Calculate tan(x) over the period
     function = np.tan(period)
     # Calculate derivative over the period
     derivative = 1/np.cos(period)**2
     # Plot the results
     plt.figure(figsize=(10,6))
     plt.plot(period, function, label='tan(x)')
     plt.plot(period, derivative, label='1/cos^2(x)')
     plt.title("tan(x) and its derivative", fontsize='large', fontweight='bold')       # Add title/lables
     plt.xlabel("Angle (radians)")
     plt.ylabel("f(x)")
     plt.ylim([-10,10])  # Note tan has a discontinuity, so in order for
     # the plot to look meaningful, we restrict the plotting range for the y-axis
     plt.legend()
     plt.grid()
     plt.show()
 
 #Choice of cot
 else:
     # Determine fundamental period of cot(x) [note this is different from that of sin & cos]
     period = np.arange(0, np.pi, 0.001)
     # Calculate cos(x) over the period
     function = 1 / np.tan(period)       # Note NumPy does not have a cot function, but it is just 1/tan
     # Calculate derivative over the period
     derivative = - 1/np.sin(period)**2
     # Plot the results
     plt.figure(figsize=(10,6))
     plt.plot(period, function, label='cot(x)')
     plt.plot(period, derivative, label='-1/sin^2(x)')
     plt.title("cot(x) and its derivative", fontsize='large', fontweight='bold')       # Add title/lables
     plt.xlabel("Angle (radians)")
     plt.ylabel("f(x)")
     plt.ylim([-10,10])  # Note cot has a discontinuity, so in order for
     # the plot to look meaningful, we restrict the plotting range for the y-axis
     plt.legend()
     plt.grid()
     plt.show()
 ```
 
 %% Output
 
     This is a short program to calculate and plot sin/cos/tan/cot and their derivatives over the fundamental period.
     
     Please select your desired function:
      1. sin(x)
      2. cos(x)
      3. tan(x)
      4. cot(x)
      User choice: 1
 
 
 %% Cell type:markdown id:004db4eb tags:
 
 ## Some afterthoughts
 
 Our program uses the simplest possible logic to perform the required tasks, without much thought. There are of course ways to optimise this, and so reduce the amount of code needed. However, this way of doing things gives one a very good and practical example of ***code reusability***, that is copy-pasting a part of code several times and only needing to perform minor alterations to change the results.
 
 > Our program above has a **small bug**, which a user can easily detect while playing with the program. You should always be careful about situations like this, as any program should be bug-free, which is especially important given that some bugs can actually cause the program to halt and so fail to fulfil its intended purpose.
 
 Let us attempt below some minor changes to our code, that aim to achieve 2 things:
 1. Reduce the amount of code and make it more efficient.
 2. Eliminate the annoying bug.
 
 %% Cell type:code id:5fe8788b tags:
 
 ``` python
 # Import necessary libraries and make our axes fonts and labels bold for a visually pleasing plot
 import numpy as np
 from matplotlib import pyplot as plt
 plt.rcParams["font.weight"] = "bold"
 plt.rcParams["axes.labelweight"] = "bold"
 
 # Allow user to choose which function to plot and also print a short description of what the program aims to achieve
 print("This is a short program to calculate and plot sin/cos/tan/cot and their derivatives over the fundamental period. \n")
 user_choice = int(input("Please select your desired function: \n 1. sin(x) \n 2. cos(x) \n 3. tan(x) \n 4. cot(x) \n User choice: "))
 
 # Calculate and plot
 # Choice of sin
 if user_choice == 1:
     # Determine fundamental period of sin(x)
     period = np.arange(0, 2*np.pi, 0.001)
     # Calculate sin(x) over the period
     function = np.sin(period)
     # Calculate derivative over the period
     derivative = np.cos(period)
     #Define labels and bounds to use for plotting
     fn_label = "sin(x)"
     deriv_label = "cos(x)"
     y_bound = 1.1
 
 # Choice of cos
 elif user_choice == 2:
     # Determine fundamental period of cos(x)
     period = np.arange(0, 2*np.pi, 0.001)
     # Calculate cos(x) over the period
     function = np.cos(period)
     # Calculate derivative over the period
     derivative = -np.sin(period)
     #Define labels and bounds to use for plotting
     fn_label = "cos(x)"
     deriv_label = "-sin(x)"
     y_bound = 1.1
 
 #Choice of tan
 elif user_choice == 3:
     # Determine fundamental period of tan(x) [note this is different from that of sin & cos]
     period = np.arange(0, np.pi, 0.001)
     # Calculate tan(x) over the period
     function = np.tan(period)
     # Calculate derivative over the period
     derivative = 1/np.cos(period)**2
     #Define labels and bounds to use for plotting
     fn_label = "tan(x)"
     deriv_label = "1/cos^2(x)"
     y_bound = 10
 
 #Choice of cot
 else:
     # Determine fundamental period of cot(x) [note this is different from that of sin & cos]
     period = np.arange(0.001, np.pi, 0.001)
     # Calculate cos(x) over the period
     function = 1 / np.tan(period)       # Note NumPy does not have a cot function, but it is just 1/tan
     # Calculate derivative over the period
     derivative = - 1/np.sin(period)**2
     #Define labels and bounds to use for plotting
     fn_label = "cot(x)"
     deriv_label = "-1/sin^2(x)"
     y_bound = 10
 
 # Plot the results
 plt.figure(figsize=(10,6))
 plt.plot(period, function, label=fn_label)
 plt.plot(period, derivative, label=deriv_label)
 title_choice = fn_label + " and its derivative" #Build the title of the plot to match the chosen function
 plt.title(title_choice, fontsize='large', fontweight='bold')       # Add title/lables
 plt.xlabel("Angle (radians)")
 plt.ylabel("f(x)")
 plt.ylim([-y_bound, y_bound])
 plt.legend()
 plt.grid()
 plt.show()
 ```
 
 %% Output
 
     This is a short program to calculate and plot sin/cos/tan/cot and their derivatives over the fundamental period.
     
     Please select your desired function:
      1. sin(x)
      2. cos(x)
      3. tan(x)
      4. cot(x)
      User choice: 4
 
 
 %% Cell type:markdown id:66c48d22 tags:
 
 ## More afterthoughts
 
 Now we seem to have removed the bug that existed (so one aim is checked - ***please read carefully the 2 codes to see the difference***) and have also reduced the amount of code that needed writing. We achieved the latter by decoupling the calculation and the plotting of the results, having devised a way in which the calculations produce standardised outputs that can then be used in a general way to plot them irrespective of the user's choice.
 
 Let us try now to improve the code even further, trying both to reduce the written amount and to make it (slightly) more efficient and general.
 
 %% Cell type:code id:fea833cb tags:
 
 ``` python
 # Import necessary libraries and make our axes fonts and labels bold for a visually pleasing plot
 import numpy as np
 from matplotlib import pyplot as plt
 plt.rcParams["font.weight"] = "bold"
 plt.rcParams["axes.labelweight"] = "bold"
 
 # Allow user to choose which function to plot and also print a short description of what the program aims to achieve
 print("This is a short program to calculate and plot sin/cos/tan/cot and their derivatives over the fundamental period. \n")
 user_choice = int(input("Please select your desired function: \n 1. sin(x) \n 2. cos(x) \n 3. tan(x) \n 4. cot(x) \n User choice: "))
 
 #Define matching labels and bounds to use for plotting
 fn_label = ["sin(x)","cos(x)","tan(x)","cot(x)"]
 deriv_label = ["cos(x)","-sin(x)","1/cos^2(x)","-1/sin^2(x)"]
 y_bound = [1.1, 1.1, 10, 10]
 title_choice = fn_label[user_choice-1] + " and its derivative" #Build the title of the plot to match the chosen function
 
 # Define appropriate periods and calculate functions and matching derivatives
 periods = [np.arange(0, 2*np.pi, 0.001), np.arange(0, 2*np.pi, 0.001), np.arange(0, np.pi, 0.001), np.arange(0.001, np.pi, 0.001)]
 functions = [lambda x: np.sin(x),lambda x: np.cos(x),lambda x: np.tan(x),lambda x: 1/np.tan(x)]
 derivs = [lambda x: np.cos(x), lambda x: -np.sin(x), lambda x: 1/np.cos(x)**2, lambda x: -1/np.sin(x)**2]
 
 # Calculate for the user's choice (note array are numbered 0-> n-1, while user has a choice of 1->n)
 period = periods[user_choice-1]
 function = functions[user_choice-1](period)
 derivative = derivs[user_choice-1](period)
 
 # Plot the results
 plt.figure(figsize=(10,6))
 plt.plot(period, function, label=fn_label[user_choice-1])
 plt.plot(period, derivative, label=deriv_label[user_choice-1])
 plt.title(title_choice, fontsize='large', fontweight='bold')       # Add title/lables
 plt.xlabel("Angle (radians)")
 plt.ylabel("f(x)")
 plt.ylim([-y_bound[user_choice-1], y_bound[user_choice-1]])
 plt.legend()
 plt.grid()
 plt.show()
 ```
 
 %% Output
 
     This is a short program to calculate and plot sin/cos/tan/cot and their derivatives over the fundamental period.
     
     Please select your desired function:
      1. sin(x)
      2. cos(x)
      3. tan(x)
      4. cot(x)
      User choice: 4
 
 
 %% Cell type:markdown id:c4a0e13b tags:
 
 ## Final thoughts
 
 In the final code example above, we made use of the fact that the program has a very rigid structure. This begins from the limited user choice, and the fact that each choice is independent of others, which can allow us to produce matching arrays that make use of anonymous functions to calculate the desired function and its derivative and plot the result. You will see more detailed examples of all the concepts used in this section as you advance through the course.
 
 > Please note that the final code is significantly less human-friendly than the very first iteration we tried, and this is to be expected. **Programming is generally not a linear process**, and one never aims to write the final version of a code on the first try. It is best practice to adopt a trial and error approach (which most programmers do), where you interatively improve on the code, rather then hope to produce the final version from the first attempt. This practice also turns out to be significantly faster and more efficient than the alternatives.
 
-### Next steps
+
+## The second problem
+
+Write a `Python` program to read in data from a text file in a specified format, perform some simple processing and display the output using pyplot.
+
+More precisely, we want to write a `Python` program to read in data from the supplied file for voltage, V(t), and current, I(t), and to plot the log power, being, p(t)=log(V(t)I(t)) where log is natural log to base e.
+
+From a computing viewpoint this problem demonstrates how to read data from a text file into suitable lists, perform some processing on these lists and then graphically display the results.
+
+
+>### Dataset
+>The voltage and current in an electronic circuit are sampled at a rate of 25kHz and the sampled data are written to a text file with the following format:
+>- The first three lines are comments detailing the equipment used and are not useful for plotting, these lines start with the "#" character.
+>- The following (several hundred) lines contain the data in the two floats separated by a " , ". The first data entry being voltage and the second the current.
+
+>### Input files
+>For this exercise there are 2 input files with which to test, and then run our code.
+>These are [short.txt](short.txt) for testing and [sample.txt](sample.txt) for the real run.
+>Both of these are in the current folder, so they can be read in and executed upon directly here. ***Be very careful not to WRITE into these files, as you may lose the measured data and will have to go to great lengths to recover it!***
+
+## First steps
+Let us think how our program might be structured:
+
+```python
+1. User is prompted for the filename to be read.
+
+2. Read in the required data from the file.
+
+3. Create a function of the form logpower(voltage,current) to form the p(t).
+
+4. Display p(t) over the supplied range of t with suitable titles and axis labels.
+
+5. Done!
+
+````
+
+>### Background
+>- To successfully complete this we should read carefully [Parsing Input](../CourseNotes/ParsingInput.ipynb).
+>- Think carefully about what we are reading from the file and what we want to plot. Also, to deal with the comment line, we have to remember that comment lines start with a ```#``` which we can test for. Look up on the web what the string function ```str.startswith()``` does, it may be useful!
+
+%% Cell type:code id:d7786a8f tags:
+
+``` python
+# Define function to calculate logpower
+def logpower(voltage,current):
+    p = math.log(voltage*current)
+    return p
+
+# Construct our program to read in the data and plot it appropriately
+# Note we do this by creating a function that takes a filename as its parameter
+def PlottingProgram(filename):
+    print('Plotting file: {}'.format(filename))
+    filein = open(filename,"r")
+    voltage_data = []
+    current_data = []
+    logpower_data = []
+    for line in filein.readlines():
+        if not line.startswith('#'):
+            tokens = line.split(",")
+            voltage_data.append(float(tokens[0]))
+            current_data.append(float(tokens[1]))
+            logpower_data.append(logpower(float(tokens[0]),float(tokens[1])))
+
+    filein.close()
+
+    # Now go on and process time_data and voltage_data as two lists
+    time_s = np.arange(len(logpower_data))/25e3
+    time_ms = time_s * 1e3
+
+    # Plot the results
+    plt.plot(time_s,logpower_data,"r")          # Plot in red
+    plt.title("Power vs. time")       # Add title/lables
+    plt.xlabel("Time (s)")
+    plt.ylabel("Power")
+    plt.grid()
+    plt.show()
+
+file_name = input("Filename: ")
+
+PlottingProgram(file_name)
+```
+
+%% Cell type:markdown id:744ab8ea tags:
+
+Below, we can test automatically for both files we are interested in. ***Building tests for all posibilities of a program is a useful practice when dealing with multiple inputs and use cases!***
+
+%% Cell type:code id:690f1836 tags:
+
+``` python
+PlottingProgram('short.txt')
+PlottingProgram('sample.txt')
+```
+
+%% Cell type:markdown id:d7bbdc86 tags:
+
+## Next steps
 1. Make sure you have fully understood all of the above (that is all you have to do for this checkpoint).
 2. Get Checkpoint 4 checked off by a TA.
 3. Please continue with the [Week4](../WeeklyTasks/Week4.ipynb) tasklist.
 
 %% Cell type:code id:63a15de4 tags:
 
 ``` python
 ```

CourseNotes/MoreFunctions.ipynb

 %% Cell type:markdown id:2e25586e tags:
 
 # More on Functions
 
 In the section on basic functions, [Basic Functions](basicfunctions.ipynb), we considered the simple case where a function took a number of arguments and returned a single *value*, typically a `float`. We now want on extend this to look  at more complex use of functions.
 
 
 ## Returning more than one value
 
 *Functions* can be more flexible than just returning *a value*. Consider
 writing a *function* that when called will return a random point in
 three dimensions inside a sphere of a given radius. Consider the code
 below:
 ```python
 import random
 
 def random_point_in_sphere(radius):
     """
     Function to get a random point within a sphere of radius a
     return floats x,y,z
     """
     while True:
         x = random.uniform(-radius,radius)
         y = random.uniform(-radius,radius)
         z = random.uniform(-radius,radius)
         if x*x + y*y + z*z <= radius*radius:
             break
     return x,y,z
 
 def main():
     <....>
     rad = 10.0
     px, py, pz = random_point_in_sphere(rad)
     <....more code>
     dx, dy, dz = random_point_in_sphere(1.0)
     <....>
 ```
 Now looking at this in detail:
 
 1.  Define a function `random_point_in_sphere()` that takes single parameter being the `radius` of the sphere.
 
 2.  Inside the function go round a loop forming a point `x,y,z` at random and checking if the point is inside a sphere of the specified `radius`.
 
 3.  Then `break` from the loop once you have a point, so after the loop `x,y,z` gives a random point within a sphere (which is what you want).
 
 4.  Then `return` the three values as a `list`.
 
 5.  In the `main()` program you can now call your *function* and return the values to a specifed list of three variables, e.g. `px,py,pz`.
 
 This starts to shown the power of using functions, it removes the need to have to code for forming the random point in your `main()` program, and also you can call it as many times as you like in `main()` with different radius values.
 
 
 > #### return of a list
 Since the function `random_point_in_sphere()` returns a list, an alternative call is:
 ```python
 <...>
 point = random_point_in_sphere(20.0)
 x = point[0]
 y = point[1]
 z = point[2]
 ```
 where the variable `point` is a `list` of three `float`s which you can then access with the `[]` syntax.
 
 > The flexibility does have a *cost*, it is *totally up to the programmer* to understand what the function returns and match this up with the variables in the `main()`, failure to do this results in *highly entertaining* bugs!
 
 
 >> **Code Example**
--   Plot Planck Radiation curve : [Planck Plot](../CodeExamples/PlanckPlot.ipynb)
-This is a more complicated example with a *function* that returns a
-*list*. You will see a better way to do this later in the course when we
-look at the `Map Function`.
--   Volume of Sphere by random numbers : [SphereVolume](../CodeExamples/SphereVolume.ipynb)
-Program to calculate the volume of a sphere by counting three dimensional points; this is an example of a simple Monte Carlo simulation which you will hear more about next year.
+>>- [Plot Planck Radiation curve](../CodeExamples/PlanckPlot.ipynb):
+>>This is a more complicated example with a *function* that returns a *list*. You will see a >>better way to do this later in the course when we look at the `Map Function`.
+>>- [Volume of Sphere by random numbers](../CodeExamples/SphereVolume.ipynb):
+>>Program to calculate the volume of a sphere by counting three dimensional points; this is an example of a simple Monte Carlo simulation which you will hear more about next year.
 
 >> Both of these longer examples show how the use of *functions* simplifies
 the `main()` program and makes it more readable and esier to understand, and hence it is more likely to be correct.
 
 
 ## Functions and Lists
 
 We have seen in that functions basically *do what you expect*, and in
 particular the variables *inside* the function are separate from those
 in the `main()` program. This is true for the basic build-in types (`str`,`float`, and `int`), but you have to be *very careful* when you pass `list`s into functions.
 
 Consider what happend in the following code where the function `set_random_list()` sets a given `list` with random numbers.
 ```python
 def set_random_list(lst):
     """
     Function to set a list full of random numbers.
     """
     for i in range(0,len(lst)):
         lst[i] = random.random()
 
 def main():
     xdata = [0.0]*100
     set_random_list(xdata)
 
 main()
 ```
 
 Now consider what happens,
 
 -   in the `main()` program we create a list of 100 `float`s, all set to zero,
 
 -   then this is passed to the function `set_random_list(xdata)`; the `list` is sent to the function,
 
 -   inside the function the data *held* in the `list` is the same as the data in the `main()`, so if you change the values of the elements of the list inside `set_random_list()` then they *will* change in `main()`.
 
 -   in `main()`, after the call to `set_random_list(xdata)` the *elements* of the list `xdata` will be set to random numbers.
 
 This operation of functions *is* typically what you want to happen, but
 you have to be very careful that you really intend to modify the
 contents of a list inside the function.
 
 
 ## Functions and Complex Numbers
 
 The way that `complex` numbers operate needs a bit of thought on how they work, if you have a `complex` function as below that `returns` a `complex`,
 
 ```python
 def complex_value_compare( a , b):
     if a.real > b.real and a.imag > b.imag:
         return a + b
     else:
         return a - b
 ```
 then this will work exactly as you expect and you can *read* the real
 and imaginary parts of the `complex` arguments with the `.real` and `.imag` syntax. *BUT* because of the way the `complex` number is passed you are not able to write to the real and imaginary parts by this route, this means that although a complex number looks like a `list` of two numbers, it cannot be changed inside a function.
 
 > #### The Tuple
 There is a variant on the list called a `tuple` which holds multiple elements just like a `list`, is indexed by the same `[i]` syntax for read *but* cannot be written to, so its values are *fixed*. This is not frequently used in normal *user* programs, but is used inside complex libraries to implement constants.
 
 >> You have now completed sufficient to attempt [Checkpoint 5](../Checkpoints/Checkpoint5.ipynb).
 
 %% Cell type:code id: tags:
 
 ``` python
 ```

CourseNotes/Scope.ipynb

-%% Cell type:markdown id: tags:
+%% Cell type:markdown id:54814145 tags:
 
 # Scope of Variables
 
 *Scope of variables* means the parts of code where a particular variable
 is accessible. When you were writing a single program this was simple,
 but as you start to use functions and `main()` you need to start to think.
 
 ## All Local Variables
 
 > ### Key Point
 If you define **all** your variables inside functions then the rule is
 simple
 -   Variables are local to the function in which they are defined.
 
 So if we take the example below which forms a list of numbers and then
 uses function `add_values()` to sum them up.
 
 ```python
 def add_values(values):
     x = 0.0 # Local variable
     for y in values: #Sum up values in list
         x += y
     return x # return local value
 
 def main():
     v = [] # make list of numbers
     for i in range(0,10):
         x = 5.0*i
         v.append(x)
     x = add_values(v) # Sum up with function
     print("Sum of values is : " + str(x)) # Print
 
 main()
 ```
 
 -   The `x` used in `add_values()` is local to that function, it is used to hold the sum of the elements of the list and its **value** is returned in line 5
 
 -   The `x` used (twice) in `main()` is a *completely separate* to the same named variable in `add_values()`, and in particular it is located in a different location in computer memory, so the value of one does *not* affect the other.
 
 > ### Key Point
 Use of local variables is the recommended programming style, it
 -   Makes each function separate and removes inter-dependancies
 -   Allows each function to operate independently of others, so easier
     to reuse in other applications.
 -   Easier to test and debug each function seperately.
 
 > **Note: functions have *no memory* from any previous call, so all local variables get re-created every time the function is called.**
 
 
 ## Global Variables
 
 When variables are declared outside functions, including outside `main()` they become *global*, so
 
 ```python
 wave = 6.5 # Declare outside main or fucntion
 
 def bright(x):
     val = x*wave # Can access global variable wave
     return val
 
 def main():
     v = bright(15.0)
     print("value of bright is : " + str(v) + " and can also access wave " + str(wave))
 ```
 
 -   In Line 1, `wave` is a global float variable declared outside any function.
 
 -   In Line 4 and 9 the value of `wave` is accessible. It is also accesible from *any* other function declared within this file.
 
 >> Here is a longer example of using a global variable
 In this case `wavelength` is visible within both `main()` and the function `planck()`.
 
 > ### Key Point: Rules
-The rules for global variables are:
--   The global variable must be decared before any function it is used
+>The rules for global variables are:
+>-   The global variable must be decared before any function it is used
     in, so typically at the top of the file.
--   It is visible from all functions declared within the file.
--   The value of a global **cannot** be changed from within any function
+>-   It is visible from all functions declared within the file.
+>-   The value of a global **cannot** be changed from within any function
     or `main()`, so it is “*Read Only*”.
 
 > Global variables look *like a good thing*, but they should be used with *extreme care* and only when you want to set a *global default* across a set of functions.
 
 
 ## Changing Globals
 
 The default operation of globals is that they are *read only* within
 each function, but you can override this by the use of the `global` keyword as shown below.
 
 ```python
 wave = 6.5 # Declare outside main or funtion
 
 def bright(x):
     val = x*wave # Can access global variable wave
     return val
 
 def main():
     global wave # make wave writable fron within main
     v = bright(15.0)
     print("value of bright is : " + str(v) + " and can also access wave " + str(wave))
 
     wave = 25.0 # Update global variable
     v = bright(15.0)
     print("value of bright is : " + str(v) + " and can also access wave with new value " + str(wave))
 ```
 
 So here in line 8 we have declared that `wave` is a writable global in `main()`, so when we update it in line 12 the value seen by function `bright()` also changes.
 
 > ### Wrong
 Using `global` to make global variables writable within functions is *very dangerous*; it leads to totally unmaintanable code and should only be used when you really understand what you are doing.
 
 > WARNING: Having lists in global is a recipe for disaster, there are all sorts of horrible and none obvious consequences; how it works is logical, but typically not what you want; just “don’t do it”.
 
 %% Cell type:code id: tags:
 
 ``` python
 ```

CourseNotes/assessment.ipynb

 %% Cell type:markdown id:0e82b6e6 tags:
 
 # Course Assessment
 
 ## Overview
 
 The Scientific Programming (SciProg) component of the course Programming and Data Analysis
 is assessed by **6** checkpoints.
 
 The checkpoints are assessed on a pass/fail basis only. This is the
 basis of “ungrading" philosophy to avoid you being over-assessed and to
 help you to enjoy learning the skill of programming, rather than worrying
 about marks. Worrying disrupts memory retention. Please enjoy the
 course and there are many demonstrators on hand to help.
 
 You should pass **all** of the checkpoints, but if you fail only one then this one will be discarded.
 Programming is a valuable skill, well-rewarded in employment, and useful for your other courses.
 It is also fun and satisfying, while intellectually challenging. Try to learn it well now as it will save you time later.
 
 The Python Programming section is the first part of the Semester 1 course Programming and Data Analysis. The Data Analysis
 section of the course follows during weeks 8-11 of Semester 1.
 
 The checkpoints are given below. In practice your deadline will depend upon which day your allocated lab session is.
 **There aren't any extensions allowed for this course.**
 
 ## Checkpoints
 
 **It may be helpful before you start a checkpoint to first rename the checkpoint notebook which contains your solutions as CheckpointN_YourUUN, eg. Checkpoint1_s1234567**.
 
 1.  [Checkpoint 1](../Checkpoints/Checkpoint1.ipynb): basic handling of floating point numbers and mathematical
     functions.
     > Deadline: **Thursday 5:00pm 26th September 2024**
 
     *The first checkpoint has a soft deadline to help with any start-up problems. It must be completed by the end of the course to be taken into account.*
 
 2.  [Checkpoint 2](../Checkpoints/Checkpoint2.ipynb): to find the root of a quadratic equation.
     > Deadline: **Thursday 5:00pm 3rd October 2024**
 
 3.  [Checkpoint 3](../Checkpoints/Checkpoint3.ipynb): to plot out a graph of amplitude against time for a damped harmonic
     oscillator.
     > Deadline: **Thursday 5:00pm 10th October 2024**
 
-4.  [Checkpoint 4](../Checkpoints/Checkpoint4.ipynb): to read in data from a text file, process the data and plot the
-    output.
+4.  [Checkpoint 4](./HowtoWriteaComputerProgramfromScratch.ipynb): a worked-through example of how to tackle various problems by programming
     > Deadline: **Thursday 5:00pm 17th October 2024**
 
 5.  [Checkpoint 5](../Checkpoints/Checkpoint5.ipynb): to calculate path and energy of projectile under drag.
     > Deadline: **Thursday 5:00pm 24th October 2024**
 
 6.  [Checkpoint 6](../Checkpoints/Checkpoint6.ipynb): to perform a simple Monte Carlo calculation and determine the volume of molecules.
     > Deadline: **Thursday 5:00pm 31st October 2024**
 
 ## Process
 
 All checkpoints will be asessed by the demonstrators during the workshop
 class time. They will:
 
 1.  Ask you to run the code with the specified inputs and any with additional
     inputs they request.
 
 2.  Look through your code and ask you questions about specific points
     regarding the operation and style of the program.
 
 3.  They will assign pass or fail and give you verbal feedback on the style, and
     where appropriate, how the program could have been improved.
 
 The *minimum* assessment criteria for each checkpoint are specified with the checkpoint description.
 You should strive to have *more* that just a working program.
 It should be well organised, have sensible variable names, and suitable comments.
 
 -   At times many people may be trying to have checkpoints done at the same
     time, so please be patient and work ahead with the material while waiting.
 
 -   Please ensure that your program works as specified **before** asking to have it checked off.
 
 %% Cell type:markdown id:13e3c8be tags:
 

CourseNotes/basicfunctions.ipynb

-%% Cell type:markdown id: tags:
+%% Cell type:markdown id:e1a67568 tags:
 
 # Basic Functions
 
 ## Main as a function
 
 Now that you have seen the use of ```functions``` to calculate mathematical expressions
 such as ```cos()```, we will see how we can use the same idea to break up your code
 into smaller and manageable sections.
 
 The first concept in breaking up your code is to write your program as a ```function```, called ```main()``` as shown below:
 
 ```python
 def main():
     print("Hello world")
 
 main()
 ```
 Here we have
 
 -   **Line 1** declares the start of a ```function``` called ```main()```. *Note: the ":" is a
     required part of the syntax*
 
 -   **Line 2** contains the body of the function, here to simply ```print()``` "Hello
     World", *Note: this must be indented by exactly 4 spaces*.
 
 -   **Line 4** executes the ```main()``` function, so running the program.
 
 ### Key Point
-As you can see, correct indentation in  is *essential* - it
+As you can see, correct indentation in `Python` is *essential* - it
 is part of the syntax of the language.
 
 The editor will allow you to use key to do the indentation but you
 absolutely *must* get the right every time. There is no margin for
 error!
 
 > #### More on indentation
 In computing languages there are *three* styles to
 designate the start and end of code blocks, these being
 1.  *brackets*, in `C` and `Java` style languages,
 2.  *keywords* in `Fortran` and `Shell` scripts.
 3.  *indentation* in `Python`.
 
 > So in most languages *indentation* of code blocks is *good style* but
 not essential. However (uniquely?) in `Python` the start and end of blocks are
 designated by *indentation* only; it is part of the syntax of `Python`. This
 makes `Python` code short and concise, but it does mean you *must* get the
 indentation absolutely right!
 Failing to do this is the biggest source of (some very interesting)
 bugs!
 
 > Modify your program for Checkpoint1 to use a `main()` function.
 
 
 ## Simple functions
 
 The power of ```functions``` becomes apparent once we look at functions that can take
 *parameters*. Lets consider the code below that uses two functions to
 convert temperature values between the centigrade and fahrenheit scale:
 
 ```python
 def fahrenheit(t):
     return 1.8*t + 32.0
 
 def centigrade(t):
     return (t - 32.0)/1.8
 
 def main():
     ct = 100.0
     ft = fahrenheit(ct)
     print("Temperature of " + str(ct) + " in centigrade is " + str(ft) + " in farenheit")
     ft = 200.0
     ct = centigrade(ft)
     print("Temperature of " + str(ft) + " in farenheit is " + str(ct) + " in centigrade")
 
 main()
 ```
 
 Looking at this in detail,
 
 -   **Line 1** declares a function called `fahrenheit()` that takes a value `t` as a
     parameter assumed to be in centigrade.
 
 -   **Line 2** is the body of the function that takes the value of `t` and calculates the fahrenheit value and `return`s it.
 
 -   **Line 4-5** defines a function called `centigrade()` that takes a value `t` as a parameter assumed to be in fahrenheit and returns the value in  centigrade.
 
 -   **Line 9** uses the `fahrenheit()` function.
 
 -   **Line 12** uses the `centigrade()` function.
 
-> Download these two programs and play with them
-- Temperature Converter
-- Quadratic
+> Have a look at these two programs and play with them:
+>- [Temperature Converter](../CodeExamples/TemperatureConverter.ipynb)
+>- [Quadratic](../CodeExamples/QuadraticFunction.ipynb)
 
 ### Key Point
 This looks like an unnecessary complication, but as your programs get more complex you will see the benefit.
 
 **You are expected to use this format in all your programs**. In particular
 
 -   Declare `functions` at the top of the code.
 
 -   The executed program called `main()` which is defined and then executed by `main()` at the **end** of the file.
 
 -   **ALL** variables must be declared within `functions()` or `main()`
 
 This is *good programming practice* that we want you to learn, it also avoids many of the problems, pitfalls and complications associated with *scope of variables*, details of which are in the optional sections at
 the end of the course.
 
 -   [Scope of variables](Scope.ipynb)
 
 You will see how to do more complex operations with functions later, but this will get you started for now.
 
 %% Cell type:code id: tags:
 
 ``` python
 ```

CourseNotes/conditionalstatements.ipynb

-%% Cell type:markdown id: tags:
+%% Cell type:markdown id:16d8e959 tags:
 
 # Conditional Statements
 
 In order to start making a computer program do more than simple
 pre-determined calculations we have to introduce the idea of conditional
 statements. These make the execution path though the code depend on the
 values of the variables. This is called *Flow Control* and is the first
 real step in *programming*.
 
 > **This section introduces multiple new concepts and syntax, take
 your time and study it carefully.**
 
 ## The `if-else` structure
 
 The simplest conditional structure is the `if - else`, to see this consider the
 section of code below, where `a` is a float variable that has already been
 set:
 
 ```python
 <code to set a>
 if a > 0 :
     b = 4.0 + math.sqrt(a)
     a = 2.0*(b + 1.0)
 else :
     b = 4.0 - 3.0*math.sqrt(-a)
     a = 7.0*(b - 3.0)
 print("The value of a is : " + str(a) + " and b is : " + str(b))
 ```
 There is a considerable amount of new syntax here; read through this
 very carefully.
 
 - Line 1: Sets the value of `a`, which may be positive or negative.
 
 - Line 2: Start of the `if` with logical statement `a > 0` which will be `True` or `False`.
     **Note** the `:` which is an essential part of the syntax.
 
 - Lines 3 & 4: These two lines are executed only if `a > 0`.
     **Note** these lines *must* be indented by exactly 4 spaces.
 
 - Line 5: Start of the `else` code.
     **Note** the `:` and also the `else` *must* be aligned with the `if`.
 
 - Lines 6 & 7: These two lines are executed only if `a > 0` is `False`.
     **Note** again they *must* be indented by exactly 4 spaces.
 
 - Line 8: Execution continues here *after* the `if: else:` structure.
     **Note** this line *must* be aligned with the `if` and the `else`.
 
 ### Key Point
 As you can see, correct indentation in `Python` is *essential* - it
 is part of the syntax of the language.
 
 The editor will allow you to use `<tab>` key to do the indentation but you
 absolutely *must* get the right every time. There is no margin for
 error!
 
 > #### More on indentation
-In computing languages there are *three* styles to
-designate the start and end of code blocks, these being
-1.  *brackets*, in C and Java style languages,
-2.  *keywords* in Fortran and Shell scripts.
-3.  *indentation* in Python.
+>In computing languages there are *three* styles to designate the start and end of code blocks, these being:
+>1.  *brackets*, in C and Java style languages,
+>2.  *keywords* in Fortran and Shell scripts.
+>3.  *indentation* in Python.
 
 > So in most languages *indentation* of code blocks is *good style* but
 not essential. However (uniquely?) in  the start and end of blocks are
 designated by *indentation* only; it is part of the syntax of . This
 makes  code short and concise, but it does mean you *must* get the
 indentation absolutely right!
 
 > Failing to do this is the biggest source of (some very interesting)
 bugs!
 
 The conditional statement, the `a > 0` above, can be any logical statement that you can build up using `and`, `or` and `not`; you will learn more about this later.
 
 ## The `if-elif-else` structure
 
 There is a more complete and useful `if-elif-else` construction that you will often use in programming, look at the following example,
 ```python
 <code to set a>
 if a > 4.0 :
     b = 4.0 - math.sqrt(a)
     a = 2.0*(b - 3.0)
 elif a > 0 :
     b = 1.0 + math.sqrt(a)
     a = (b - 1.0)
 else :
     b = 4.0 - 3.0*math.sqrt(-a)
     a = 7.0*(b - 3.0)
 print("The value of a is : " +str(a) + " and b is : " + str(b))
 ```
 Looking at this is detail we have:
 
 -   Line 2: Changes the conditional on line 2 so that lines 3 & 4 will
     only be executed if $a > 4$.
 
 -   Line 5: Introduces a new statement `elif` (short for *else if*) with an
     additional condition that $a > 0$ and if `True` lines 6 & 7 will be executed.
 
 -   Line 8: The `else` catches *all other cases*, so here Lines 8 & 9 will be
     executed when $a \leq 0$.
 
 ### Key Point
 
 Here it is essential to note that:
 -   only **one** of the indented blocks of code will be executed, and
 -   this will be determined at the execution of the initial `if` statement.
 
 This looks a more complex piece of code but it will become one of the
 most common constructs you will use in programs.
 
 
 ## Nested if : else
 
 You can nest `if: elif: else:` blocks to any depth you like, so for example you can have:
 ```python
 <code to set a>
 <code to set b>
 if a > 0:
     if b > 0 :
         val = math.sqrt(b/a)
     else: val = math.sqrt(-b/a)
 else:
     if b > -10 :
         val = math.sqrt(-a / (b + 11.0))
     else: val = float("nan")
 print("Val is : " +str(val))
 ```
 Here:
 
 -   Line 3: Tests on variable `a`. The execution thread will jump *either*
     to Line 4 *or* to Line 9.
 
 -   Lines 4 to 7: Will be executed only if the test on Line 3 is `True`.
     Either Line 5 or Line 7 will be executed depending on the test on
     Line 4.
 
 -   Lines 9 to 12: Will be executed only if the test on Line 3 is `False`.
     Either Line 10 or Line 12 will be executed depending on the test on
     Line 9.
 
 -   Line 13: Will print out the final value of `val` .
 
 Note here the indentation; Lines 4, 6, 9 and 11 *must* be indented by 4
 spaces while lines 5, 7, 10 and 12 *must* be indented by 8 spaces.
 
 ### Key Point
 You can nest `if: elif: else:` to any *depth*, **but** such complex structure are
 difficult to write and even more difficult to debug.
 
 The general rule is:
 
 -   Do not nest deeper than two levels - if you find you have to,
     consider using *functions* to break up the code (see later in
     course).
 
 -   Add careful comments explaining what you are doing.
 
 >**Example Code:**
--   One way example:
--   Two way example:
--   Three way example:
--   Which quadrant is a complex number in :
--   Is point inside sphere using a function :
+>-   [One way example](../CodeExamples/OneWayConditional.ipynb)
+>-   [Two way example](../CodeExamples/TwoWayConditional.ipynb)
+>-   [Three way example](../CodeExamples/ThreeWayConditional.ipynb)
+>-   [Which quadrant is a complex number in](../CodeExamples/ComplexQuadrant.ipynb)
+>-   [Is point inside circle using a function](../CodeExamples/PointsInCircle.ipynb)
 > Download these and "play" with them; in particular change in indentation
 and see what type of "crashes" you get.
 
 >> Once you have practiced and understood the `if : elif: else:` syntax you have completed
 enough to attempt [Checkpoint 2](../Checkpoints/Checkpoint2.ipynb)
-Note, Checkpoint is much more tricky than it looks, read in instuctions
+Note, Checkpoint 2 is much more tricky than it looks, read in instructions
 and the **Hint** and plan out all the conditions that your program has
 to deal with.
 
 %% Cell type:code id: tags:
 
 ``` python
 ```

CourseNotes/fileIO.ipynb

 %% Cell type:markdown id:a3ba9097 tags:
 
 # File Input and Output
 
 In `Terminal Input and Output`, you learned how to read and write to the terminal window, but to deal with larger amounts of data we need to be able to read and write from and to files.
 
 Here we will only consider text files, which are the same type of files
 created by the editor and used to hold your `Python` source code.
 
 
 ## Opening files to Write
 
 Before writing to a file you must first open it which is done with:
 ```python
 fileout = open("mydata.dat","w")
 ```
 -   this will open a file called `mydata.dat` in your current directory with access code of `"w"` for *write* access.
 
 -   it will return a *filestream* in the variable `fileout`, which you will use to access the file. You do not need to concern youself with the details of what a *filestream* is at this point in your programming career; just use it.
 
 -   if the file `mydata.dat` already exists it will be *overwritten*, see more advanced use below to change this.
 
 You can now write `str` to this file *line-by-line* with for example,
 ```python
 x = 3.456e-6
 fileout.write("The value of x is : " + str(x) + "\n")
 ```
 which will form a single string and then write it to the opened file.
 This has basic syntax as the `print()` that you used to write to the terminal, *except*
 
 -   the extra `"\n"` at the end which adds a *newline* character to the end of the written `str`
 
 You can then simply repeat this `.write()` for as many other lines as you wish to write.
 
 > #### Why the extra newline
 The default `print()` command automatically adds the `"\n"`*behind-the-scenes* since it is *usually what you want*. This is sensible for output to a terminal, but for file output you want more control. The default `.write()` does only a write of the raw string that you supply, so you have to add the `"\n"` yourself.
 
 > This is the common convention in all similar languages, for example `C` and `Java`.
 
 ### Key Point
 So the easiest way to output to a file is:
 
 1.  open the file with `open(filename, "w")`
 
 2.  for each line convert to a string using `str()` and append a newline
     character using ` + "\n"`
 
 3.  write the string to the *filestream* using `.write()`
 
 This is sufficient to get you started and for many scientific `Python`  programs that deal with small amounts of data this is the only strategy you will *ever need to use*.
 
 > **Code Examples**
--   Write strings to a file: [WriteFile](../CodeExamples/WriteFile.ipynb)
--   Write values to a file from a for loop: [RangeLooptoFile](../CodeExamples/RangeLooptoFile.ipynb)
+>-   Write strings to a file: [WriteFile](../CodeExamples/WriteFile.ipynb)
+>-   Write values to a file from a for loop: [RangeLooptoFile](../CodeExamples/RangeLooptoFile.ipynb)
 
-> Download and "play".
+> Have a look around and "play".
 
 
 ## Opening files to Read
 
 Reading from a file is basically the reverse of write, so firstly we
 open the file, for example
 ```python
 filein = open("mydata.dat","r")
 ```
 1.  will open a file called `mydata.dat` in your current directory for access key `"r"` (read access),
 
 2.  it will return the *filestream* in the variable `filein` which you will use to read from,
 
 3.  if the file `mydata.dat` does not exist you program *will* crash; you will learn how to trap this in later courses.
 
 You would not normally *hard code* the filename into your program but
 ask for it as shown in `Printing and reading to/from the Terminal`, so your code would be:
 ```python
 filename = input("File to open : ")
 filein = open(filename, "r")
 ```
 which will ask you for the filename, and then open it.
 
 Once you have the opened the file you can *read* from it. There are
 *many* strategies for reading from files, but the simplest is using:
 ```python
 lines = filein.readlines()
 ```
 which will read in the *whole* file and return each line and as the
 elements of a list of strings, so that
 
 1. `lines[0]` is a string containing the first line of the file,
 
 2. `lines[1]` is a string containing the second line of the file,
 
 3.  `len(lines)` is the number of lines successfully read.
 
 How you now process this list of strings is the trickier bit, see next
 section for details on this at [Parsing Input](ParsingInput.ipynb).
 
 
 ## Closing the file
 
 When you have written or read the contents of a file you can close it
 with
 ```python
 filein.close()
 ```
 where `filein` is the *filestream*. This will close the file and tidy up. When a program exits successfully or *crashes* all open files are automatically *closed* so this is not something you have worry about in short programs, but it is *good programming style* to close files after the read/write has been completed.
 
 > **Code Examples**
--   Read text file as strings: [ReadingandPrintingStrings](../CodeExamples/ReadingandPrintingStrings.ipynb)
+>-   Read text file as strings: [ReadingandPrintingStrings](../CodeExamples/ReadingandPrintingStrings.ipynb)
 
-> Download and "play".
+> Have a look around and "play".
 
 ### Other types of files
 
 There many other types of files that hold *binary* data, for example
 sound files, images (jpeg, png) , movies (mov, mp4), spreadsheets (xls,
 xlsx) etc. These types cannot just processed as above and are much more
 complex.
 
 These are almost always read/written via library calls so the `Python` programmer does not need to know their internal structure; so for
 example if you want to know how to read a `jpeg` image file, search (or Google) for the right module and the right call and use it, *“do not re-invent the wheel…”*.
 
 For example you can read and display a `jpeg` image using Matlibplot with:
 ```python
 import matplotlib.pyplot as plt
 import matplotlib.image as img # Import image module
 
 image = img.imread("myimage.jpeg") # Read the jpeg
 plt.imshow(image) #render it in plot axis
 plt.show() # display it
 ```
 which does a default read and display without needing to know about the
 internal complexities of `jpeg` images.
 
 %% Cell type:code id: tags:
 
 ``` python
 ```

CourseNotes/loops.ipynb

 %% Cell type:markdown id: tags:
 
 # Loops and Looping
 
 To get into real programming we have to look at loops; here we have a
 *block* of code that is repeated either a set number of times (`for` loops) *or* until some condition is reached (`while` loops).
 
 #### Key Point
 The use of *loops* can often be a significant hurdle for new
 programmers but it is absolutely key to programming. Any “non-trivial”
 program contains loops, often many of them, and is the key to a
 computer’s main strength of “doing the same simple thing over and over
 again…” very fast.
 
 
 ## Fixed length loops
 
 First we will start with the simplest case of fixed length loops. Assume
 we want to print out values of $\cos(\theta)$ in the range
 $0\rightarrow2\pi$ using a `for` loop. Consider the piece of code:
 
 %% Cell type:code id: tags:
 
 ``` python
 import math
 
 points = 50
 dt = 2.0*math.pi/points
 for i in range(0,points):
     theta = dt*i
     value = math.cos(theta)
     print("theta is : " + str(theta) + " cos(theta) : " + str(value))
 print("End of loop")
 ```
 
 %% Output
 
     theta is : 0.0 cos(theta) : 1.0
     theta is : 0.12566370614359174 cos(theta) : 0.9921147013144779
     theta is : 0.25132741228718347 cos(theta) : 0.9685831611286311
     theta is : 0.3769911184307752 cos(theta) : 0.9297764858882513
     theta is : 0.5026548245743669 cos(theta) : 0.8763066800438636
     theta is : 0.6283185307179586 cos(theta) : 0.8090169943749475
     theta is : 0.7539822368615504 cos(theta) : 0.7289686274214116
     theta is : 0.8796459430051422 cos(theta) : 0.6374239897486896
     theta is : 1.0053096491487339 cos(theta) : 0.5358267949789965
     theta is : 1.1309733552923256 cos(theta) : 0.42577929156507266
     theta is : 1.2566370614359172 cos(theta) : 0.30901699437494745
     theta is : 1.3823007675795091 cos(theta) : 0.18738131458572452
     theta is : 1.5079644737231008 cos(theta) : 0.0627905195293133
     theta is : 1.6336281798666925 cos(theta) : -0.0627905195293134
     theta is : 1.7592918860102844 cos(theta) : -0.18738131458572482
     theta is : 1.884955592153876 cos(theta) : -0.30901699437494756
     theta is : 2.0106192982974678 cos(theta) : -0.4257792915650727
     theta is : 2.1362830044410597 cos(theta) : -0.5358267949789969
     theta is : 2.261946710584651 cos(theta) : -0.6374239897486897
     theta is : 2.387610416728243 cos(theta) : -0.7289686274214117
     theta is : 2.5132741228718345 cos(theta) : -0.8090169943749473
     theta is : 2.6389378290154264 cos(theta) : -0.8763066800438636
     theta is : 2.7646015351590183 cos(theta) : -0.9297764858882515
     theta is : 2.8902652413026098 cos(theta) : -0.9685831611286311
     theta is : 3.0159289474462017 cos(theta) : -0.9921147013144779
     theta is : 3.1415926535897936 cos(theta) : -1.0
     theta is : 3.267256359733385 cos(theta) : -0.9921147013144779
     theta is : 3.392920065876977 cos(theta) : -0.9685831611286311
     theta is : 3.518583772020569 cos(theta) : -0.9297764858882512
     theta is : 3.6442474781641603 cos(theta) : -0.8763066800438635
     theta is : 3.769911184307752 cos(theta) : -0.8090169943749472
     theta is : 3.8955748904513436 cos(theta) : -0.7289686274214116
     theta is : 4.0212385965949355 cos(theta) : -0.6374239897486895
     theta is : 4.1469023027385274 cos(theta) : -0.5358267949789963
     theta is : 4.272566008882119 cos(theta) : -0.42577929156507216
     theta is : 4.39822971502571 cos(theta) : -0.30901699437494756
     theta is : 4.523893421169302 cos(theta) : -0.18738131458572463
     theta is : 4.649557127312894 cos(theta) : -0.06279051952931321
     theta is : 4.775220833456486 cos(theta) : 0.06279051952931372
     theta is : 4.900884539600078 cos(theta) : 0.18738131458572513
     theta is : 5.026548245743669 cos(theta) : 0.30901699437494723
     theta is : 5.152211951887261 cos(theta) : 0.4257792915650726
     theta is : 5.277875658030853 cos(theta) : 0.5358267949789968
     theta is : 5.403539364174445 cos(theta) : 0.63742398974869
     theta is : 5.529203070318037 cos(theta) : 0.7289686274214119
     theta is : 5.6548667764616285 cos(theta) : 0.8090169943749478
     theta is : 5.7805304826052195 cos(theta) : 0.8763066800438636
     theta is : 5.906194188748811 cos(theta) : 0.9297764858882515
     theta is : 6.031857894892403 cos(theta) : 0.9685831611286312
     theta is : 6.157521601035995 cos(theta) : 0.9921147013144779
     End of loop
 
 %% Cell type:markdown id: tags:
 
 Looking at this in detail:
 
 -   Line 1: `points` is an `int`, in this case the number of points we want to calculate in between $0\rightarrow2\pi$
 
 -   Line 2: is the separation between each value of $\theta$ we wish to
     calculate.
 
 -   Line 3: the start of the `for` loop. It says: create an `int` variable `i` and while it is the range $0\rightarrow49$, execute the loop:
 
     -   It will *stop* before 50, so at 49.
 
     -   The `:` at the end of the line is essential and is part of the
         syntax.
 
 >    #### Range function
 The range function has the full syntax
 ```python
     range(start,end,step)
 ```
 where `start` is the starting integer, `end` the termination integer and the *optional* argument `step` the amount the value is incremented each time. If `step` is not given, it defaults to 1.
 
 >    All arguments *must* be `int`, and the loop will terminate *before*
     reaching the `end` value.
 
 -   Line 4 to 6: the indented code is *inside* the loop:
 
     -   Calculate $\theta$ by scaling `i` where `dt` is the separation between values.
 
     -   Calculate `value`, being $\cos(\theta)$.
 
     -   Print out the value of $\theta$ and of $\cos(\theta)$ to the
         screen.
 
     It will do this 50 times.
 
 -   Line 7: Print `End of Loop` when the loop is finished; it will only print this
     once.
 
 ### Key Point
 Note the most important bits of syntax here are
 
 -   that the body of the loop, (lines 4,5, & 6), *must* be indented by
     *exactly 4 spaces*.
 
 -   the loop variable `int` in that is automatically incremented each time round the loop.
 
 -   that the number of times the loop is exected is determined at the
     start (even if the loop variable in changed within the body of the
     loop).
 
 ## Loop access of lists
 
 One of the main applications of loops is to access the elements of a
 list, here we will look at two routes, the first conceptually simpler.
 
 Assume that the list `mydata` contains `float`s, its length is given by `len(mydata)` so if we want to sum up the values squared of the elements in `mydata` we could write
 
 %% Cell type:code id: tags:
 
 ``` python
 total = 0.0
 for i in range(0,len(mydata)):
     total = total + mydata[i]**2
 
 print("The total of mydata squared is : " + str(total))
 ```
 
 %% Output
 
     ---------------------------------------------------------------------------
     NameError                                 Traceback (most recent call last)
     <ipython-input-2-3cb76652cfbb> in <module>
           1 total = 0.0
     ----> 2 for i in range(0,len(mydata)):
           3     total = total + mydata[i]**2
           4
           5 print("The total of mydata squared is : " + str(total))
     NameError: name 'mydata' is not defined
 
 %% Cell type:markdown id: tags:
 
 which in detail does the following:
 
 -   Line 1: create a variable `total` and set its initial value to zero.
 
 -   Line 2: start of loop from 0 to `len()` of list; note again `i` will run from $0\rightarrow {\tt len()} - 1$
 
 -   Line 3: add the square of the `i`th elements of `mydata` to `total`; note the indentation.
 
 -   Line 5: at the end of the loop print out the answer.
 
 > #### Missing Line 4
 Here Line 4 is *intentionally left blank*, you can insert extra blank lines anywhere in your code and leaving a blank line at the end of a loop makes the code more readable and easier to understand.
 
 > Remember: white-space is *free*, use it to make your code readable, it will save you much time and effort when trying to find bugs.
 
 ### Key Point
 Here again the key points of this loop are
 
 -   the number of times the loop is executed is determined as the start,
     it is `len(mydata)`.
 
 -   the loop index `i` is automatically incremented by $+1$ every time round the loop.
 
 -   the largest value that `i` takes is $len(mydata)-1$ which is the index of the *last* element in the list.
 
 However since accessing lists like this is such a common operation there
 is a more compact syntax to do the same thing; take the following piece
 of code.
 
 %% Cell type:code id: tags:
 
 ``` python
 total = 0.0
 for d in mydata:
     total = total + d*d
 
 print("The total of mydata squared is : " + str(total))
 ```
 
 %% Cell type:markdown id: tags:
 
 -   Line 1: create variable `total` and set it to zero.
 
 -   Line 2: start of `for` loop, here the variable `d` is set to the value of each of the elements of `mydata` in turn.
 
 -   Line 3: add the value of `d` squared to `total`.
 
 -   Line 5: at the end of the loop, print out the final value.
 
 Both of these pieces of code will do the same thing, but the second is
 shorter, more computationally efficient and in `Python` style, but somewhat more difficult to understand.
 
 > #### Being Pythonic
 Being “Pythonic” is a statement you will find all over
 the web; it means doing something in “python style” which usually means
 using a programming method or syntax unique to `Python` that is not available in other languages. This can be “good” as in the alternative method to access lists since it is shorter and more efficient, but can also be “bad” since some of the Pythonic style is very compact and difficult to work out what it is actually doing. It is also often used to push style over function.
 
 > You will find must heated *debate* about this on the computing forums
 often by people who’s knowledge is questionable, but you should
 concentrate on getting your programs to work and understand what they
 are doing first. Worry about making them “Pythonic” as you gain
 experience. Do NOT copy down “magic recipes” from forums that you don’t
 understand and may not do what you want / expect.
 
 
 ## The `while` loop
 
 The other looping construct is when at the start of the loop we **do not
 know** how many times the loop is to be executed, for example consider
 the code below:
 
 %% Cell type:code id: tags:
 
 ``` python
 x = 0
 while x < 100 :
     x = x + random.randint(1,6)
 
 print("Final value of x is : " + str(x))
 ```
 
 %% Output
 
     ---------------------------------------------------------------------------
     NameError                                 Traceback (most recent call last)
     <ipython-input-4-cbfe5d858a1f> in <module>
           1 x = 0
           2 while x < 100 :
     ----> 3     x = x + random.randint(1,6)
           4
           5 print("Final value of x is : " + str(x))
     NameError: name 'random' is not defined
 
 %% Cell type:markdown id: tags:
 
 so looking at this in detail,
 
 -   Line 1: set the initial value of `x`
 
 -   Line 2: start of `while` loop, the body of the loop will be executed while the logical statement $x < 100$ is `True`
 
 In this type of loop the programmer is responsible for updating the
 termination condition, the `x` in this case. This type of loop is most often used in iterative methods, for example calculating the roots of an
 equation to a particular accuracy or the position of projectile.
 
 This type of loop is the key to solving Checkpont 5 in a couple of
 weeks.
 
 > #### Getting stuck
 The “danger” of the `while` loops is forgetting to update the
 variable that control the termination condition. The loop then never
 terminates and the program “hangs” going round-and-round “for ever”. If
 (when) this happens
 -   Type `Cntl-C` (both keys at once) which will interrupt the program and     tell you where it was in the code.
 -   If you can’t see the problem, print out the termination variable in
     the loop to see what is happening.
 
 
 ## The `break` statement
 
 An important concept associated with loops is the ability to “break out
 off a loop early”, which overrides the normal loop termination
 condition, so for example we could have:
 
 %% Cell type:code id: tags:
 
 ``` python
 total = 0
 while total < 100 :
     x = <function that sets x>
     if x < 0 :
         break
     else :
         total = total + x
 
 print("End of loop")
 ```
 
 %% Output
 
       File "<ipython-input-6-cb0d11525ce0>", line 3
         x = <function that sets x>
             ^
     SyntaxError: invalid syntax
 
 %% Cell type:markdown id: tags:
 
 so in detail
 
 -   Line 1: set `total` to zero
 
 -   Line 2: start of `while` loop, which should run until $total < 100$
 
 -   Line 3: code that calculates a value for `x`
 
 -   Line 4 & 5: Tests if the value of `x` is negative, and if it is `break` the loop, so jump straight to the end of the loop *now*.
 
 -   Line 6 & 7: if `x` is positive, then add to `total` and continue with the loop.
 
 You should use the `break` statement with care; its proper use is to catch errors or unexpected conditions. Using it as a part of algorithm often results in code that is hard to read.
 
 A common programming *trick* is to deliberately put a program into an
 infinite loop and then use the `break` statement as the exit, for example:
 
 %% Cell type:code id: tags:
 
 ``` python
 while True :
     x = \<function to set x>
     if x > 100:
         break
 
 print("End of loop")
 ```
 
 %% Cell type:markdown id:8dd67a17 tags:
 
 Here the `while` loop will run *forever* and your program will only exit this loop when `x` has been set to 100 (or more).
 
 This is a construct that is often used in interactive programs that keep
 taking “command” for example keeps asking for files to process or
 programs with a “graphical user interface” (GUI), but should be used
 with care in general programming since it difficult to debug and work
 out what is really happening.
 
 > **Code Examples**
--   Loop to terminal using for range : [RangeLoop](../CodeExamples/RangeLoop.ipynb)
--   Loop to list using for range : [RangeLooptoList](../CodeExamples/RangeLooptoList.ipynb)
--   Loop to list using while : [WhileLooptoList](../CodeExamples/WhileLooptoList.ipynb)
--   Guessing Game using `while` and `break`: [GuessGame](../CodeExamples/GuessGame.ipynb)
+>-   Loop to terminal using for range : [RangeLoop](../CodeExamples/RangeLoop.ipynb)
+>-   Loop to list using for range : [RangeLooptoList](../CodeExamples/RangeLooptoList.ipynb)
+>-   Loop to list using while : [WhileLooptoList](../CodeExamples/WhileLooptoList.ipynb)
+>-   Guessing Game using `while` and `break`: [GuessGame](../CodeExamples/GuessGame.ipynb)
 
 > You should have a look at these examples and "play" with them.

CourseNotes/plotting.ipynb

 %% Cell type:markdown id: tags:
 
 # Simple Graphs
 
 There are no graphics in standard `Python`; they have to be added by using an additional module. The standard package used in scientific computing is `MatPlotLib` which is an extensive data presentation package that produces two and three dimensional data plots, displays images, and supports animation; so all the graphics that most people will ever need. We will start of with the simplest use of this package to produce simple graphs and histograms.
 
 ## Getting Started
 
 ### Key Point
 You must first import the library, so at the top of your program put the line
 ```python
 import matplotlib.pyplot as plt
 ```
 What this does is:
 - imports `pyplot` components from module `matplotlib`
 - and calls it `plt`
 
 This is what you need for simple plots. See the examples below for what this means in practice.
 
 Now if you have X and Y data in two lists of `float`s (see Section 11) called `xdata` and `ydata`, then you can plot this as a simple x/y graph (the default graph)
 ```python
 plt.plot( xdata, ydata)
 plt.show()
 ```
 Note the syntax:
 - Line 1: the name of the `plot` function is `plt.plot()`, you specified the `plt` prefix on the import, this function builds the graph, taking the two lists as the arguments.
 - Line 2: `plt.show()` displays the graph on your screen. How it does this depends on the exact details of what system you are using (see below for more details).
 
 > #### The plt name
 Importing the `matplotlib.pyplot` as `plt` shortens the call since without this the the full call would be
 ```python
 matplotlib.pyplot.plot(xdata , ydata)
 ```
 which is getting rather verbose. You can perform this type of import with any library, so for example you can import `math` with
 ```python
 import math as m
 ```
 then the mathematical functions call become `m.cos()`, `m.sin()` etc.
 
 
 ## Where the plot goes
 
 How the plot appears on your screen depends on how your environment is set up:
 
 ### Using Jupyter
 
 Using `Jupyter` the plot will automatically appear within the browser below the cell that you are executing from.
 
 ### Using Spyder
 
 Using the `Spyder` IDE the default is for the plot to appear in-line in the iPython console window where you type commands, this is OK for checking code, but it does not allow you to zoom / pan the graph. To allow this:
 
 1. Open `Preferences` from the `Python` menu, this will open a large `Preference` panel with many options.
 2. Select `iPython` console, which will open a panel with set of Tabs on the top.
 3. Select `Graphics`, which will open a panel with many options.
 4. In the panel `Graphics backend` there is option tab labelled `Backend`.
 5. By default this is set to `inline`, use the option arrors to change this to `Automatic`.
 6. Click `OK` tab at the bottom of the `Preferences` panel.
 *You will need to **restart** `Spyder` for this change to take effect.*
 
 Now when you display graphics they will appear in a separate pop-up window with control icons.
 
 <div>
 <img src="spyder_graphics.png" width="500"/>
 </div>
 
 **Note: you only have to do this ONCE unless you do a `Reset to defaults` in the `Preferences`**
 
 > #### Other Preferences
 There are many-many other `Preferences` in `Spyder`, but this is the only one you will want to change. Many make rather complex changes to be behaviour; play with these with care, and if it all goes wrong, use the `Reset to defaults`.
 Remember that some `Preference` changes take place immediately, but some of the major configuration changes require you to restart `Spyder`.
 
 ### Other routes
 
 When `Python` is run from a terminal window on CPLab, Command Window in `Windows` or `Terminal` on `MacOS`, the `Matplotlib` plot automatically appears in its own window with controls.
 
 
 ## Interactive Display
 
 A typical `Matplotlib` plot is shown below:
 
 <div>
 <img src="cos_plot.png" width="500"/>
 </div>
 
 You can move and resize this window by dragging the boundary. There are a set of tabs below the plot that allow pan/zoom, select rectangular area, change plot area and save as `png` file which you can then import into other systems, in particular $\LaTeX$ (which you will use for reports in later years).
 
 
 ## Controlling the plot
 
 The default action is to plot the data with a red solid line, but this action can be changed by adding a third parameter to the call being a `str`, so, for example, it becomes.
 ```python
 plt.plot(xdata, ydata , "gx")
 ```
 The syntax of the control `str` is:
 
 - First character is the colour, which can be `"r"`, (red), `"g"` (green), `"b"` (blue), `"k"` (black), etc,
 - Second characters is the line or plot type, which can be `"-"` (solid line), (`"–"` (dashed line), `"x"` (cross marker), `"+"` (plus marker), etc.
 - The example above with `"gx"` plots the data with green cross-markers.
 
 There are many dozens of possibilities, which are listed at: `Matplotlib plot document page`.
 
 This also details the alternative route using keyword arguments, which allows even more options.
 
 You can also plot multiple set of data on one plot, so for example of you have two sets of y-data, called `firstydata` and `secondydata` then you can plot both sets of data on the one graph with
 ```python
 plt.plot(xdata, firstydata , "r" , xdata , secondydata, "g")
 ```
 which will give a red line for `firstydata` and green line for `secondydata`.
 
 > #### Code Examples
-- Plot of $\cos(\theta)$ in the range 0→4π : [CosPlot](../CodeExamples/CosPlot.ipynb)
-- Plot of flight of particle given inital velocity and acceleration : [FlightPlot](../CodeExamples/FlightPlot.ipynb)
-- Plot of a quadratic using a function: [QuadraticPlot](../CodeExamples/QuadraticPlot.ipynb)
-- More complex plot of a function using a function from the data `lists`
+>- Plot of $\cos(\theta)$ in the range 0→4π : [CosPlot](../CodeExamples/CosPlot.ipynb)
+>- Plot of flight of particle given inital velocity and acceleration : [FlightPlot](../CodeExamples/FlightPlot.ipynb)
+>- Plot of a quadratic using a function: [QuadraticPlot](../CodeExamples/QuadraticPlot.ipynb)
+>- More complex plot of a function using a function from the data `lists`
 
-> Download and play with range, number of points and colours.
+> Have a look around and play with range, number of points and colours.
 
 
 ## Making Histograms
 
 Another common plot you may want to produce is a histogram of the data held in a list of `float`s. If our lists of `float`s is called `numbers` and we wish to produce a histogram with 20 bins and evenly spaced between −3→3 then the code is:
 ```python
 plt.hist(numbers , bins = 20, range = [-3.0,3.0])
 plt.show()
 ```
 This introduces the a new type of argument, called `kargs` or *keyword arguments*, in this case there are two:
 
 - `bins = 20` sets the number of bins,
 - `range = [-3.0 , 3.0]` sets the argument `range` to a list that contains two floats, being the minumum and maximum value of the range of the *bins*.
 
 You will find this keyword argument syntax is often used in complex library functions where a function may take many dozens of different arguments and this methods simplifes the call. Note also the `kargs` can occur is any order, but must be after the normal arguments.
 
 > #### Code Examples
-- Histogram plot of Gaussian random noise :
+>- [Histogram plot of Gaussian random noise](../CodeExamples/GaussianNoisePlot.ipynb)
 
 > This uses the `random.gauss()` function that we introduced in `Adding Randoms`.
 
-> Download and play with range, number of points and number of histogram bins.
+> Have a look around and play with range, number of points and number of histogram bins.
 
 
 ## Titles, Labels and Scale
 
 You can control and annotate your graph. You can add a *title* and *labels* to the x/y-axis with:
 ```python
 plt.plot(<arguments to plot>)
 plt.title("Title of graph")
 plt.xlabel("Label for x axis")
 plt.ylabel("Label for y axis")
 plt.show()
 ```
 you can also control the *limits* of the x/y-axis with
 ```python
 plt.xlim(-3.0,5.0)     # set limit of xaxis to -3.0 -> 5.0
 plt.ylim(0.0,100.0)    # set limit of yaxis to 0.0 -> 100.0
 ```
 There are many dozens of other commands, for example to change from linear to log scaling, add legends, vary axis ticks, add grids etc, all of which are documented in `Matplotlib pyplot summary`.
 
 All these function calls must occur before the final `plt.show()`, which actually displays the graph.
 
 This is all you need for making basic plots; Matplotlib is a very powerful and flexible package that will plot just about any type of graph / plot you can imagine. Look up the on-line examples in the Matpoltlib documentation and “play”.
 
 > You have now completed sufficient programming to attempt [Checkpoint 3](../Checkpoints/Checkpoint3.ipynb).
 
 %% Cell type:code id: tags:
 
 ``` python
 ```

CourseNotes/simplelists.ipynb

 %% Cell type:markdown id:7f60042b tags:
 
 # Simple Lists
 
 In most programs you will want to manipulate more than one variable at a
 time, for example a set of x/y values that you want to plot or write to
 a file. In  this is handled by the which is a powerful and flexible
 construct. In fact much of  programming is the manipulation of .
 
 We will start with a simple example; writing
 ```python
 vals = [1.0, 2.0, 3.0, 5.0, 9.0, 4.0]
 print("Value of the 4th element is " + str(vals[3]))
 ```
 will give `The value of the 4th element is 5.`. Looking at the syntax
 
 1. Creates a `list` called `vals` that has 6 items, all being `float`, that are denoted by `vals[0]` to `vals[5]`. Note the numbering starts at `0`!
 2.  Prints the value of the 4th element, which is simply a `float`
 
 > The fact that lists number from “0” and the last element of a list of
 length $L$ is at $L-1$ is just a “syntactic fact of life” and is common to all
 “C”-style languages.
 This is one of the most common stumbling points for novice programmers;
 you just have to learn this and work with it!
 A *list* superficially looks like a *vector*, but the index of the
 elements is different.
 
 > #### Starting from the end
 You can also access the elements of the `list` from *the
 end* using a $-$index, with `vals[-1]` being the *last* element, `vals[-2]` the *second last*
 and so on.
 It is not often you want to access a list this way, but `vals[-1]` is a very common
 *short cut* syntax for the *last element*.
 
 We will see in the next section how to access lists in a loop, but first
 let’s consider some useful operations on the list from above:
 ```python
 vals.append(6.0)
 u = [12.0, 13.0, 14.0]
 vals.extend(u)
 print("Length of vals is now " + str(len(vals)))
 w = vals[3:7]
 ```
 where these statements will
 
 1.  Append an element to the end of list `vals`, which will now have 7
     elements.
 
 2.  Create a new list `u` with 3 elements.
 
 3.  Extend the list `vals` appending the contents of list `u` to the end of `vals`.
 
 4.  Print the `len(vals)`, which gives the number of elements in `vals`. This will now be 10.
 
 5.  Extract the elements of `vals` *starting* with `vals[3]` and *ending* at `vals[6]` and copy them to a new list `w`. Note that `w` will have 4 elements, watch the numbering!
 
 
 ## How to create a `list`
 
 There are many ways to create a list, but in simple programs there are
 three typical routes:
 
 1.  Create a list of values or variables as above, for example
 ```python
     x = 10.0
     y = 13.0
     z = 16.0
     v = [ x, y, z, 1.35]
 ```
     will create a list of 4 `floats`. This is useful for short lists where you know what the elements will be.
 
 2.  Create a list of *zero* length and then append what you want, so for
     example with the same `x, y, z` you could write
 ```python
     v = []
     v.append(x)
     v.append(y)
     v.append(z)
     v.append(1.35)
 ```
     would give you the same list of 4 `floats`. This is not really useful in this example, but we will see this construct again when we start reading in data from a file where we don’t know how many elements we are going to read.
 
 3.  Create a list of known length with all the elements being set the
     the same value, this is done with
 ```python
     v = [0.0]*25
 ```
     which will create a list of 25 `floats` and set them all to $0.0$. Here they will be numbered $0\rightarrow24$.
 
 
 ## Adding lists
 
 `lists` implements the `+` and `-` operators. This allows you to *add* lists together in a very obvious way, so you can write:
 ```python
 a = [1,2,3,4,5]
 b = [7,8,9,10]
 c = a + b[1:3]
 ```
 gives `c` being a list containing the 5 elements of list `a` plus elements `[1], [2]` of list `b` so would be 7 elements long.
 
 Similarly we can write
 ```python
 a = [1,2,3,4,5]
 b = [7,8,9,10]
 a += b[0:2]
 ```
 where the operator `+=` in this case will extend list `a` with the first **two** elements of list `b`; so that
 ```python
 a = [1,2,3,4,5,7,8]
 ```
 
 ## Printing Lists
 
 To print, you again do what you would expect; you can use the `str()` function to format the list as a `str` which you can print. So for example:
 ```python
 a = [1,2,3,4,5,6]
 print("List a is : " + str(a))
 print("Elements 2 to 4 are : " + str(a[2:5]))
 ```
 where the first `print` will format the all the elements of `a` surrounded by `[]` and the second `print` will format a three element sub-list of `a`.
 
 There are many fancier ways to format the output of lists but this
 recipe will get you started and is a quick and effective way, especialy
 if you want to print the contents of a list to monitor your program or
 during debugging (which is often the case!).
 
 > #### Other Types of Lists
 In the above example we have *only* considered lists of a single data type, being here `int` or `float`. However lists are much more
 flexible that this and you can create a list of *anything*, including
 *lists-of-lists*, *lists-of-objects*, *list-of-functions* etc.
 
 >`Python` is also unique (?) in allowing lists of *mixed type*, so you can have mixture of any type of data in a single list, so `int`,`complex` `str`, and even other lists. It is, however, the sole responsibility of the programmer to *get
 this right* and keep track of what each element actually is. This is a
 very powerful and dangerous “feature” that sould be used with great
 care, here there is almost unlimited scope for bugs which are obscure
 and impossible to find!!
 
 > Computationally intensive scientific programs typically use the `numpy` and `scipy` modules which use to hold numerical data; these are similar in but limited to fixed numerical types of a fixed length; you will learn about these in next year’s *Computer Modelling* course.
 
 >> **Code Examples:**
--   Make and append to a list : [MakeandAppendList](../CodeExamples/MakeandAppendList.ipynb)
--   Extract sub lists and add lists together : [ExtractSublist](../CodeExamples/ExtractSublist.ipynb)
--   Print a list : [PrintList](../CodeExamples/PrintList.ipynb)
+>>-   Make and append to a list : [MakeandAppendList](../CodeExamples/MakeandAppendList.ipynb)
+>>-   Extract sub lists and add lists together : [ExtractSublist](../CodeExamples/ExtractSublist.ipynb)
+>>-   Print a list : [PrintList](../CodeExamples/PrintList.ipynb)
 
 This is just the start of lists and you will learn much more as you use
 them. There are on-line examples:
 1. `Python Informal Introduction` which contains a gentle explanation.
 2. `Python Data Structures` which contains more detail including some useful methods for example `.sort()` and `.reverse()` that act on the whole list.
 
 
 ## Lists and Functions
 You can use `lists` with `function`s, but you have to be slightly careful. Consider the code below to append two `lists`.
 ```python
 def append(first , second):
     l = first + second
     return l
 
 def main():
     first = [1,2,3,4,5]
     second = [6,7,8,9,10]
     nl = append(first,second)
     print(str(nl))
 
 main()
 ```
 -   Lines 1-3 define a `function` that takes two variables, adds them together and `returns` the result.
 
 -   Lines 5-9 define two `list`s, pass them to the function which forms a new `list` called `l`, being the addition of the `lists`, which it `returns`.
 
 -   Line 11 then runs the `main` program.
 
 This works exactly as expected and the returned `list` called `nl` on line 8 is the copy of list `first` and `second` added together, so is a `list` of 10 elements holding the numbers $1\rightarrow9$.
 
 > Experiment with the following `append` fuction, and see that it also works for other variable types.
--   Code of [AppendFunction](../CodeExamples/AppendFunction.ipynb).
+>-   Code of [AppendFunction](../CodeExamples/AppendFunction.ipynb).
 
 However things get a little more complicated if you pass a `list` into a `function`, and then change values in the `list`, so for example consider the following piece of code that sorts the contents of a `list`:
 ```python
 def sortit(ls):
     ls.sort()
 
 def main():
     vals = [2,7,6,9,1]
     sortit(vals)
     print(str(vals))
 
 main()
 ```
 -   Lines 1-2 define a `function` that will sort a `list` into ascending order using the `.sort()` method.
 
 -   Lines 4-7 show the use of this `function` to sort a `list` of integers.
 
 So in this case changes made to contents of the `list` inside the `function`, change the contents of the `list` in the `main()` program.
 
 > #### What is really happening
 This initially looks inconsistent as it looks like `lists` behave differently from variables like `float` or `int`. The answer to this is
 “What is being passed to the function”.
 -   For the basic built-in variables, a copy of the value is passed to
     the `function`. This means that any changes to the variable value inside the `function` do not change the value in the calling program.
 -   For compound variable types, for example `lists`, a copy of the location is passed, so that the elements of the `list` are visible, and can be changed inside the `function`.
 
 > This sounds a lot more complex that it is, and it normally does what you expect, but confusing this aspect of the language can result in complex and hard to find bugs.
 
->> Download these two example and convince yourself you understand what is happening
--   Use of an `append` function for `list` and `float`
--   Use of a `sort` function for `list`
-The second of these is rather tricky, try and work out what is
-happening!
+>> Play with these two examples and convince yourself you understand what is happening
+>>-   Use of an `append` function for `list` and `float`
+>>-   Use of a `sort` function for `list`
+>>The second of these is rather tricky, try and work out what is happening!
 
 %% Cell type:code id: tags:
 
 ``` python
 ```

WeeklyTasks/Week0.ipynb

 %% Cell type:markdown id: tags:
 
 # Before Course Starts
 
 Welcome to Scientific Programming! This course aims to provide a gentle introduction to `Python` programming, making use of Jupyter notebooks.
 
 ## Expectations
 
 The course is designed as an introduction to `Python` programming assumming no prior experience of programming whatsoever.
 
 The assessment is performed through a series of checkpoints. For some checkpoints you will need to write the entire code from scratch (or may have some comments to help you structure your program). For others you will be given a working part of the final code needed, with gaps for you to fill in (which will be denoted in the code cells by `...` - the gaps most often will need to be filled with several lines of code, not just the line where the dots are present).
 
 The total amount of work expected for this course (equivalent to the number of credits awarded for the successful completion of it) is **100 hours**, out of which about **3 x 7 = 21 hours** will be spent in in-class **workshops**, and the **rest (~80 hours)** are to be used for **individual study**.
 
 ***Note: It is not feasible to expect to parse and complete the entire course material exclusively during the allocated in-class workshops.***
 
 For more information about the course, please watch the following online mini-lecture:
 - [SciProg - L01 - Introduction and course structure (video)](https://ed-ac-uk.zoom.us/rec/share/zOy03-qGQiinUqbrxFLDvytIvqRvhl7vnh1sq29zMD0tXhtyZkMcPLLtfK3F208n.D_fLStkzPUU6xdx6)
 - [SciProg - L01 - Introduction and course structure (pdf)](../Slides/sciprog-L01-introduction.pdf)
 
 ## No Requirements
 
 This course is designed so that it can be performed entirely within your browser, not needing any local installation of Python or any other programming environments. This also means that it can be performed on any platform (Windows, Linux-based, MacOS, Chromebook), though access to a keyboard is highly beneficial.
 
 By design, you will not need to worry about losing your computer or deleting files by mistake, as your progress throughout the course will be safely saved in the cloud.
 
 In order to achieve this, we will be using the [Noteable](https://noteable.edina.ac.uk) service developed here, at the University of Edinburgh. This will provide a central server (and kernel) for Python, and so a medium upon which we can perform the actual programming, exclusively within Jupyter Notebooks.
 
 **When you do checkpoints please first rename the checkpoint notebook which contains your solutions as CheckpointN_YourUUN, eg. Checkpoint1_s1234567**.
 This is to avoid them being possibly overwritten by mistake and to allow us to distribute extra information if needed.
 
 > It is worth (for offline use and for the future) to download and install [Anaconda](https://www.anaconda.com) on your personal computer so that you will always have access to a Python + JupyterLab environment (this will also be useful for future courses where Jupyter notebooks will be used). Please do this **now**!
 
 > Once installed, you can open the Jupyter-notebook server (that looks just like the server in Noteable on which the current course runs) by searching for ***jupyter-notebook*** in your computer's applications or by typing ***jupyter-notebook*** into a terminal window of your operating system. More information can be found in the links at the bottom of this page.
 
 ## Jupyter Notebooks
 
 Jupyter Notebooks are the most widely used means of communicating and performing interactive computing. In a notebook, you can blend computations and their outputs with explanatory text, mathematics and images.
 
 > We think there is value in practising what you teach, so accordingly this entire course is written and delivered entirely within **Jupyter notebooks**!
 
 The notebooks consist of cells, of which there are 2 types:
 - ***Code cells*** that allow you to type Python code, perform calculations, plotting and anything you may want
 - ***Markdown cells*** that enable you to type in Markdown format blocks of text, equations (using LaTeX style), include links and images
 
 You will see the different types of cells and their usage all throughout the course, as the course notes comprise both *Markdown cells* explaining different concepts in programming, physics and mathematics, as well as *Code cells* that can be executed in-place, interactively, so you can see what exactly specific bits of code produce as an output.
 
 ## Questionnaire
 
-Please complete the [Start of Course Questionnaire in Learn](https://www.learn.ed.ac.uk/ultra/courses/_117833_1/outline/assessment/_10718488_1/overview?)
+Please complete the [Start of Course Questionnaire in Learn](https://www.learn.ed.ac.uk/ultra/courses/_117833_1/outline/assessment/_10718488_1/overview?courseId=_117833_1)
 
 You are now ready to move on to [Week 1](Week1.ipynb) and begin the actual course! Have fun!
 
 ## Additional Information
 
 If you are so-inclined, more information about the infrastructure and philosophy of Jupyter can be found directly at the source, [Jupyter.org](https://jupyter.org/try-jupyter/retro/notebooks/?path=notebooks/Intro.ipynb).
 
 For a quick, simple guide to the Jupyter environment you can consult [Datacamp](https://www.datacamp.com/tutorial/tutorial-jupyter-notebook).
 
 
 
 
 %% Cell type:markdown id: tags:
 

WeeklyTasks/Week2.ipynb

 %% Cell type:markdown id: tags:
 
 # Week Two
 
 ## Online mini-lecture
 
 Please watch the following online mini-lecture:
 - [SciProg - L02 - Adding Structure using functions (video)](https://ed-ac-uk.zoom.us/rec/share/4KGc7RWfsL0k8k7JxI5jyiVBdf_eMGDxdry5jsz3xpvPu6EReL9BO74TlKh5qcDR.aXNq9P93PsIvzhWb?startTime=1663587375000)
 - [SciProg - L02 - Adding Structure using functions (pdf)](../Slides/sciprog-L02-structure.pdf)
 
 ## Course notes
 
 Study the following sections of the course notes before your workshop session:
 
 - [Random Numbers](../CourseNotes/random.ipynb)
 - [Basic Functions](../CourseNotes/basicfunctions.ipynb)
 - [Conditionals](../CourseNotes/conditionalstatements.ipynb)
 
 
 ## Multiple choice questions
 
-Ensure you have completed the on-line quiz [MCQ Test 1](https://www.learn.ed.ac.uk/ultra/courses/_117833_1/outline/assessment/_10718497_1/overview?)
+Ensure you have completed the on-line quiz [MCQ Test 1](https://www.learn.ed.ac.uk/ultra/courses/_117833_1/outline/assessment/_10718497_1/overview?courseId=_117833_1)
 
 ## Workshop
 
 In the workshop you should:
 
 
 1. Work through the example codes in the Functions and Conditionals folders and ensure they work and that you understand them.
 2. Do [Checkpoint 2](../Checkpoints/Checkpoint2.ipynb)
 3. Have Checkpoint 2 assessed and checked off by a TA.
 
 
 ## To do next
 <!---
 The tasks to do next are:
 
 1. Complete the on-line  [MCQ Test 2](https://www.learn.ed.ac.uk/ultra/courses/_108405_1/outline/assessment/_9430146_1/overview?courseId=_108405_1) in Learn.
 2. Please watch the following online mini-lecture:
     - [SciProg - L03 - Flow control (video)](https://ed-ac-uk.zoom.us/rec/share/x2cCNw9WJeqtHWRFv57sC1r1QWD4ikzFXM6o7HsyuWQwfLHDFM1VlnzuEPJt5WMZ.5LUDLkNm0irxWxLA?startTime=1663591435000)
     - [SciProg - L03 - Flow control (pdf)](../Slides/sciprog-L03-flow-control.pdf)
 3. Pre-read the following sections of the notes:
     >- [Lists](../CourseNotes/simplelists.ipynb)
     >- [Loops](../CourseNotes/loops.ipynb)
     >- [Plotting](../CourseNotes/plotting.ipynb)
 4. Explore the code example themes ***Lists***, ***Loops*** and ***Plotting*** from [here](../CodeExamples/CodeExamples.ipynb).
 5.
 -->
 Continue your journey through this course by looking at [Week 3](Week3.ipynb).
-
-%% Cell type:code id: tags:
-
-``` python
-```

WeeklyTasks/Week3.ipynb

 %% Cell type:markdown id: tags:
 
 # Week Three
 
 ## Online mini-lecture
 
 Please watch the following online mini-lecture:
 - [SciProg - L03 - Flow control (video)](https://ed-ac-uk.zoom.us/rec/share/x2cCNw9WJeqtHWRFv57sC1r1QWD4ikzFXM6o7HsyuWQwfLHDFM1VlnzuEPJt5WMZ.5LUDLkNm0irxWxLA?startTime=1663591435000)
 - [SciProg - L03 - Flow control (pdf)](../Slides/sciprog-L03-flow-control.pdf)
 
 ## Course notes
 
 Study the following sections of the course notes before your workshop session:
 
 - [Lists](../CourseNotes/simplelists.ipynb)
 - [Loops](../CourseNotes/loops.ipynb)
 - [Plotting](../CourseNotes/plotting.ipynb)
 
 ## Multiple choice questions
 
-Ensure you have completed the on-line quiz TWO.
+Ensure you have completed the on-line quiz [MCQ Test 2](https://www.learn.ed.ac.uk/ultra/courses/_117833_1/outline/assessment/_10718510_1/overview?courseId=_117833_1)
 
 ## Workshop
 
 In the workshop you should:
 
 1. Work through the example codes in the List, Loops and Plotting folders and ensure they work and that you understand them.
 2. Do [Checkpoint 3](../Checkpoints/Checkpoint3.ipynb)
 3. Have Checkpoint 3 assessed and checked off by a TA.
 
 ## To do next
 <!---
 The tasks to do next are:
 
 1. Complete the on-line [MCQ Test 3](https://www.learn.ed.ac.uk/ultra/courses/_108405_1/outline/assessment/_9430153_1/overview?courseId=_108405_1) in Learn.
 2. Please watch the following online mini-lecture:
     - [SciProg - L04 - Lists (video)](https://ed-ac-uk.zoom.us/rec/share/yK98ttOI_mHJXSXdJhm62wyqaN623aMCCcwD8lzUEXJeJ6SQGafGjZMhMlSLTlPp.ecFJwvAxNPspH4iS?startTime=1663594151000)
     - [SciProg - L04 - Lists (pdf)](../Slides/sciprog-L04-lists.pdf)
 3. Read the following sections of the notes:
     >- [Files](../CourseNotes/fileIO.ipynb)
     >- [Parsing Input](../CourseNotes/ParsingInput.ipynb)
 4. Explore the code example themes ***Files***, ***Functions*** and ***Conditionals*** from [here](../CodeExamples/CodeExamples.ipynb).
 5.
 -->
 Continue your journey through this course by looking at [Week 4](Week4.ipynb).
-
-%% Cell type:code id: tags:
-
-``` python
-```

WeeklyTasks/Week4.ipynb

 %% Cell type:markdown id: tags:
 
 # Week Four
 
 
 ## Course notes
 
 Study the following sections of the course notes before your workshop session:
 - [Files](../CourseNotes/fileIO.ipynb)
 - [Parsing Input](../CourseNotes/ParsingInput.ipynb)
 - Review again [Plotting](../CourseNotes/plotting.ipynb)
 
 ## Multiple choice questions
 
-Ensure you have completed the on-line quiz THREE.
+Ensure you have completed the on-line quiz [MCQ Test 3](https://www.learn.ed.ac.uk/ultra/courses/_117833_1/outline/assessment/_10718527_1/overview?courseId=_117833_1)
 
 ## Workshop
 
 In the workshop we will go through a guided tutorial on [How to design and write a computer program from scratch](../CourseNotes/HowtoWriteaComputerProgramfromScratch.ipynb)
 <!---
 1. Work through the example codes in the List, Loops and Plotting folders and ensure they work and that you understand them.
 2. Do [Checkpoint 4](../Checkpoints/Checkpoint4.ipynb)
 3. Have Checkpoint 4 assessed and checked off by a TA.
 -->
 ## To do next
 <!---
 The tasks to do next are:
 
 1. Complete the FOURTH on-line quiz. [MCQ-4](https://www.learn.ed.ac.uk/ultra/courses/_108405_1/outline/assessment/_9430162_1/overview?courseId=_108405_1)
 2. Please watch the following online mini-lecture:
     - [SciProg - L05 - Functions and Lists (video)](https://ed-ac-uk.zoom.us/rec/share/ckl9Gj8YuPVbaC2dXCjEJA9wVaARETkvP53NE1ivr_s_R2ZKntu-Rpb3bzWTgOkI.mSWzj2ScX9GJPZ99?startTime=1663597243000)
     - [SciProg - L05 - Functions and Lists (pdf)](../Slides/sciprog-L05-functions-lists.pdf)
 3. Read the following sections of the notes:
     >- [More Functions](../CourseNotes/MoreFunctions.ipynb)
     >- [Functions and Lists](../CourseNotes/FunctionsAndLists.ipynb)
 4. Read [Checkpoint 5](../Checkpoints/Checkpoint5.ipynb) and in particular look at the suggested code structure.
 5. Explore the code example themes ***FurtherFunctions*** and optionally ***MoreComplex*** from [here](../CodeExamples/CodeExamples.ipynb).
 6.
 -->
 Continue your journey through this course by looking at [Week 5](Week5.ipynb).
 
 %% Cell type:code id: tags:
 
 ``` python
 ```