(Ca...

Transcription

1 1 of 8 9/7/18, 1:59 PM

2 Getting started with 228 computational exercises Many physics problems lend themselves to solution methods that are best implemented (or essentially can only be implemented) with a computer. Solving integrals that don't have exact solutions, analyzing data, and creating virtual experiments (simulations) are just a few examples you'll experience. Here in the physics 228 lab, you'll have the chance to produce and use some computer simulations implemented with python run through a jupyter notebook (more on these below). In other parts of the course you may use Mathematica. These are just 2 of a wide space of possible tools for doing computational physics. You may have the chance to use both again, as well as other tools throughout the physics major. The physics 231 class provides some comparative information about the various tools available for doing computational physics, and much more information about the field. For today, we'll just go for it with python and jupyter. What is Jupyter? Answer: A notebook front-end for running python code. You can write notes as well as do computations all in one place and produce a clean, readable, modifiable, solution to a physics problem. As such, it's becoming popular among physicists. If you're familiar with Mathematica, the notebook environment is pretty similar. If you've coded with python before pretty much everything you know should work here. You can also cut and past the code into any other editor your want and it should work. However, you should use the jupyter notebook for your work here. It will provide uniformity across the class and give you exposure to a new tool that's becoming popular for coding in physics. You can be a great resource for peers that have less experience, but be careful to give them time and space to learn. Don't take over. If you've never met python before it's ok. This exercise will tell you all you need to know to get started. You can also google around and learn more about the history and functionality of python, and if you want more from a CS perspective, it's currently used in the intro CS course (CS111) at Carleton. In a nut shell, python is a general purpose programming language that can be used to implement algorithms on a computer. Getting started with Jupyter Opening the notebook If you're looking at this, you've probably figured out how to access and start jupyter notebook. However, just in case you're looking at a printed copy of this, or you're not sure how this was opened on your computer, here's the info. 1. Work at a computer where Jupyter is installed. It's on physics department macs and can be installed on any operating system following the instructions at ( The "Anaconda" installation available there makes it easiest. Python and jupyter are both free. jupyter notebook 2. Type at a command prompt to start Jupyter. It will then open the interface in a browser. 3. In the Home tab, click on the file you want to open, or click new -> notebooks -> Python. Jupyter notebooks have the file extension ".ipynb". 4. Begin working in the notebook you've opened. Basic instructions for running Jupyter can also be found on the wiki /carl/physics+jupyter+workshop ( Cells Everything you do in a notebook goes in a cell. There are 2 cell types we'll use extensively, "Markdown cells" and "Code cells". 2 of 8 9/7/18, 1:59 PM

3 Python by itself is a fairly basic computer language, but there are extra libraries that extend its capabilities to allow interesting things like plotting equations, data manipulation, and 3D objects. The libraries you will need for these exercises are Numpy, Scipy, and MatPlotLib, which are often known collectively as pylab. Googling can tell you more about these. In our first code cell below, we'll import them into our notebook. You'll usually want to do this since many built in functions that are useful for computational physics live here. When you activate the cell (click on it and shift-enter), it may take a while and give some irrelevant feedback if you have not previously loaded pylab. That's ok. Note also that a comment in python follows a # sign. This code cell just sets up the tools we want, nothing else happens here. from pylab import * %matplotlib inline #this second line is nice in jupyter notebooks since it puts plots you make into the notebook. Basic coding concepts In the cells to follow, you will: 1. meet some basic coding concepts, 2. learn the syntax for implementing them in python, 3. and build some skills in developing algorithms using them. Note that these are 3 separate things to learn! Loops One of the things computers are good at is doing the same procedure over and over in a fast and accurate way. Loops are what tell the computer to do this. There are 2 basic kinds of loops, While loops, which continue until a condition is met and For loops which do things a specified number of times. While loop example: First let's look at a straightforward example, the kind that shows the basic idea but does not really take advantage of the tool. Activate the code (click in the cell and press shift-enter). i=0 while i<3: print(i) i=i+1 print("we're done, woohoo!") If you're a purist mathematician and have not done computer programming before, the last line might be jarring for you since it's not valid math. The meaning here is different. It means, replace i with it's current value plus 1 -- that is, increment i by 1. There is quite a bit to see here. The loop is executed until the condition (i<3) fails. Once it fails, (when i=3), the computer immediately breaks out of the loop (does not do the loop with i=3). Note that the indented text is a part of the loop, while the unindented text is not. Now lets do an example that illustrates when "while" is helpful vs. "for". The Fibonacci numbers go 1,1,2,3,5,8,... That is, the next Fibonacci number is the sum of the previous two. Find the largest Fibonacci number less than 178. (activate the code below to find the answer) 3 of 8 9/7/18, 1:59 PM

4 maxfib=178 #I intruduced a variable for where I want to stop fiba=1 #a storage spot for a fib number fibb=1 #a storage spot for the next fib number while fibb < maxfib: fib = fibb+fiba #get the next fib number fiba=fibb #store the last 2 fib numbers fibb=fib print("the largest Fibonacci number less than") print(maxfib) print("is") print(fiba) Well, you should have gotten a number, but there are a lot of interesting points here. Let's do some exercises to get at some of them: 1. How do you know the number generated is right? You might try the same code on a case where you know the answer. Replace 178 with 8, a case were you know the answer is 5 and make sure it works. You usually always want to do checks like this. 2. Talk though the code with your group. Make sure you all understand what each line does. You might find it helpful to "play computer" and try to do what you think the computer is being told to do. Note the use of while. We loop over the code contained until we break the condition fibb < maxfib then we move on to the print statement. We don't care how many loops we do, we just want to keep going until we meet the condition. 3. If things had not worked at step 1, the mistake would have fallen into one of 2 basic classes: "logic errors" and "syntax errors". If you make a logic error, the code may run, but not give the correct answer. In other words the computer will do what you told it to do, but your instructions were not the right ones to achieve your goal. If you make a syntax error, the code may not run. To try the latter, change the 'w' in while to a 'W' and see what happens when you activate the code. Note also that when while is capitalized it turns black, which means it's not a known word to python. When you write while loops, you want to be sure that the condition will at some point fail. Otherwise, the computer will work for a long time. Finally, note the copious comments that tell others and your future self what various parts of the code do. This is good practice. For loop examples: Lets again start with a straightforward example so you can see what the issues are. (activate the code) for i in range(1,4): print(i) Note that the loop is executed with i starting at the first number in the range, but not for the last number in the range. Hence the code in the loop is executed 3 times in this example. For a more interesting example, find the 50th Fibonacci number. This code contains a logic error and a syntax error. Activate the code, then find and fix the bugs, then get the answer to the question. Compare your fix for the logic error with another group. There are a variety of ways to change the code such that it succeeds in answering the question correctly. 4 of 8 9/7/18, 1:59 PM

5 number=50 fiba=1 fibb=1 For i in range(1,number+1): fib=fibb+fiba fiba=fibb fibb=fib print("element number", number, "of the Fibonocci sequence is", fibb) If statements Another thing a computer is good at is making comparisons. This is the job of an if statement. Here is a silly example. Activate the code. t=1 while t < 10: t=t+1 if t**2 > 10: print(t**2) else: print("too small") Let's do some exercises to explore this one too. 1. Talk through the code and describe what each line does. 2. What does ** do? Do some experiments. Change the '2' to a '3' or a '4'. 3. The else part is optional. Copy the code into a cell below and try it without the else. That is, delete the else and the instruction that follows. Arrays and Plots One can give a whole set of objects a name, and manipulate it as a set. This is called an array in python (actually part of the numpy library). Plotting is also something you'll want to do a lot of as you deal with physics problems. This example illustrates both arrays and plotting. Activate the code. Then we'll take a look at the parts. t = linspace(0, 10*pi, 1000) z = sin(t)*exp(-t/10) plot(t,z,'b-') title("cool! It works!") xlabel("time") ylabel("displacement") show() The first line creates an array of 1000 numbers linearly spaced between 0 and. You can access any of the elements individually as follows. Note that the first element in an array is stored in a slot numbered 0 so the 1000th element is in slot number 999. Activate the cells below to check this. 10π t[0] t[999] 5 of 8 9/7/18, 1:59 PM

6 10π In the following cell, I check that this ending value is really. 10*pi The second line creates another array stored in. That is, the equation is applied individually to each element of the array to make the corresponding element in. z z t The 3rd line makes a plot with the values contained in on the horizontal axis and the values contained in t on the vertical axis. The 'b-' is an option that makes the plot with a blue line. Try changing it to 'g-', then try changing it to 'b.' with 100 points instead of Predict how to make red dots. The rest of the lines except show() are optional commands to format the plot. The last line show() is to make the plot appear. One can also add elements to an array one at a time. Activate the following code and see if you can figure out how it works. z number=10 fib = [1,1] for i in range(3,number+1): fib=append(fib,fib[i-2]+fib[i-3]) print(fib) Why do we need fib i-2 and i-3 instead of i-1 and i-2? Functions A function is a chunk of code that does a particular job and can be called elsewhere in your program. Things you've used like sin(x) are actually built in functions in python or its libraries. You can write your own. If you do, it will be known to the kernal throughout the rest of your jupyter session, or if you develop code outside of jupyter throughout your program. Functions are helpful in many ways. They are handy if the same job needs to be done in a number of different places within the code, they allow larger projects to be spread across people, they can organize the code into subtasks, etc. Functions are key for software developers that work on large projects. For the smaller one-time-use codes that physicists sometimes write, they my be less crucial. As a pointed example of the usefulness of functions, imagine you are programming a maze game, and the language only has a built in "turn right function". The only way to turn left would be to program 3 turn right functions in a row. It won't take long before you wanted to make your own function called "turn left" that consisted of the 3 turn rights. Here is a silly example of how to construct a function. First we'll define the function, which in this case will be a mathematical function, then we'll use (call) in the next cell. This could all be done in one cell, it's up to you. def silly(x): y = sqrt(x**2 + 9) return y 6 of 8 9/7/18, 1:59 PM

7 t = linspace(0, 10, 1000) plot(t,silly(t),'b-') title("cool! It works!") xlabel("time (s)") ylabel("silly (sillies)") show() Talk through what each line in the above cells does. Concluding remarks There is much much more one can learn about python, programming, and computational physics, but this will get you started. Some extras If you're done with the above and your lab's not over, check out the following. Symbolics At the start we said that python is quite expandable via its many libraries. As a final note about this in the current introduction, we'll look at one more really cool library for doing physics called sympy. It will also give us a chance to look at another way to load a library. Sympy does symbolic manipulation with functionality that's becoming competitive with Mathematica. If you're working in a new python session, you can load sympy just like we did with pylab in our first code cell. If you want to use sympy along with pylab, conflicts will arise if you take this approach. This is because pylab contains a function cos() that eats arrays and sympy contains a function cos() that eats generic mathematical variables called symbols. To avoid this, we'll load sympy as in the cell below. When libraries are loaded this way, all of their functions need to be called with a sym. (or any set of letters you put following 'as') in front of them. So pylab's cos() remains cos() and sympy's is now available as sym.cos(). So we have both functions available to us. We can then do cool things like analytical derivatives. Check it out by activating the code below. If you want to know more about sympy, a full tutorial can be found at ( import sympy as sym x, y, z = sym.symbols('x y z') sym.diff(sym.cos(x),x) An exercise challenge If you want more practice exercises like the ones you looked at in this notebook, you should check out the Project Euler challenges at ( You might have fun with them on your own, challenge a friend to a competition as weekend fun, or your instructor may ask you to create an account and solve some of them now. Some sections adapted from ( by E. Ayars. 7 of 8 9/7/18, 1:59 PM

8 8 of 8 9/7/18, 1:59 PM