Checkpoints/Checkpoint4.ipynb

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

CourseNotes/HowtoWriteaComputerProgramfromScratch.ipynb

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