Compare revisions

cprutean · cprutean · cprutean · cprutean · cprutean · cprutean
--- a/Checkpoints/Checkpoint1.ipynb
+++ b/Checkpoints/Checkpoint1.ipynb
 %% Cell type:markdown id:33931eba tags:

 ## Checkpoint 1

 ### Aim

 To write a basic `Python` program to prompt for a floating point number, read it in, perform basic arithmetic and print out the result.

 ### Task

 Write a `Python` program to calculate and output the radius and surface area of a sphere from its volume.

 Your program should:

 1. Prompt for the volume of a sphere in $mm^3$.
 2. Calculate and print out to the terminal the radius and the surface area of the sphere in m and $m^2$ respectively in an understandable format.

 Check your program works for a range of volumes, both large and small and that you have the output units correct.

 ### Background

 To complete this checkpoint you need to have read and studied the following course sections:

 1. [Basic Variables](../CourseNotes/variables.ipynb)
 2. [Printing and Reading to/from the terminal](../CourseNotes/terminalIO.ipynb)
 3. [Adding Mathematical Functions](../CourseNotes/functions.ipynb)

 ### Checkpoint

 - Check carefully that you have fullfilled at least the assessement criteria below. Call a demonstrator, show them your code, and run your program with the following input volumes:
-    - $1.4\times10^6\,\text{mm}^3$
-    - $3.7\times10^{-4}\,\text{mm}^3$
+    - $$ 1.4 \times 10^6 \text{ mm}^3 $$
+    - $$ 3.7 \times 10^{-4} \text{ mm}^3 $$
 - Ensure that the demonstrator finds you in Learn. Please check that your pass/fail (0/1) has been entered correctly (you should be able to see this in Learn).

 ### Assessment

 To pass this checkpoint:

 - The program works for the supplied numbers, *including* correct powers of 10.
 - Prompting is sensible and the output is clear.
 - Variable names are concise, but explain their purpose, and there are basic commenets explaining the operation of the program.

 ### Next steps

 Once you have completed this checkpoint, please continue with the [Week1](../WeeklyTasks/Week1.ipynb) tasklist.

 %% Cell type:code id:8d47fffa tags:

 ``` python
 # Placeholder for a comment to describe what this program does (replace as appropriate)

 # Describe the input here
 ...

 # Describe how the input is processed to get to the desired results
 ...

 # Describe the outputs produced
 ...
 ```

 %% Cell type:markdown id:33931eba tags:

 ## Checkpoint 1

 ### Aim

 To write a basic `Python` program to prompt for a floating point number, read it in, perform basic arithmetic and print out the result.

 ### Task

 Write a `Python` program to calculate and output the radius and surface area of a sphere from its volume.

 Your program should:

 1. Prompt for the volume of a sphere in $mm^3$.
 2. Calculate and print out to the terminal the radius and the surface area of the sphere in m and $m^2$ respectively in an understandable format.

 Check your program works for a range of volumes, both large and small and that you have the output units correct.

 ### Background

 To complete this checkpoint you need to have read and studied the following course sections:

 1. [Basic Variables](../CourseNotes/variables.ipynb)
 2. [Printing and Reading to/from the terminal](../CourseNotes/terminalIO.ipynb)
 3. [Adding Mathematical Functions](../CourseNotes/functions.ipynb)

 ### Checkpoint

 - Check carefully that you have fullfilled at least the assessement criteria below. Call a demonstrator, show them your code, and run your program with the following input volumes:
-    - $1.4\times10^6\,\text{mm}^3$
-    - $3.7\times10^{-4}\,\text{mm}^3$
+    - $$ 1.4 \times 10^6 \text{ mm}^3 $$
+    - $$ 3.7 \times 10^{-4} \text{ mm}^3 $$
 - Ensure that the demonstrator finds you in Learn. Please check that your pass/fail (0/1) has been entered correctly (you should be able to see this in Learn).

 ### Assessment

 To pass this checkpoint:

 - The program works for the supplied numbers, *including* correct powers of 10.
 - Prompting is sensible and the output is clear.
 - Variable names are concise, but explain their purpose, and there are basic commenets explaining the operation of the program.

 ### Next steps

 Once you have completed this checkpoint, please continue with the [Week1](../WeeklyTasks/Week1.ipynb) tasklist.

 %% Cell type:code id:8d47fffa tags:

 ``` python
 # Placeholder for a comment to describe what this program does (replace as appropriate)

 # Describe the input here
 ...

 # Describe how the input is processed to get to the desired results
 ...

 # Describe the outputs produced
 ...
 ```

--- a/Checkpoints/Checkpoint2.ipynb
+++ b/Checkpoints/Checkpoint2.ipynb
 %% Cell type:markdown id:75c1fe44 tags:

 ## Checkpoint 2

 ### Aim

 To write a Python program to read in the coefficients of a quadratic equation and print out the roots for all conditions.

 This program demonstrates how to use a simple function, the use of conditional statements, mainly the `if : elif : else:` construct, and how to deal with the various input conditions.

 ### Task

 Write a Python program to read in the three floating point coefficients a, b and c of the quadratic equation:

-$a x^2 + b x + c = 0$
+$$ a x^2 + b x + c = 0$$

-then calculate and display the roots using the standard formula for roots of quadratic being,
+then calculate and display the roots using the standard formula for roots of a quadratic equation, being :

-$r_i = \frac{ −b± \sqrt{b^2−4ac}}{2a}$
+$$ r_i = \frac{ −b± \sqrt{b^2−4ac}}{2a} $$

 The program is expected to deal with conditions of

 1. two real roots
 2. two complex roots
 3. single real root

-Your program must contain a function to calcuate the discriminant, d=$b^2$−4ac
-and must have a main(): method. All variables must be declared inside a function or main().
+Your program must contain a function to calculate the discriminant, $d=b^2−4ac$ and must have a main(): method. All variables must be declared inside a function or main().

 ### Background

 In addition to the sections for Checkpoint 1, you will need to have read and studied the following additional sections:

 1. [Basic Functions](../CourseNotes/basicfunctions.ipynb)
 2. [Conditionals](../CourseNotes/conditionalstatements.ipynb)

 Note: the structure of this program is more complex than it initially looks; plan out what you are going to do before you start coding and also check it a bit at a time.

 ### Checkpoint

 - Check your program with the following values:
    - a=2.0, b=4.0 and c=−8.0
    - a=2.0, b=−4.0 and c=8.0
    - a=2.0, b=4.0 and c=2.0
    - a=0.0, b=6.0 and c=8.0

 Ensure you get sensible answers for the four cases. **Remember when a=0.0 you will get a linear equation with a single root. You should handle this correctly.**
 > #### Note:
 > You should think about using the `cmath.sqrt` and `math.sqrt` functions to deal explicitly with square roots of complex and real numbers respectively.

 - Call a demonstrator, show them your code and run your program with the four sets of inputs above and any additional ones requested by the demonstrator.
 - Ensure that the demonstrator finds you in Learn. Please check that your pass/fail (0/1) has been entered correctly (you should be able to see this in Learn).

 ### Assessment

 To pass this checkpoint:

 - The program must work correctly for at least three of the above four cases.
 - The prompting is sensible.
 - The code structure uses a function to calculate the discriminant and has a main(): function.
 - The code uses conditional statements `(if : elif : else:)` to test for the various cases.

 ### Next steps
 Once you have completed this checkpoint, please continue with the [Week2](../WeeklyTasks/Week2.ipynb) tasklist.

 %% Cell type:code id:883eb6c3 tags:

 ``` python
 ```

 %% Cell type:markdown id:75c1fe44 tags:

 ## Checkpoint 2

 ### Aim

 To write a Python program to read in the coefficients of a quadratic equation and print out the roots for all conditions.

 This program demonstrates how to use a simple function, the use of conditional statements, mainly the `if : elif : else:` construct, and how to deal with the various input conditions.

 ### Task

 Write a Python program to read in the three floating point coefficients a, b and c of the quadratic equation:

-$a x^2 + b x + c = 0$
+$$ a x^2 + b x + c = 0$$

-then calculate and display the roots using the standard formula for roots of quadratic being,
+then calculate and display the roots using the standard formula for roots of a quadratic equation, being :

-$r_i = \frac{ −b± \sqrt{b^2−4ac}}{2a}$
+$$ r_i = \frac{ −b± \sqrt{b^2−4ac}}{2a} $$

 The program is expected to deal with conditions of

 1. two real roots
 2. two complex roots
 3. single real root

-Your program must contain a function to calcuate the discriminant, d=$b^2$−4ac
-and must have a main(): method. All variables must be declared inside a function or main().
+Your program must contain a function to calculate the discriminant, $d=b^2−4ac$ and must have a main(): method. All variables must be declared inside a function or main().

 ### Background

 In addition to the sections for Checkpoint 1, you will need to have read and studied the following additional sections:

 1. [Basic Functions](../CourseNotes/basicfunctions.ipynb)
 2. [Conditionals](../CourseNotes/conditionalstatements.ipynb)

 Note: the structure of this program is more complex than it initially looks; plan out what you are going to do before you start coding and also check it a bit at a time.

 ### Checkpoint

 - Check your program with the following values:
    - a=2.0, b=4.0 and c=−8.0
    - a=2.0, b=−4.0 and c=8.0
    - a=2.0, b=4.0 and c=2.0
    - a=0.0, b=6.0 and c=8.0

 Ensure you get sensible answers for the four cases. **Remember when a=0.0 you will get a linear equation with a single root. You should handle this correctly.**
 > #### Note:
 > You should think about using the `cmath.sqrt` and `math.sqrt` functions to deal explicitly with square roots of complex and real numbers respectively.

 - Call a demonstrator, show them your code and run your program with the four sets of inputs above and any additional ones requested by the demonstrator.
 - Ensure that the demonstrator finds you in Learn. Please check that your pass/fail (0/1) has been entered correctly (you should be able to see this in Learn).

 ### Assessment

 To pass this checkpoint:

 - The program must work correctly for at least three of the above four cases.
 - The prompting is sensible.
 - The code structure uses a function to calculate the discriminant and has a main(): function.
 - The code uses conditional statements `(if : elif : else:)` to test for the various cases.

 ### Next steps
 Once you have completed this checkpoint, please continue with the [Week2](../WeeklyTasks/Week2.ipynb) tasklist.

 %% Cell type:code id:883eb6c3 tags:

 ``` python
 ```

--- a/Checkpoints/Checkpoint3.ipynb
+++ b/Checkpoints/Checkpoint3.ipynb
 %% Cell type:markdown id:ed4c83c4 tags:

 ## Checkpoint 3

 ### Aim

 To write a Python program to explore the behaviour of a damped simple harmonic oscillator for a range of damping coefficients. This involves writing a program to trace out the amplitude against time for a damped simple harmonic oscillator under a range of conditions.

 From a computing viewpoint this checkpoint demonstrates the use of *functions*, *loops*, *lists*, and the `Matplotlib pyplot` library for simple graph plotting.

 ### Mathematical Background

 The damped simple harmonic oscillator satisfies the second order differential equation
 $m\ddot{x} +b \dot{x} + kx=0$ where m is the mass of the oscillator, b is the coefficient of damping, and k is the spring constant.

 Defining new constants
 $\gamma$=b/m and $\omega_0^2$=k/m
 we can re-write the differential equation as:

 $$\ddot{x} + \gamma \dot{x} + \omega_{0}^2x =0 $$

 where $ω_0$ is known as the natural frequency of the undamped oscillator.

 The solutions to this equation take the following forms:

-$$ x=\exp(−γt/2)[a\cosh(pt)+b\sinh(pt)]  when  γ>2ω_0  with  p^2=(γ^2/4)−ω^2_0 $$
+$$ x=\exp(−γt/2)[a\cosh(pt)+b\sinh(pt)]  \text{ when }  γ>2ω_0  \text{ with }  p^2=(γ^2/4)−ω^2_0 $$

-$$ x=\exp(−γt/2)[a+bt]  when  γ=2ω_0 $$
+$$ x=\exp(−γt/2)[a+bt]  \text{ when }  γ=2ω_0 $$

-$$ x=\exp(−γt/2)[a\cos(ωt)+b\sin(ωt)] when  γ<2ω_0  with ω^2=ω^2_0−(γ^2/4)$$
+$$ x=\exp(−γt/2)[a\cos(ωt)+b\sin(ωt)] \text{ when }  γ<2ω_0  \text{ with } ω^2=ω^2_0−(γ^2/4)$$

 where these three conditions are known as over damped, critically damped and under damped respectively.

 Note: Read these equations *very* carefully and note the location of the parentheses.

-With the initial conditions that x=1 and $\dot{x}$ =0 at t=0 the above constants, after some manipulation, become,
+With the initial conditions that x=1 and $\dot{x}$ =0 at t=0 the above constants, after some manipulation, become

-a=1 b=$\gamma$/2p when $\gamma$>2ω$_0$
+$$ a=1 \text{, } b=\gamma/2p \text{ when } \gamma>2ω_0 $$

-a=1 b=$\gamma$/2 when $\gamma$=2ω$_0$
+$$ a=1 \text{, } b=\gamma/2 \text{ when } \gamma=2ω_0 $$

-a=1 b=$\gamma$/2ω when $\gamma$<2ω$_0$
+$$ a=1 \text{, } b=\gamma/2ω \text{ when } \gamma<2ω_0 $$

 ### Task

-Write an interactive Python program to compute and display, using the pyplot function from Matplotlib, the solution for x against t for t in the range 0$\to 5\pi/ω_0$. Your program should:
+Write an interactive Python program to compute and display, using the pyplot function from Matplotlib, the solution for x against t for t in the range $0 \to 5\pi/ω_0$. Your program should:

- Ask for and read in the values of ω$_0$, $\gamma$ and the number of points to plot on the graph from the terminal.
+- Ask for and read in the values of $ω_0$, $\gamma$ and the number of points to plot on the graph from the terminal.
 - Use a function of form shm(omega_zero,gamma,t) to calculate the displacement.
 - Calculate and plot the amplitude and time to lists
 - Plot the output via pyplot with suitable title and labels to axis
 - Look at the structure of the [FlightPlot](../CodeExamples/FlightPlot.ipynb) example for structure.

 ### Background

 For this checkpoint you will need to have read and studied the following sections:

 1. [Lists](../CourseNotes/simplelists.ipynb)
 2. [Loops](../CourseNotes/loops.ipynb)
 3. [Plotting](../CourseNotes/plotting.ipynb)

 Note: The structure of this program is reasonably complex. Think carefully how you are going to structure it before you start. Also be very careful when coding the expression for the amplitude of the oscillation; in particular make sure it is performing the correct arithmetic (there is some helpful code for this included below).


 ### Checkpoint

- Test your program using the following input paramters:
-    - $\gamma=0.5\ \quad\&\quad \omega_0=1.0\quad$ for an under damped condition.
-    - $\gamma=2.0\ \quad\&\quad \omega_0=1.0\quad$ for a critically damped condition.
-    - $\gamma=20.0\! \quad\&\quad \omega_0=1.0\quad$ for an over damped condition.
+- Test your program using the following input parameters:
+    - Case 1: $\gamma=0.5 \text{ and } \omega_0=1.0$ for an under damped condition.
+    - Case 2: $\gamma=2.0 \text{ and } \omega_0=1.0$ for a critically damped condition.
+    - Case 3: $\gamma=20.0 \text{ and } \omega_0=1.0$ for an over damped condition.
 - To obtain a smooth plot you need to calculate the above expression for at least 200 evenly spaced values of t.
 - Call a demonstrator, show them your code and run your program with the three sets of inputs above and any additional ones requested by the demonstrator.

 ### Assessment

 To pass this checkpoint:

 - The programme works correctly for at least two of the three cases and the output plotted via pyplot.
 - The output graph has correct title and labels.
 - The program uses a function of the form shm(omega_zero,gamma,t) to calculate the displacement.
 - The program calculates and stores the amplitude and time in lists with a loop to iterate over the number of points for the plot.

 ### Next steps
 Once you have completed this checkpoint, please continue with the [Week3](../WeeklyTasks/Week3.ipynb) tasklist.

 %% Cell type:code id:6077b2ca tags:

 ``` python
 """
   Damped harmonic oscillator
 """
 import math
 import matplotlib.pyplot as plt     # Import the plot package as plt

 # Somewhere in your code you will need to implement the 3 distinct cases presented in the text to deal with various damping scenarios
 if gamma ? :
    ...
    x = math.exp(-gamma*t/2)*(a*math.cosh(p*t) + b*math.sinh(p*t))
 elif gamma ?:
    ...
    x = math.exp(-gamma*t/2)*(a+b*t)
 else:
    ...
    x = math.exp(-gamma*t/2)*(a*math.cos(omega*t) + b*math.sin(omega*t))


 ```

 %% Cell type:markdown id:ed4c83c4 tags:

 ## Checkpoint 3

 ### Aim

 To write a Python program to explore the behaviour of a damped simple harmonic oscillator for a range of damping coefficients. This involves writing a program to trace out the amplitude against time for a damped simple harmonic oscillator under a range of conditions.

 From a computing viewpoint this checkpoint demonstrates the use of *functions*, *loops*, *lists*, and the `Matplotlib pyplot` library for simple graph plotting.

 ### Mathematical Background

 The damped simple harmonic oscillator satisfies the second order differential equation
 $m\ddot{x} +b \dot{x} + kx=0$ where m is the mass of the oscillator, b is the coefficient of damping, and k is the spring constant.

 Defining new constants
 $\gamma$=b/m and $\omega_0^2$=k/m
 we can re-write the differential equation as:

 $$\ddot{x} + \gamma \dot{x} + \omega_{0}^2x =0 $$

 where $ω_0$ is known as the natural frequency of the undamped oscillator.

 The solutions to this equation take the following forms:

-$$ x=\exp(−γt/2)[a\cosh(pt)+b\sinh(pt)]  when  γ>2ω_0  with  p^2=(γ^2/4)−ω^2_0 $$
+$$ x=\exp(−γt/2)[a\cosh(pt)+b\sinh(pt)]  \text{ when }  γ>2ω_0  \text{ with }  p^2=(γ^2/4)−ω^2_0 $$

-$$ x=\exp(−γt/2)[a+bt]  when  γ=2ω_0 $$
+$$ x=\exp(−γt/2)[a+bt]  \text{ when }  γ=2ω_0 $$

-$$ x=\exp(−γt/2)[a\cos(ωt)+b\sin(ωt)] when  γ<2ω_0  with ω^2=ω^2_0−(γ^2/4)$$
+$$ x=\exp(−γt/2)[a\cos(ωt)+b\sin(ωt)] \text{ when }  γ<2ω_0  \text{ with } ω^2=ω^2_0−(γ^2/4)$$

 where these three conditions are known as over damped, critically damped and under damped respectively.

 Note: Read these equations *very* carefully and note the location of the parentheses.

-With the initial conditions that x=1 and $\dot{x}$ =0 at t=0 the above constants, after some manipulation, become,
+With the initial conditions that x=1 and $\dot{x}$ =0 at t=0 the above constants, after some manipulation, become

-a=1 b=$\gamma$/2p when $\gamma$>2ω$_0$
+$$ a=1 \text{, } b=\gamma/2p \text{ when } \gamma>2ω_0 $$

-a=1 b=$\gamma$/2 when $\gamma$=2ω$_0$
+$$ a=1 \text{, } b=\gamma/2 \text{ when } \gamma=2ω_0 $$

-a=1 b=$\gamma$/2ω when $\gamma$<2ω$_0$
+$$ a=1 \text{, } b=\gamma/2ω \text{ when } \gamma<2ω_0 $$

 ### Task

-Write an interactive Python program to compute and display, using the pyplot function from Matplotlib, the solution for x against t for t in the range 0$\to 5\pi/ω_0$. Your program should:
+Write an interactive Python program to compute and display, using the pyplot function from Matplotlib, the solution for x against t for t in the range $0 \to 5\pi/ω_0$. Your program should:

- Ask for and read in the values of ω$_0$, $\gamma$ and the number of points to plot on the graph from the terminal.
+- Ask for and read in the values of $ω_0$, $\gamma$ and the number of points to plot on the graph from the terminal.
 - Use a function of form shm(omega_zero,gamma,t) to calculate the displacement.
 - Calculate and plot the amplitude and time to lists
 - Plot the output via pyplot with suitable title and labels to axis
 - Look at the structure of the [FlightPlot](../CodeExamples/FlightPlot.ipynb) example for structure.

 ### Background

 For this checkpoint you will need to have read and studied the following sections:

 1. [Lists](../CourseNotes/simplelists.ipynb)
 2. [Loops](../CourseNotes/loops.ipynb)
 3. [Plotting](../CourseNotes/plotting.ipynb)

 Note: The structure of this program is reasonably complex. Think carefully how you are going to structure it before you start. Also be very careful when coding the expression for the amplitude of the oscillation; in particular make sure it is performing the correct arithmetic (there is some helpful code for this included below).


 ### Checkpoint

- Test your program using the following input paramters:
-    - $\gamma=0.5\ \quad\&\quad \omega_0=1.0\quad$ for an under damped condition.
-    - $\gamma=2.0\ \quad\&\quad \omega_0=1.0\quad$ for a critically damped condition.
-    - $\gamma=20.0\! \quad\&\quad \omega_0=1.0\quad$ for an over damped condition.
+- Test your program using the following input parameters:
+    - Case 1: $\gamma=0.5 \text{ and } \omega_0=1.0$ for an under damped condition.
+    - Case 2: $\gamma=2.0 \text{ and } \omega_0=1.0$ for a critically damped condition.
+    - Case 3: $\gamma=20.0 \text{ and } \omega_0=1.0$ for an over damped condition.
 - To obtain a smooth plot you need to calculate the above expression for at least 200 evenly spaced values of t.
 - Call a demonstrator, show them your code and run your program with the three sets of inputs above and any additional ones requested by the demonstrator.

 ### Assessment

 To pass this checkpoint:

 - The programme works correctly for at least two of the three cases and the output plotted via pyplot.
 - The output graph has correct title and labels.
 - The program uses a function of the form shm(omega_zero,gamma,t) to calculate the displacement.
 - The program calculates and stores the amplitude and time in lists with a loop to iterate over the number of points for the plot.

 ### Next steps
 Once you have completed this checkpoint, please continue with the [Week3](../WeeklyTasks/Week3.ipynb) tasklist.

 %% Cell type:code id:6077b2ca tags:

 ``` python
 """
   Damped harmonic oscillator
 """
 import math
 import matplotlib.pyplot as plt     # Import the plot package as plt

 # Somewhere in your code you will need to implement the 3 distinct cases presented in the text to deal with various damping scenarios
 if gamma ? :
    ...
    x = math.exp(-gamma*t/2)*(a*math.cosh(p*t) + b*math.sinh(p*t))
 elif gamma ?:
    ...
    x = math.exp(-gamma*t/2)*(a+b*t)
 else:
    ...
    x = math.exp(-gamma*t/2)*(a*math.cos(omega*t) + b*math.sin(omega*t))


 ```

--- a/Checkpoints/Checkpoint4.ipynb
+++ b/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
 ```

 %% 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
 ```

--- a/Checkpoints/Checkpoint6.ipynb
+++ b/Checkpoints/Checkpoint6.ipynb
 %% Cell type:markdown id:51574bca tags:

 ## Checkpoint 6

 ### Aim

 To write a Python program to calculate the volume of molecules made up of overlapping spherical atoms; it is also an example in using OOP to simpify the task. Don't get frightened, for this checkpoint you will be given part of the code to help you progress (***this also simulates pretty well how multi-person software development works***).

 ## Monte Carlo estimate of π

-Consider a circle of radius r within a square of side 2r$\times$2r as shown in the figure below.
+Consider a circle of radius r within a square of side $2r \times 2r$ as shown in the figure below.

 ![dynamicpng-width_300.png](dynamicpng-width_300.png)

 ### Calculation of π by estimation of area.

 If we randomly pick N points evenly distributed within the square and $N_{i}$ of them are inside the circle, then an estimate of the area of the circle A is given by the fraction falling inside the circle multiplied by the area of the square, so

 $$ A=4r^ 2 \frac{N_i}{N} $$

-Noting that A=$\pi r^2$, we get an estimate for the value of π given by,
+Noting that $A=\pi r^2$, we get an estimate for the value of π given by,

 $$ π≈4 \frac{N_i}{N} $$

 So provided the selection of points is evenly distributed over the whole square, than as N becomes large you will get a good estimate for $\pi$. This is the basis of Monte Carlo integration and can be used to estimate the internal area of any closed object.

 See an example Python code that uses the random.uniform() function to form random points:

 - Code example to calculate $\pi$ [here](../CodeExamples/PiExample.ipynb)

 Take a look at this and experiment, you will find that for N>200,000 you get a reasonable estimate for $\pi$, and that as N gets larger the estimate gets better.

 This is clearly a "very bad" way to calcuate π, but is very useful for finding the area of overlapping objects in two-dimensions as shown in the figure below; which is otherwise analytically tricky.
 ![dynamicpng-width_250.png](dynamicpng-width_250.png)

 This can also easily be extended to three-dimensions so for example overlapping spheres as shown below.
 ![dynamicpng-width_2502.png](dynamicpng-width_2502.png)

 Here the method is to form a bounding box of dimensions Vb=a×b×c that totally encloses the object. If N points are in the bounding box and N$_i$ are inside the object, then the volume of the object is simply given by

 $$ V_0=V_b \frac{N_i}{N} $$

 This technique is used in computer simulations of molecules to calculate the volume of molecules that are made up of overlapping spherical atoms.


 #### Code Structure

 This is rather tricky program but it can be vastly simplied by use of OOP; the suggested structure is

 1. Form an Atom class by extending the Vector3d class given by Vector3d Class
 2. The Atom class should add an extra internal variable radius and have a boolean method isInside(v) which takes argument v being a Vector3d and returns True if v is inside the atom. (Note the distance(v) method of Vector3d is useful here.)
 3. Form a Molecule class that has a list of objects of type Atom and a boolean method isInside(v), which takes argument v being a Vector3d and returns True if v is inside the molecule.

 - You also need to consider how to read in the location of the atoms; this is similar to Checkpoint 4.

 4. Form a BoundingBox class where the constructor takes a populated Molecule and finds and stores internally the minima / maxima of the box round the molecule (you need 6 floats). This class should have two methods:
 - volume() that gets the volume of the box.
 - getRandomPoint() which should return a random Vector3d that is randomly distributed inside the box.

    (This is the most “messy” bit of the code to write.)

 If you have this structure, then what your main program has to do is:

 - Ask for the file containing the Atom data and read this into a Molecule.
 - Construct a BoundingBox from the Molecule
 - Go round a while loop,
 - Getting a random Vector3d from the BoundingBox
 - Testing if it isInside() the Molecule and incrementing a counter if it is.
 - Finally calculating the estimate for the Molecule volume and printing it out.

 It is also useful to monitor the progress of the estimate as was done in the example code for estimation of π to check how the integration is going.

 #### Format of Data

 There are two data files suppied (in the current directory, so they can be read in and executed directly upon here), these being :

 - [oxygen.data](oxygen.data) : single oxygen atom
 - [water.data](water.data) : water molecule

 each consists of a comma delimited CSV file with one atom per line in the format,

 Name , r , x , y , z

 with comment lines delimited by # being the same format as coded in [Parsing Input](../CourseNotes/ParsingInput.ipynb) and used in [Checkpoint 4](Checkpoint4.ipynb).

 #### Computing Task

 Write a Python program based on the above structure to:

 1. Read in the data file defining the atom locations.
 2. Prompt the user for the number of points to run in the calculation.
 3. Calculate the volume of the molecule using Monte Carlo integration and output the final value.
 4. Optionally plot a graph of the convergence of the algorithm, being the estimate against number of points. The graph should have 100 data points at regular intervals, see Pi example for how to to this easily.
 5. Test your code with a single oxygen atom and with water. ***For a pass, only the atom is strictly necessary to run.***
 > #### Note
 > The volume of a single oxygen atom of radius 1.4 Å is 11.494 Å$^3$. The volume of water is $\approx$ 15.5 Å$^3$. Use these values to check your results before calling a demonstrator.
 6. Have another careful read of [final weekly task](../WeeklyTasks/Week6.ipynb).


 %% Cell type:code id:9376506d tags:

 ``` python
 """"
    A more developed Vector class for simple 3d vectors
 """

 import math
 import random
 class Vector3d(object):
    """
    Simple vector 3d class
    """
    def __init__(self, x, y, z):
        """
        Constructor to form a vector
        """
        self.x = float(x)
        self.y = float(y)
        self.z = float(z)

    def __str__(self):
        """
        Method to format a vector as a string (implments str())
        """
        return "[" + str(self.x) + ", " + str(self.y) + ", " + str(self.z) + "]"

    def copy(self):
        """
        Method to return a copy of current vector
        """
        return Vector3d(self.x,self.y,self.z)

    def magnitude(self):
        """
        Return the magnitude
        """
        return math.sqrt(self.x*self.x + self.y*self.y + self.z*self.z)

    def distance(self,b):
        """
        Distance from self to vector b
        """
        dx = self.x - b.x
        dy = self.y - b.y
        dz = self.z - b.z
        return math.sqrt(dx*dx + dy*dy + dz*dz)


    def normalise(self):
        """
        Normalise current vector so its magnitude is 1.0 (unit vector)
        """
        mag = self.magnitude()
        if mag != 0.0 :         # if not already zero
            self.x /= mag       # dveive throgh by mag
            self.y /= mag
            self.z /= mag

    def add(self,b):
        """
        Add a vector b to self and return a new vector.
        """
        x = self.x + b.x
        y = self.y + b.y
        z = self.z + b.z
        return Vector3d(x,y,z)

    def addTo(self,b):
        """
        Add a vector b to self in place.
        """
        self.x += b.x
        self.y += b.y
        self.z += b.z


    def dot(self,b):
        """
        Form dot product between self and vector b
        """
        return self.x*b.x + self.y*b.y + self.z*b.z

    def cross(self,b):
        """
        Form cross product between self and vector b.
        """
        x = self.y*b.z - self.z*b.y
        y = self.z*b.x - self.x*b.z
        z = self.x*b.y - self.y*b.x
        return Vector3d(x,y,z)

 def main():
    """
    Simple test program to test the vectors
    """
    a = Vector3d(1,2,3)
    b = Vector3d(4,5,6)

    print("Magnitude of a is " + str(a.magnitude()))

    c = a.cross(b)           # Form cross product
    #
    #         the str() function call the __str__(self) method
    print("Cross product of a x b is : " + str(c))



 #main()
 ```

 %% Cell type:code id:e0aad9ca tags:

 ``` python
 ### Atom class

 class Atom(Vector3d):
    """
    The Atom class to extends the Vector3d that hold position
    """

    def __init__(self,x,y,z,r):
        """
        Constructor to form an atom with x,y,z,r parameters
        """
        # Your code here


    def __str__(self):
        """
        Implemnts str()
        """
        # Your code here


    def isInside(self,v):
        """
        isInside method, returns True of v in inside atom
        """
        # Your code here

 ```

 %% Cell type:code id:fccc8a4e tags:

 ``` python
 ### Molecule class

 class Molecule(list):
    """
    Molecule, being a list to hold Atoms
    """
    def __init__(self,*args):
        """
        Constructor to form a Molecule with optional arguments each one assumed to be an Atom
        """
        list.__init__(self)      # Init underlying list
        for a in args:           # Append any args to list
            self.append(a)

    def __str__(self):
        """      Format string of all atoms
        """
        s = ""
        for a in self:
            s += str(a) + "\n"
        return s

    def inInside(self, v):
        """
        Method to check if vector is inside moleule.
        """
        # Your code here


        return False           # if here then outside

    def fromFile(self,file):
        """
        Read Atoms from a file
        """
        # Your code here

 ```

 %% Cell type:code id:663fe126 tags:

 ``` python
 ### BoundingBox class

 class BoundingBox(object):
    """
    Class to define a  bounding box class round the molecule
    """
    def __init__(self, molecule):
        """
        The Constructor, which takes a molecule
        """
        self.xmin = float("inf")             # Initially set limits to +/- infty
        self.ymin = float("inf")
        self.zmin = float("inf")
        self.xmax = float("-inf")
        self.ymax = float("-inf")
        self.zmax = float("-inf")

        for a in molecule:                  # update limits for each atom in molecule
           # Your code here

    def volume(self):
        """
        Get the volume of the box
        """
        # Your code here


    def getRandomPoint(self):
        """
            Get a random point in the bounding box as a Vector3d.
        """
        # Your code here

 ```

 %% Cell type:code id:3e01a08e tags:

 ``` python

 """    Main program to do the simulation
 """

 file = open(str(input("File : ")),"r")   # Open file
 mol = Molecule().fromFile(file)              # Read in molecule
 print("Molecule is \n" + str(mol))           # Print out info
 box = BoundingBox(mol)                       # Form Bounding box

 maxpoint = float(input("Number of points : ")) # Max number of points
 plotInterval = maxpoint/100                    # Plot internal for monitoring

 # Your code here


 while p < maxpoint:                          # Loop counting internal points
    # Your code here
 ...



 print("Final estimate is : " + str(estimate))
 plt.plot(xData,yData)                       # Draw graph (with default plot)
 plt.ylim(0.9*estimate,1.1*estimate)
 plt.title("Estimate of volume for " + str(maxpoint) + " points.")
 plt.show()
 ```

 %% Cell type:markdown id:51574bca tags:

 ## Checkpoint 6

 ### Aim

 To write a Python program to calculate the volume of molecules made up of overlapping spherical atoms; it is also an example in using OOP to simpify the task. Don't get frightened, for this checkpoint you will be given part of the code to help you progress (***this also simulates pretty well how multi-person software development works***).

 ## Monte Carlo estimate of π

-Consider a circle of radius r within a square of side 2r$\times$2r as shown in the figure below.
+Consider a circle of radius r within a square of side $2r \times 2r$ as shown in the figure below.

 ![dynamicpng-width_300.png](dynamicpng-width_300.png)

 ### Calculation of π by estimation of area.

 If we randomly pick N points evenly distributed within the square and $N_{i}$ of them are inside the circle, then an estimate of the area of the circle A is given by the fraction falling inside the circle multiplied by the area of the square, so

 $$ A=4r^ 2 \frac{N_i}{N} $$

-Noting that A=$\pi r^2$, we get an estimate for the value of π given by,
+Noting that $A=\pi r^2$, we get an estimate for the value of π given by,

 $$ π≈4 \frac{N_i}{N} $$

 So provided the selection of points is evenly distributed over the whole square, than as N becomes large you will get a good estimate for $\pi$. This is the basis of Monte Carlo integration and can be used to estimate the internal area of any closed object.

 See an example Python code that uses the random.uniform() function to form random points:

 - Code example to calculate $\pi$ [here](../CodeExamples/PiExample.ipynb)

 Take a look at this and experiment, you will find that for N>200,000 you get a reasonable estimate for $\pi$, and that as N gets larger the estimate gets better.

 This is clearly a "very bad" way to calcuate π, but is very useful for finding the area of overlapping objects in two-dimensions as shown in the figure below; which is otherwise analytically tricky.
 ![dynamicpng-width_250.png](dynamicpng-width_250.png)

 This can also easily be extended to three-dimensions so for example overlapping spheres as shown below.
 ![dynamicpng-width_2502.png](dynamicpng-width_2502.png)

 Here the method is to form a bounding box of dimensions Vb=a×b×c that totally encloses the object. If N points are in the bounding box and N$_i$ are inside the object, then the volume of the object is simply given by

 $$ V_0=V_b \frac{N_i}{N} $$

 This technique is used in computer simulations of molecules to calculate the volume of molecules that are made up of overlapping spherical atoms.


 #### Code Structure

 This is rather tricky program but it can be vastly simplied by use of OOP; the suggested structure is

 1. Form an Atom class by extending the Vector3d class given by Vector3d Class
 2. The Atom class should add an extra internal variable radius and have a boolean method isInside(v) which takes argument v being a Vector3d and returns True if v is inside the atom. (Note the distance(v) method of Vector3d is useful here.)
 3. Form a Molecule class that has a list of objects of type Atom and a boolean method isInside(v), which takes argument v being a Vector3d and returns True if v is inside the molecule.

 - You also need to consider how to read in the location of the atoms; this is similar to Checkpoint 4.

 4. Form a BoundingBox class where the constructor takes a populated Molecule and finds and stores internally the minima / maxima of the box round the molecule (you need 6 floats). This class should have two methods:
 - volume() that gets the volume of the box.
 - getRandomPoint() which should return a random Vector3d that is randomly distributed inside the box.

    (This is the most “messy” bit of the code to write.)

 If you have this structure, then what your main program has to do is:

 - Ask for the file containing the Atom data and read this into a Molecule.
 - Construct a BoundingBox from the Molecule
 - Go round a while loop,
 - Getting a random Vector3d from the BoundingBox
 - Testing if it isInside() the Molecule and incrementing a counter if it is.
 - Finally calculating the estimate for the Molecule volume and printing it out.

 It is also useful to monitor the progress of the estimate as was done in the example code for estimation of π to check how the integration is going.

 #### Format of Data

 There are two data files suppied (in the current directory, so they can be read in and executed directly upon here), these being :

 - [oxygen.data](oxygen.data) : single oxygen atom
 - [water.data](water.data) : water molecule

 each consists of a comma delimited CSV file with one atom per line in the format,

 Name , r , x , y , z

 with comment lines delimited by # being the same format as coded in [Parsing Input](../CourseNotes/ParsingInput.ipynb) and used in [Checkpoint 4](Checkpoint4.ipynb).

 #### Computing Task

 Write a Python program based on the above structure to:

 1. Read in the data file defining the atom locations.
 2. Prompt the user for the number of points to run in the calculation.
 3. Calculate the volume of the molecule using Monte Carlo integration and output the final value.
 4. Optionally plot a graph of the convergence of the algorithm, being the estimate against number of points. The graph should have 100 data points at regular intervals, see Pi example for how to to this easily.
 5. Test your code with a single oxygen atom and with water. ***For a pass, only the atom is strictly necessary to run.***
 > #### Note
 > The volume of a single oxygen atom of radius 1.4 Å is 11.494 Å$^3$. The volume of water is $\approx$ 15.5 Å$^3$. Use these values to check your results before calling a demonstrator.
 6. Have another careful read of [final weekly task](../WeeklyTasks/Week6.ipynb).


 %% Cell type:code id:9376506d tags:

 ``` python
 """"
    A more developed Vector class for simple 3d vectors
 """

 import math
 import random
 class Vector3d(object):
    """
    Simple vector 3d class
    """
    def __init__(self, x, y, z):
        """
        Constructor to form a vector
        """
        self.x = float(x)
        self.y = float(y)
        self.z = float(z)

    def __str__(self):
        """
        Method to format a vector as a string (implments str())
        """
        return "[" + str(self.x) + ", " + str(self.y) + ", " + str(self.z) + "]"

    def copy(self):
        """
        Method to return a copy of current vector
        """
        return Vector3d(self.x,self.y,self.z)

    def magnitude(self):
        """
        Return the magnitude
        """
        return math.sqrt(self.x*self.x + self.y*self.y + self.z*self.z)

    def distance(self,b):
        """
        Distance from self to vector b
        """
        dx = self.x - b.x
        dy = self.y - b.y
        dz = self.z - b.z
        return math.sqrt(dx*dx + dy*dy + dz*dz)


    def normalise(self):
        """
        Normalise current vector so its magnitude is 1.0 (unit vector)
        """
        mag = self.magnitude()
        if mag != 0.0 :         # if not already zero
            self.x /= mag       # dveive throgh by mag
            self.y /= mag
            self.z /= mag

    def add(self,b):
        """
        Add a vector b to self and return a new vector.
        """
        x = self.x + b.x
        y = self.y + b.y
        z = self.z + b.z
        return Vector3d(x,y,z)

    def addTo(self,b):
        """
        Add a vector b to self in place.
        """
        self.x += b.x
        self.y += b.y
        self.z += b.z


    def dot(self,b):
        """
        Form dot product between self and vector b
        """
        return self.x*b.x + self.y*b.y + self.z*b.z

    def cross(self,b):
        """
        Form cross product between self and vector b.
        """
        x = self.y*b.z - self.z*b.y
        y = self.z*b.x - self.x*b.z
        z = self.x*b.y - self.y*b.x
        return Vector3d(x,y,z)

 def main():
    """
    Simple test program to test the vectors
    """
    a = Vector3d(1,2,3)
    b = Vector3d(4,5,6)

    print("Magnitude of a is " + str(a.magnitude()))

    c = a.cross(b)           # Form cross product
    #
    #         the str() function call the __str__(self) method
    print("Cross product of a x b is : " + str(c))



 #main()
 ```

 %% Cell type:code id:e0aad9ca tags:

 ``` python
 ### Atom class

 class Atom(Vector3d):
    """
    The Atom class to extends the Vector3d that hold position
    """

    def __init__(self,x,y,z,r):
        """
        Constructor to form an atom with x,y,z,r parameters
        """
        # Your code here


    def __str__(self):
        """
        Implemnts str()
        """
        # Your code here


    def isInside(self,v):
        """
        isInside method, returns True of v in inside atom
        """
        # Your code here

 ```

 %% Cell type:code id:fccc8a4e tags:

 ``` python
 ### Molecule class

 class Molecule(list):
    """
    Molecule, being a list to hold Atoms
    """
    def __init__(self,*args):
        """
        Constructor to form a Molecule with optional arguments each one assumed to be an Atom
        """
        list.__init__(self)      # Init underlying list
        for a in args:           # Append any args to list
            self.append(a)

    def __str__(self):
        """      Format string of all atoms
        """
        s = ""
        for a in self:
            s += str(a) + "\n"
        return s

    def inInside(self, v):
        """
        Method to check if vector is inside moleule.
        """
        # Your code here


        return False           # if here then outside

    def fromFile(self,file):
        """
        Read Atoms from a file
        """
        # Your code here

 ```

 %% Cell type:code id:663fe126 tags:

 ``` python
 ### BoundingBox class

 class BoundingBox(object):
    """
    Class to define a  bounding box class round the molecule
    """
    def __init__(self, molecule):
        """
        The Constructor, which takes a molecule
        """
        self.xmin = float("inf")             # Initially set limits to +/- infty
        self.ymin = float("inf")
        self.zmin = float("inf")
        self.xmax = float("-inf")
        self.ymax = float("-inf")
        self.zmax = float("-inf")

        for a in molecule:                  # update limits for each atom in molecule
           # Your code here

    def volume(self):
        """
        Get the volume of the box
        """
        # Your code here


    def getRandomPoint(self):
        """
            Get a random point in the bounding box as a Vector3d.
        """
        # Your code here

 ```

 %% Cell type:code id:3e01a08e tags:

 ``` python

 """    Main program to do the simulation
 """

 file = open(str(input("File : ")),"r")   # Open file
 mol = Molecule().fromFile(file)              # Read in molecule
 print("Molecule is \n" + str(mol))           # Print out info
 box = BoundingBox(mol)                       # Form Bounding box

 maxpoint = float(input("Number of points : ")) # Max number of points
 plotInterval = maxpoint/100                    # Plot internal for monitoring

 # Your code here


 while p < maxpoint:                          # Loop counting internal points
    # Your code here
 ...



 print("Final estimate is : " + str(estimate))
 plt.plot(xData,yData)                       # Draw graph (with default plot)
 plt.ylim(0.9*estimate,1.1*estimate)
 plt.title("Estimate of volume for " + str(maxpoint) + " points.")
 plt.show()
 ```

--- a/Checkpoints/ch4.jpg
+++ b/Checkpoints/ch4.jpg
--- a/CourseNotes/FunctionsAndLists.ipynb
+++ b/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.
-%% 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.
--- a/CourseNotes/GetPython.ipynb
+++ b/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 !

-%% 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 !

--- a/CourseNotes/HowtoWriteaComputerProgramfromScratch.ipynb
+++ b/CourseNotes/HowtoWriteaComputerProgramfromScratch.ipynb
--- a/CourseNotes/MoreFunctions.ipynb
+++ b/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
 ```

 %% 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
 ```

--- a/CourseNotes/Scope.ipynb
+++ b/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
 ```

-%% 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
 ```

--- a/CourseNotes/assessment.ipynb
+++ b/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

-**Remember before you start a checkpoint please first rename the checkpoint notebook which contains your solutions as CheckpointN_YourUUN, eg. Checkpoint1_s1234567**.
+**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 28th September 2023**
+    > 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 5th October 2023**
+    > 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 12th October 2023**
+    > 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.
-    > Deadline: **Thursday 5:00pm 19th October 2023**
+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  26th October 2023**
+    > 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 2rd November 2023**
+    > 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:


 %% 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

-**Remember before you start a checkpoint please first rename the checkpoint notebook which contains your solutions as CheckpointN_YourUUN, eg. Checkpoint1_s1234567**.
+**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 28th September 2023**
+    > 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 5th October 2023**
+    > 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 12th October 2023**
+    > 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.
-    > Deadline: **Thursday 5:00pm 19th October 2023**
+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  26th October 2023**
+    > 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 2rd November 2023**
+    > 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:


--- a/CourseNotes/basicfunctions.ipynb
+++ b/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
 ```

-%% 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
 ```

--- a/CourseNotes/conditionalstatements.ipynb
+++ b/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
 ```

-%% 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
 ```

--- a/CourseNotes/fileIO.ipynb
+++ b/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
 ```

 %% 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
 ```

--- a/CourseNotes/loops.ipynb
+++ b/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.

 %% 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.

--- a/CourseNotes/plotting.ipynb
+++ b/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
 ```

 %% 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
 ```

--- a/CourseNotes/program.ipynb
+++ b/CourseNotes/program.ipynb
 %% Cell type:markdown id:776882d3 tags:

 # What is a Computer Program

 ## What is a Computer ?
 Before we start teaching *computer programming* we need to first ask
 *what is a computer*. A simplfied structure of a computer is shown
 below.

 <div>
 <img src="png.png" width="500"/>
 </div>

 The *Central Processing Unit* (CPU) operates on a series of instructions
 called a *program* which is stored in *memory*. The CPU consists of an
 *Arithmetic Logic Unit* (ALU) which performs such functions as addition,
 subtraction, comparison etc. and a *Control Unit* which directs and
 monitors the operation of the computer. The *input* and *output* provide
 an interface to the outside world, for example the *input* may be the
 keyboard and *output* the display screen. The *input* and *output* units
 also provide access to data storage devices such as hard discs, DVDs,
 USB devices etc. All these may be either connected directly to the
 computer or over the *network*.

 The computer holds all information (numbers, letters, instructions) in
 memory as patterns of binary bits, (ones and zeros). The instructions
 are decoded by the *Control Unit* and determine what operations the ALU
 performs on the data. The desired sequence of instructions (the
 *Program*) have to be placed in memory by the “programmer”, which is
 what we will be doing during this course. Remember that the computer is
 a machine that exactly follows instructions and it is the sole
 responsibility of the programmer to get these instructions right!

 The binary instructions used by the computer are not convenient for
 humans to use. This is further complicated by the fact that different
 computers use different sets of instructions. It is therefore much more
 convenient to program in a *High Level Language* which is (more) humanly
 readable and is independent of the details of the computer being used.
 The high level language chosen for this course is .

 From the model above the *program* is a set of instuctions that the
 computer hardware implements in strict sequential order.

 ## What is a program?

 ### Key Point
 The actual program is:

 1.  written in a *high level language* by the “programmer”, typically as
    a text file,

 2.  converted into low level *machine instuctions*,

 3.  loaded into memory,

 4.  executed by the hardware.

 so as a *programmer* you see only the *high level language*; all the
 rest is handled for you by the *operating system*.

 > #### More details
-`Python` is an *interpreted language* which means that the
-*conversion to low level machine instuctions*, *load into memory* all
-occurs automatically *on the fly* as you execute the program, for
-example with the command
-```python
+>`Python` is an *interpreted language* which means that the
+ *conversion to low level machine instuctions*, *load into memory* all
+ occurs automatically *on the fly* as you execute the program, for
+ example with the command
+>```python
          python3 MyProgram.py
-```
-from a Terminal Window. You do not have to worry about the underlying
-details, particularly since we are running from Jupyter Notebooks in this course, but an understanding of what is “happening” is useful
-when you are trying to work out why your program is not working….
+>```
+>from a Terminal Window. You do not have to worry about the underlying
+>details, particularly since we are running from Jupyter Notebooks in this course, but an understanding of what is “happening” is useful
+>when you are trying to work out why your program is not working….

 >In particular when things go wrong, has it failed during
-1.  conversion to low level instructions (syntax error),
-2.  during load (not able to find libraries or modules),
-3.  or execution (did something numerically wrong).
-There are more details on this in [Finding and fixing bugs](bugs.ipynb).
+>1.  conversion to low level instructions (syntax error),
+>2.  during load (not able to find libraries or modules),
+>3.  or execution (did something numerically wrong).
+>There are more details on this in [Finding and fixing bugs](bugs.ipynb).

 ### Key Point
 So a *computer program* actually is

 1.  a set of instructions written in a precisely defined *language* with
    a very strict *syntax*,

 2.  implemented by *hardware* in a strict and precisely defined
    sequential order.

 and it is the sole responsibility of the *programmer* to get this right.
 This is why computer programing is *not easy*.

 In this course you have to learn two things at the same time, these
 being

 1.  the syntax of the *language*; *this is mainly covered in the on-line
    notes and examples*

 2.  how to formulate a problem in the required sequential order (program
    design); *this is mainly covered in the mini-lectures*. This is
    challenging part and a skill you will develop as progress through
    this and subsequent courses.

 All of this will only start to come together as *you* work through this
 course.

 > #### (Apparent) similarity with mathematics
 When you look at the source for any *computer program* there is an *apparent* similarity with
 mathematics. There are *variables*, *functions* and signs; this can lead
 novice programmers into a false sense of security…you are NOT *doing
 mathematics*, you *are* learning a new language that happens to use the
 same symbols!
 For example, the usage of ``=`` for assignment (see later) is very different from *equals* and can lead to quite hard to spot bugs.|

 %% Cell type:markdown id:776882d3 tags:

 # What is a Computer Program

 ## What is a Computer ?
 Before we start teaching *computer programming* we need to first ask
 *what is a computer*. A simplfied structure of a computer is shown
 below.

 <div>
 <img src="png.png" width="500"/>
 </div>

 The *Central Processing Unit* (CPU) operates on a series of instructions
 called a *program* which is stored in *memory*. The CPU consists of an
 *Arithmetic Logic Unit* (ALU) which performs such functions as addition,
 subtraction, comparison etc. and a *Control Unit* which directs and
 monitors the operation of the computer. The *input* and *output* provide
 an interface to the outside world, for example the *input* may be the
 keyboard and *output* the display screen. The *input* and *output* units
 also provide access to data storage devices such as hard discs, DVDs,
 USB devices etc. All these may be either connected directly to the
 computer or over the *network*.

 The computer holds all information (numbers, letters, instructions) in
 memory as patterns of binary bits, (ones and zeros). The instructions
 are decoded by the *Control Unit* and determine what operations the ALU
 performs on the data. The desired sequence of instructions (the
 *Program*) have to be placed in memory by the “programmer”, which is
 what we will be doing during this course. Remember that the computer is
 a machine that exactly follows instructions and it is the sole
 responsibility of the programmer to get these instructions right!

 The binary instructions used by the computer are not convenient for
 humans to use. This is further complicated by the fact that different
 computers use different sets of instructions. It is therefore much more
 convenient to program in a *High Level Language* which is (more) humanly
 readable and is independent of the details of the computer being used.
 The high level language chosen for this course is .

 From the model above the *program* is a set of instuctions that the
 computer hardware implements in strict sequential order.

 ## What is a program?

 ### Key Point
 The actual program is:

 1.  written in a *high level language* by the “programmer”, typically as
    a text file,

 2.  converted into low level *machine instuctions*,

 3.  loaded into memory,

 4.  executed by the hardware.

 so as a *programmer* you see only the *high level language*; all the
 rest is handled for you by the *operating system*.

 > #### More details
-`Python` is an *interpreted language* which means that the
-*conversion to low level machine instuctions*, *load into memory* all
-occurs automatically *on the fly* as you execute the program, for
-example with the command
-```python
+>`Python` is an *interpreted language* which means that the
+ *conversion to low level machine instuctions*, *load into memory* all
+ occurs automatically *on the fly* as you execute the program, for
+ example with the command
+>```python
          python3 MyProgram.py
-```
-from a Terminal Window. You do not have to worry about the underlying
-details, particularly since we are running from Jupyter Notebooks in this course, but an understanding of what is “happening” is useful
-when you are trying to work out why your program is not working….
+>```
+>from a Terminal Window. You do not have to worry about the underlying
+>details, particularly since we are running from Jupyter Notebooks in this course, but an understanding of what is “happening” is useful
+>when you are trying to work out why your program is not working….

 >In particular when things go wrong, has it failed during
-1.  conversion to low level instructions (syntax error),
-2.  during load (not able to find libraries or modules),
-3.  or execution (did something numerically wrong).
-There are more details on this in [Finding and fixing bugs](bugs.ipynb).
+>1.  conversion to low level instructions (syntax error),
+>2.  during load (not able to find libraries or modules),
+>3.  or execution (did something numerically wrong).
+>There are more details on this in [Finding and fixing bugs](bugs.ipynb).

 ### Key Point
 So a *computer program* actually is

 1.  a set of instructions written in a precisely defined *language* with
    a very strict *syntax*,

 2.  implemented by *hardware* in a strict and precisely defined
    sequential order.

 and it is the sole responsibility of the *programmer* to get this right.
 This is why computer programing is *not easy*.

 In this course you have to learn two things at the same time, these
 being

 1.  the syntax of the *language*; *this is mainly covered in the on-line
    notes and examples*

 2.  how to formulate a problem in the required sequential order (program
    design); *this is mainly covered in the mini-lectures*. This is
    challenging part and a skill you will develop as progress through
    this and subsequent courses.

 All of this will only start to come together as *you* work through this
 course.

 > #### (Apparent) similarity with mathematics
 When you look at the source for any *computer program* there is an *apparent* similarity with
 mathematics. There are *variables*, *functions* and signs; this can lead
 novice programmers into a false sense of security…you are NOT *doing
 mathematics*, you *are* learning a new language that happens to use the
 same symbols!
 For example, the usage of ``=`` for assignment (see later) is very different from *equals* and can lead to quite hard to spot bugs.|

--- a/Checkpoints/sample.txt
+++ b/Checkpoints/sample.txt
--- a/Checkpoints/short.txt
+++ b/Checkpoints/short.txt
No results found