View source for EGR 103/Fall 2021/Lab 3

<div class="noautonum">__TOC__</div>

== Typographical errors ==
* None yet!

== Self-Guided Run-through ==
The following will take you through what you need to do during the lab period today.  It will generally follow the order of the lab handout with some exceptions.

=== 1 Get the files ===
See [[EGR 103/Fall 2021/Beginning of Lab]] and follow those instructions for Lab 3.  Note that there are several starter files for this week in addition to the usual style file and skeleton for the lab report.  You should '''not''' worry about getting Overleaf set up at this time - that can wait until you are ready to work on the individual lab report writeup (i.e. once you are done writing the scripts and creating the graphs for that).  For this week, the Connect, APT, and Individual Gradescope parts will not require anything from Overleaf.

=== 2 Connect ===
==== 2.1 Registration ====
* You will need to have an account on the McGraw-Hill Connect system for this class to do this assignment.  If you already have one, you can move on to the next step.
* If you do not already have an account, you need to go to [https://connect.mheducation.com/class/m-gustafson-egr-103-fall-2021-1] and click '''register now''' to get registered.
* There are several reading assignments and lab assignments in the Connect book; you must have your own account for this.
==== 2.2 Assignments ====
Once you have registered, you should be able to get into the class on Connect.  At the moment, there should be one assignment - "Connect Lab 03."  When you begin an assignment, it will give you assignment details such as how many points are available and when the assignment is due.  I will generally give an extra hour for the Connect assignments just in case something happens at or just before 9PM ET on the day it is due (so the due time will look like 10 PM; that is a hard limit).  You are allowed as many attempts as needed before the due date.  You are also allowed to "Check my work" but please note that checking your work is '''not''' the same as submitting your work!  Be sure to actually submit when you are ready to turn something in.

When you '''Continue''' to the assignment, you will go to the first problem, which for this week is Problem 01.013 (or 1.13).  At left, there are icons; you can click them to: 
* See the relevant parts of the Chapra book,
* Get a hint about the problem,
* Print the problem, or
* Look at the references for the problem.  
For this problem, you may be given different numerical values from others in the class.  You are allowed to work on these in small groups; your group should collectively talk about the process by which you are going to answer the question and then individually work on those answers.  Note that for Problem 1.13 you do not actually need to write a program (though you can use Python as a calculator to come up with the answer).  Look at the diagram and note that there are four ways water gets into the body and five ways it leaves; the metabolism arrow is a net intake. 

Figure out what you think the amount of water you would need to drink to remain at equilibrium, enter that value in the box, and note as you are entering that number that the "Check my work" box lights up. Click that box and you will be told you "only" have 100 times to check your work.  If you believe your work is correct, click "Check my work" - otherwise, click Cancel and re-calculate.  If you get the answer right, remember that later '''you must submit the assignment.'''  If you get the answer wrong, try again until you get it right.  In either case, you will need to "Return to question."

Once you get it right, you can click "Submit" at the top right immediately or wait until you have answered more questions.  As mentioned in the lab handout, I will be grading based on your '''best''' answer for '''each''' problem.  Also, when you submit, if you go back to work on other problems, your previous answers will remain in place.  For whatever reason, Connect will tell ''you'' your score based on the average score of all submissions.  That will generally be lower than what I have as a score.  A week or so after a Connect assignment is due, I will upload the grades to Sakai and then you can make sure I have your grade right for your best parts.  For right now, go ahead and make sure you have the first question correct by using "Check your work" and then go ahead and "Submit" the partial assignment. '''''Having at least a 10/50 for the Connect Lab 03 assignment by the end of lab this week will count as a 10 point homework assignment'''''.  When you click Submit, if the assignment is not yet actually completed (i.e. you haven't put answers in for everything), Connect will warn you.  You can either Submit to get a partial score registered or you can Cancel and go back and fill more things in.  There is really no harm in submitting multiple times so go ahead and submit your answer to the first question now.

Once you are done with a question, you can use the navigation section at the bottom center of the screen to change questions.  "Next" will take you to the next question and "Prev" will take you to the previous one.  If you click on the 3x3 grid, that will show you all the problems in a particular set.  For this assignment, go ahead and click on the grid and note that there is a set of two chain links between Questions 4 and 5 -- that means that they are linked together and that you are expected to answer Question 4 before moving on to Question 5.   If you skip a linked part and Connect does not let you go back, you can simply Submit your answers to that point; when you go back to the assignment, it will let you in to the earlier Questions.  There is more information in the lab handout run-through below regarding each of the other problems in the Connect part of the lab for this week.

=== 3. APT ===
The Algorithmic Programming Testing assignments are auto-graded exercises designed and vetted by faculty and staff in Duke's Computer Science Department, and they have let me use them for EGR 103, for which I am incredibly thankful.  As noted elsewhere, you are allowed to work together in small groups on APTs but you do need to have your own code and you should make sure you completely understand the solution you have come up with.  You will ''not'' be required to submit documentation or your code anywhere other than the APT site, where you will upload your code and have it graded.

==== 3.1 Assignments ====
The APT assignments will be posted at the [http://classes.pratt.duke.edu/EGR103F21/ Classes] page, specifically in [http://classes.pratt.duke.edu/EGR103F21/assignments.html Assignments] at the [http://classes.pratt.duke.edu/EGR103F21/APT.html link].  The problems will generally be due at the same time as the lab for that week is due.

Each assignment will have one or more problems, and each problem will have a link to a description on the CS server.  The problem description will always have the following parts:
* Problem Statement
*: This will be a narrative description of what you are trying to solve.  This may include some domain knowledge (for instance, the equation for the distance traveled by an object thrown downward at an initial velocity of $$v$$, under the influence of Earth's gravity, after $$t$$ seconds).  
* Specification
*: This will be critical information about the exact name of the file to save (including capitalization) as well as the exact name of the function that needs to be in that file (including capitalization and the names of any local variables).  Be sure your file is named exactly the same as the <code>filename</code> given in the Specification and be sure your function definition matches the Specification exactly.  You are not required to include the docstring (the triple quotes and the text between them) but you are certainly welcome to.
* Constraints
*: This will give you information about how your function will be tested.  Basically, this puts limits on what you will be asked.
* Examples
*: These are...examples...showing what the returns should be for different runs of the functions you are supposed to write.  You should generally test your code with all the examples before actually uploading to the APT grading system

==== 3.2 Testing ====
Quick note: the APT system will require you to log in to the Duke system; if you have not logged in from the browser you are using in a while, asking the APT page to run a test will take you to the log-in page and then may display a mostly blank screen with the message: "upload issue on move. If this is the first upload after authenticating with netid, resubmit the same file."  If you get that, just go back two pages in your browser and re-run the test.

==== 3.3 Script Structure ====
Your scripts should generally include two parts: your function and your tests on the examples.  It turns out there is a specific way you should run your tests.  You could just put your tests in your script as follows:
<syntaxhighlight lang=python>
# Define function
def FUN(VAR1, VAR2, ...):
    CODE
    MORE CODE
    YET MORE CODE
    return THING1, THING2, THING3

# Run tests
IN1 = BLAH1
IN2 = BLAH2
print(FUN(IN1, IN2))
IN1 = BLAH3
IN2 = BLAH4
print(FUN(IN1, IN2))
</syntaxhighlight>
and that will ''work'' for APTs but you will get some extra stuff printed on your screen that yo do not need.  Also, it turns out, that will ''not'' work for Gradescope, which is sometimes very picky about any extra print statements that may arise.  To see how the APT system reacts to this kind of script, create and save a file called <code>Gravity.py</code> with the following in it:
<syntaxhighlight lang=python>
# Define function
def falling(time, velo):
    dist = velo + time # this is wrong!
    return dist

# Run tests
t = 3
v = 5
print(falling(t, v))
t = 3
v = 0
print(falling(t, v))
t = 3600
v = 0
print(falling(t, v))
t = 86400
v = 0
print(falling(t, v))
</syntaxhighlight>
If you test this, (a) all the tests will fail and (b) there will be some text between horizontal lines that looks like:
<syntaxhighlight lang=python>
8
3
3600
86400
</syntaxhighlight>
The reason for that is that the APT system is actually ''importing'' your script in order to learn a function that it will call <code>Gravity.falling()</code>.  In the process of importing, however, it will also run whatever extra lines of code happen to be in your script.  To see this work, 
* Run your <code>Gravity.py</code> script to make sure Python's working directory is the same as where your script lives,
* Clear all the variables by clicking on the eraser or trash can icon above and on the left side of the top right (Variable explorer, usually) window (if you hover over the correct icon it will say something like "Remove all variables" - go ahead and do that but note that the working directory has not changed).
* Go to the ''console'' (lower right) window and type <code>import Gravity</code> and you will see that the four print statements in your script will print.  
* In the console, type <code>falling(3, 5)</code> and note that you get an error --  this is because when you ''import'' the script versus ''run'' the script the functions defined in the script have to be called by first saying what module the function was from!  This is similar to having to use something like <code>np.cos()</code> to indicate that the cos function was imported from the numpy module (with a nickname for the latter of np).  
* In the console, type type <code>Gravity.falling(3, 5)</code> and note that now you have a value of 8 that is returned.
* Once again, clear all the variables by clicking on the eraser or trash can icon above and on the left side of the top right (Variable explorer, usually) window.
* Now type <code>import Gravity as grav</code>
* See if you can figure out how to ask falling to compute the result when $$t$$ is 3 and $$v$$ is 5 now!
* For completeness, once again, clear all the variables by clicking on the eraser or trash can icon above and on the left side of the top right (Variable explorer, usually) window.
* Now type <code>from Gravity import falling</code>; this will actually bring in the function <code>falling</code> under its own name without needing to say the module name, so try <code>falling(3, 5)</code> and make sure you get 8 again.

== Lab Document Supporting Information ==
The following parts of this document follow the sections / subsections in the lab handout.

=== 3.1 Introduction ===
This lab involves functions and random numbers.  Every script has been started, but sometimes only with the boilerplate community standard statement.  Note - none of the <code>test_</code> files will be included in your lab report; they are meant to test your code and sometimes produce other files.  Those ''other'' files will be included in your lab report.  

=== 3.2 Resources ===
See main [[EGR 103]] page for links to these

=== 3.3 Getting Started ===
* See [[EGR 103/Fall 2021/Beginning of Lab]].

=== 3.4 Connect Assignments ===
The Connect assignments come from a book that focuses on MATLAB, but you will be completing the problems in Python.

==== Chapra 2.13 ====
Your program needs to perform the following tasks:
* Store the Force values in an array
* Store the $$x$$ values in an array
* Calculate the $$k$$ values for each pair (i.e. you will have five different $$k$$ values)
* Calculate the potential energy for each pair 
* Use the <code>ARRAY.max()</code> method and print this value
Notes about the differences between MATLAB and Python when you see the solution code:
* MATLAB uses arrays by default, so something like <code>[1 2 3]</code> in MATLAB would be <code>np.array([1, 2, 3])</code> in Python
* MATLAB uses '''matrix''' multiplication and division by default, so if you want to multiply the '''elements''' in corresponding locations together, you have to use <code>.*</code> and <code>./</code> in MATLAB (i.e. put a period in front of the operator).  Python does element multiplication and division by default so <code>np.array([1, 2, 3]) * np.array([4, 5, 6])</code> gives an array with <code>[4, 10, 18]</code> in it.
* MATLAB uses <code>.^</code> for raising arrays to powers, whereas Python uses <code>**</code> so <code>np.array([1, 2, 3])**2</code> is an array with <code>[1, 4, 9]</code> in it.
* MATLAB and Python both have a built-in <code>max()</code> function, but for Python arrays, it is better to use the <code>.max()</code> method appended to the array.

==== Chapra 2.14 ====
Your program should store the $$n$$, $$S$$, $$B$$, and $$H$$ values in an array, then use those to calculate $$U$$.  Note that Connect will accept both floating-point and scientific notation for numbers (i.e. something like 0.3624 or 3.624e-01)

==== Chapra 2.21 ====
Your program should store the $$m$$, $$v_t$$, and $$A$$ values in arrays and the $$\rho$$ and $$g$$ values in floats.  Calculate the seven different $$C_D$$ values using the equations in Case Study 2.7 (one equation has $$c_d$$ as a function of $$m$$, $$g$$, and $$v_t$$ and another equation can be re-written to calculate $$C_D$$ as a function of $$c_d$$, $$\rho$$, and $$A$$). The <code>.min()</code>, <code>.max()</code>, and <code>.mean()</code> methods for arrays will come in handy!

=== 3.5 APT Problems ===
* We will go through these in labs - be sure to take notes!  As we go through them, you will solve the first APT Problem!  Here's what we have by the end of lab:
<syntaxhighlight lang=python>
def falling(time, velo):
    return velo * time + 0.5 * 9.8 * time ** 2


# Alternately
"""
def falling(time, velo):
    dist = velo*time + 0.5 * 9.8 * time**2
    return dist
"""

print(__name__)

if __name__ == "__main__":
    print(falling(3, 5))
    print(falling(0, 0))
    print(falling(0, 1))
    print(falling(1, 0))

</syntaxhighlight>

=== 3.6 In-Lab Autograded Assignments ===

==== 3.6.1 P&E 1.31 ====
* Integer division is given by // and the values can be ints or floats or a combination thereof; if either or both of the arguments are floats the answer is a float.
* The remainder operator is given by %.
* Think about how you need to update the number of seconds after accounting for some with hours or minutes.
* Remember to return the three items in a tuple in the correct order.
* Note the starter test code that has been provided for you in the script.

==== 3.6.2 Based on P&E 1.31 ====
* Main thing here is to figure out how to get defaults to work.  Remove the <code>*blah</code> and replace it with three inputs.  Note that two of them need default cases.
* The tester does not always have three input parameters when the function gets called.

==== 3.6.3 Saturation Function ====
* Be sure to include the default cases.
* This can be done all in one calculation!  Note that in Lab 2 we used ARRAY.min() to get the minimum value of an array; that version does not work if you are comparing two numbers (unless you put them in an array).  Use <code>min(Thing1, Thing2)</code> instead.

=== 3.7 Individual Post-Lab Autograded Work ===
As mentioned, these are individual exercises.  You should not look at anyone else's work for this nor should you allow anyone other than a TA or instructor to look at your work.  Note that you can submit to the autograder as many times as you would like before the lab is due; your grade will be based on the score earned the last time the autograder ran.

==== 3.7.1 Random Integers ====
* Be sure to include the default cases.
* Carefully consider how you the human would keep track of rolls and roll counts before trying to code it.
* <code>np.random.seed(INT)</code> is the command you need to initialize the random number generator to a particular state
* <code>np.random.randint</code> is your friend!
* There are a few different ways to organize this - make sure you are clear about what you want to do before coding.
* Note that the first output will have as many entries as there are dice and the second will have as many as there are sides.
* The return should be a tuple of two arrays.  If for whatever reason you ended up with a list somewhere, you can always convert a list of numerical values to an array (if the shape of the list is compatible with conversion) using <code>np.array(LIST)</code>
* You will need a for loop for this to work.

==== 3.7.2 Inspired by P&E 1.39 ====
* Note the import line at the top.
* The <code>round(NUM, ndigits=DIG)</code> command will round a number NUM so that it has DIG significant digits after the decimal point.  You ''can'' have negative DIG values!  Play with the command to see what that does.  Then make sure your function is returning a value that has been properly rounded.
* See [https://en.wikipedia.org/wiki/Passer_rating Passer rating] on Wikipedia and specifically the NFL rating in the [https://en.wikipedia.org/wiki/Passer_rating#NFL_and_CFL_formula NFL and CFL Formula] section to determine how $$a$$, $$b$$, $$c$$, and $$d$$ are computed. Note especially that those four values are bounded by [0, 2.375]. 
* The link is [https://www.teamrankings.com/nfl/player-stat/qb-rating-nfl NFL Player Stats - QB Rating] from TeamRankings; click on a player and you will get a table with the information you need.
* When you want to submit this to the autograder, you must also submit your <code>football_helper.py</code> script.

=== 3.8 Individual Lab Report ===
Once again, these are individual exercises.  You should not look at anyone else's work for this nor should you allow anyone other than a TA or instructor to look at your work.  These scripts and graphs will go in a written lab report that will be uploaded to Sakai.  There is no autograder for these parts.

==== 3.8.1 Based on P&E 1.35 ====
* Carefully consider what the equations need to look like for the angles before writing them.
* Test your code with some obvious triangles (hint: once you import numpy as np, you can use np.sqrt()...and you probably know some things about a 1-1-1 triangle and a 1-1-np.sqrt(2) triangle!)
* The input values for trig functions and the output values for inverse trig function in numpy are in radians.
* Get the math working before trying the drawing, then spend some times figuring out how to create the line (hint: it takes four points to draw a closed triangle)
* There should be a default case for whether or not to make the drawing.
* Make sure your graphics are set to "Automatic" - see [[Python:Plotting#Python_Settings]]
* Do not use the plt.show() or fig.show() command in your code!

==== 3.8.2 Random Numbers ====
* Note that you have the code for getting a NetID, converting the NetID to a seed for the random number generator, and calculating the number of bins for the histogram.  You will need to change the <code>nums = </code> line to get input from the user.
* I also included the code for plotting histograms with a particular number of bins.  
* I did not include the code to make the distributions.  They are in the np module, in the random groups, and the actual commands have names that completely make sense for generating uniform or normal distributions, respectively.
** Oops, I've said too much...
* I also did not include the lines about printing.  Make sure you use the correct formats!
* There are some commands in the script or that need to go in the script that we haven't completely covered in class - we will go over the following in lab:
** <code>map</code>, <code>ord</code>, <code>m.ceil</code>, <code>m.log10</code>
*** We are going to use <code>m.ceil()</code> instead of <code>np.ceil()</code> because the Numpy version returns a float instead of an int.

===== On checking your random numbers =====
You can check your work by using <code>mrg</code> and 5000 for the input responses - you should get the values in the lab handout. ''However'' - this assumes you calculated the uniformly distributed numbers first and the normally distributed numbers second!  
Calculating them this way gives you:
<source lang=text>
Information for 5000 random numbers for mrg:
Uniform: min: +8.509e-05 avg: +5.020e-01 max: +9.998e-01
Normal:  min: -4.292e+00 avg: -7.668e-04 max: +3.634e+00
</source>
as listed in the lab manual.  If you calculated them in the other order (normal and then uniform), you would get:
<source lang=text>
Information for 5000 random numbers for mrg:
Uniform: min: +6.652e-05 avg: +5.001e-01 max: +1.000e+00
Normal:  min: -3.272e+00 avg: -8.981e-03 max: +3.660e+00
</source>
and the histograms will be slightly different as well.  We will accept either set of answers!  Also - this has not been tested on different platforms - if the random number generators behave differently on OSX, Win, and Linux, I will note that here.  So far - no evidence of differences.

== General Concepts ==
This section is not in the lab report but rather has some items in it that span multiple problems in the lab.  We will cover these during the lab.

* If your script's main job is to define one or more functions, and you want to put test code in the script, a great way to do that is to put the tester code at the bottom in a section headed by the statement:
:<syntaxhighlight lang=python>
if __name__ == "__main__":
</syntaxhighlight>
: That way the test code will only run when you '''run''' the script and not when you '''import''' the script.
* Please do not make any changes at all to the <code>test_</code> file!  Also, do not include it in your lab report.  Here's some information about how it works, though:
** The fo=open() command opens a file for writing - this is how you can "print" into a file
** The scrsave() function will take a string and send it two places - the screen with a print() function and a file with the fo.write() function.  This was so I only had to generate the string once to have it show up on the screen and in the file.
** The seeding will take a string, convert it to the mapping of the ord() function on the letters in the string, then add them all together.
** The try...except structure will...try to do something.  If it can - great!  If not, it stores the problem in ex and then prints it.  If your code doesn't work, my tester will still run.  
** The fo.close() command closes the file for writing
* For random numbers, the key commands we need for this week are:
** [https://numpy.org/doc/stable/reference/random/generated/numpy.random.seed.html numpy.random.seed]
** [https://numpy.org/doc/stable/reference/random/generated/numpy.random.randint.html numpy.random.randint]
** [https://numpy.org/doc/stable/reference/random/generated/numpy.random.uniform.html numpy.random.uniform]
** [https://numpy.org/doc/stable/reference/random/generated/numpy.random.normal.html numpy.random.normal]

{{Protected Class Document}}