Introduction to Scientific Programming with Python: A Starting Point

Computing with Formulas...................................1
The First Programming Encounter: a Formula....................1
Using a Program as a Calculator.........................2
About Programs and Programming.......................2
Tools for Writing Programs............................3
Writing and Running Your First Python Program..............4
Warning About Typing Program Text.....................5
Verifying the Result.................................6
Using Variables....................................6
Names of Variables.................................6
Reserved Words in Python............................7
Comments.......................................8
Formatting Text and Numbers..........................9
Computer Science Glossary...............................12
Another Formula: Celsius-Fahrenheit Conversion................16
Potential Error: Integer Division........................16
Objects in Python..................................17
Avoiding Integer Division............................18
Arithmetic Operators and Precedence.....................20
Evaluating Standard Mathematical Functions...................20
Example: Using the Square Root Function.................20
Example: Computing with sinh x........................23
A First Glimpse of Rounding Errors.....................23
Interactive Computing..................................24
Using the Python Shell..............................25
Type Conversion..................................26
IPython........................................27
Complex Numbers.....................................29
Complex Arithmetics in Python........................30
Complex Functions in Python..........................31
Unified Treatment of Complex and Real Functions............31
Symbolic Computing...................................33
Basic Differentiation and Integration.....................33
Equation Solving..................................34

xi

Taylor Series and More..............................35

Summary...........................................35
Chapter Topics...................................35
Example: Trajectory of a Ball..........................39
About Typesetting Conventions in This Book...............40
Exercises...........................................41

Loops and Lists..........................................51
While Loops.........................................51
A Naive Solution..................................51
While Loops.....................................52
Boolean Expressions................................54
Loop Implementation of a Sum.........................56
Lists 57
Basic List Operations...............................57
For Loops.......................................60
Alternative Implementations with Lists and Loops................62
While Loop Implementation of a for Loop.................62
The Range Construction.............................63
For Loops with List Indices...........................64
Changing List Elements.............................65
List Comprehension................................66
Traversing Multiple Lists Simultaneously..................66
Nested Lists.........................................67
A table as a List of Rows or Columns....................67
Printing Objects...................................68
Extracting Sublists.................................70
Traversing Nested Lists..............................72
Tuples.............................................74
Summary...........................................75
Chapter Topics...................................75
Example: Analyzing List Data.........................78
How to Find More Python Information....................80
Exercises...........................................82
Functions and Branching...................................91
Functions...........................................91
Mathematical Functions as Python Functions...............91
Understanding the Program Flow.......................93
Local and Global Variables...........................94
Multiple Arguments................................96
Function Argument or Global Variable?...................97
Beyond Mathematical Functions........................98
Multiple Return Values..............................99
Computing Sums.................................100
Functions with No Return Values......................101
Keyword Arguments...............................103
Doc Strings.....................................105
Functions as Arguments to Functions....................107
The Main Program................................109
Lambda Functions................................110
Branching..........................................110
If-else Blocks...................................111
Inline if Tests...................................113
Mixing Loops, Branching, and Functions in Bioinformatics

Examples......................................113

Counting Letters in DNA Strings.......................114
Efficiency Assessment..............................118
Verifying the Implementations........................120

Summary..........................................121
Chapter Topics...................................121
Example: Numerical Integration.......................123
Exercises..........................................127

User Input and Error Handling..............................149
Asking Questions and Reading Answers......................150
Reading Keyboard Input............................150
Reading from the Command Line..........................151
Providing Input on the Command Line...................151
A Variable Number of Command-Line Arguments...........152
More on Command-Line Arguments....................153
Turning User Text into Live Objects........................154
The Magic Eval Function............................154
The Magic Exec Function...........................158
Turning String Expressions into Functions................160
Option-Value Pairs on the Command Line....................161
Basic Usage of the Argparse Module....................162
Mathematical Expressions as Values....................163
Reading Data from File.................................165
Reading a File Line by Line..........................166
Alternative Ways of Reading a File.....................167
Reading a Mixture of Text and Numbers..................169
Writing Data to File...................................171
Example: Writing a Table to File.......................171
Standard Input and Output as File Objects.................173
What is a File, Really?..............................176
Handling Errors......................................179
Exception Handling...............................180
Raising Exceptions................................183
A Glimpse of Graphical User Interfaces......................185
Making Modules.....................................188
Example: Interest on Bank Deposits.....................188
Collecting Functions in a Module File...................189
Test Block.....................................190
Verification of the Module Code.......................192
Getting Input Data................................193
Doc Strings in Modules.............................195
Using Modules..................................196
Distributing Modules..............................199
Making Software Available on the Internet................200
Making Code for Python 2 and 3...........................201
Basic Differences Between Python 2 and 3................201
Turning Python 2 Code into Python 3 Code................202
Summary..........................................204
Chapter Topics..................................204
Example: Bisection Root Finding......................208
Exercises..........................................216
Array Computing and Curve Plotting.........................227
Vectors...........................................228
The Vector Concept...............................228
Mathematical Operations on Vectors....................229
Vector Arithmetics and Vector Functions.................231
Arrays in Python Programs..............................232
Using Lists for Collecting Function Data.................232
Basics of Numerical Python Arrays.....................233
Computing Coordinates and Function Values...............235
Vectorization....................................236
Curve Plotting.......................................238
MATLAB-Style Plotting with Matplotlib.................238
Matplotlib; Pyplot Prefix............................243
SciTools and Easyviz..............................244
Making Animations...............................249
Making Videos..................................254
Curve Plots in Pure Text............................255
Plotting Difficulties...................................256
Piecewisely Defined Functions........................256
Rapidly Varying Functions...........................259
More Advanced Vectorization of Functions...................260
Vectorization of StringFunction Objects..................260
Vectorization of the Heaviside Function..................261
Vectorization of a Hat Function........................265
More on Numerical Python Arrays.........................267
Copying Arrays..................................267
In-Place Arithmetics...............................268
Allocating Arrays.................................269
Generalized Indexing..............................269
Testing for the Array Type...........................270
Compact Syntax for Array Generation...................271
Shape Manipulation...............................271
High-Performance Computing with Arrays....................272
Scalar Implementation..............................272
Vectorized Implementation..........................273
Memory-Saving Implementation.......................273
Analysis of Memory Usage..........................275
Analysis of the CPU Time...........................276
Higher-Dimensional Arrays..............................277
Matrices and Arrays...............................277
Two-Dimensional Numerical Python Arrays...............278
Array Computing.................................281
Matrix Objects...................................282
Some Common Linear Algebra Operations....................283
Inverse, Determinant, and Eigenvalues...................283
Products.......................................283
Norms 284
Sum and Extreme Values............................284
Indexing.......................................286
Transpose and Upper/Lower Triangular Parts..............286
Solving Linear Systems.............................287
Matrix Row and Column Operations....................287
Computing the Rank of a Matrix.......................288
Symbolic Linear Algebra............................289
Plotting of Scalar and Vector Fields.........................292
Installation.....................................292
Surface Plots....................................293
Parameterized Curve...............................293
Contour Lines...................................294
The Gradient Vector Field...........................294
Matplotlib.........................................296
Surface Plots....................................296
Contour Plots....................................297
Vector Field Plots.................................299
Mayavi...........................................299
Surface Plots....................................300
Contour Plots....................................303
Vector Field Plots.................................303
A 3D Scalar Field and Its Gradient Field..................304
Animations.....................................306
Summary..........................................307
Chapter Topics...................................307
Example: Animating a Function.......................308
Exercises..........................................313
Dictionaries and Strings...................................333
Dictionaries........................................333
Making Dictionaries...............................334
Dictionary Operations..............................334
Example: Polynomials as Dictionaries...................336
Dictionaries with Default Values and Ordering.............338
Example: Storing File Data in Dictionaries................341
Example: Storing File Data in Nested Dictionaries...........342
Example: Reading and Plotting Data Recorded at Specific Dates..347
Strings............................................351
Common Operations on Strings........................351
Example: Reading Pairs of Numbers....................355
Example: Reading Coordinates........................358
Reading Data from Web Pages............................360
About Web Pages.................................361
How to Access Web Pages in Programs..................362
Example: Reading Pure Text Files......................363
Example: Extracting Data from HTML...................365
Handling Non-English Text..........................366
Reading and Writing Spreadsheet Files......................369
CSV Files......................................369
Reading CSV Files................................370
Processing Spreadsheet Data.........................371
Writing CSV Files................................372
Representing Number Cells with Numerical Python Arrays 373
Using More High-Level Numerical Python Functionality . 374
Examples from Analyzing DNA...........................375
Computing Frequencies.............................375
Analyzing the Frequency Matrix.......................382
Finding Base Frequencies...........................385
Translating Genes into Proteins........................388
Some Humans Can Drink Milk, While Others Cannot.........393
Making Code that is Compatible with Python 2 and 3.............394
More Basic Differences Between Python 2 and 3............394
Turning Python 2 Code into Python 3 Code................396
Summary..........................................396
Chapter Topics..................................396
Example: A File Database...........................398
Exercises..........................................402
Introduction to Classes....................................409
Simple Function Classes................................409
Challenge: Functions with Parameters...................410
Representing a Function as a Class.....................412
The Self Variable.................................417
Another Function Class Example.......................419
Alternative Function Class Implementations...............420
Making Classes Without the Class Construct...............422
Closures.......................................424
More Examples on Classes..............................426
Bank Accounts..................................426
Phone Book....................................428
A Circle.......................................430
Special Methods.....................................432
The Call Special Method............................432
Example: Automagic Differentiation....................433
Example: Automagic Integration.......................438
Turning an Instance into a String.......................440
Example: Phone Book with Special Methods...............441
Adding Objects..................................443
Example: Class for Polynomials.......................443
Arithmetic Operations and Other Special Methods...........449
Special Methods for String Conversion...................449
Example: Class for Vectors in the Plane......................451
Some Mathematical Operations on Vectors................451
Implementation..................................452
Usage 454
Example: Class for Complex Numbers.......................455
Implementation..................................455
Illegal Operations.................................457
Mixing Complex and Real Numbers....................457
Dynamic, Static, Strong, Weak, and Duck Typing............459
Special Methods for “Right” Operands...................460
Inspecting Instances...............................461
Static Methods and Attributes.............................463
Summary..........................................464
Chapter Topics...................................464
Example: Interval Arithmetic.........................466
Exercises..........................................470
Random Numbers and Simple Games.........................489
Drawing Random Numbers..............................489
The Seed......................................490
Uniformly Distributed Random Numbers.................491
Visualizing the Distribution..........................492
Vectorized Drawing of Random Numbers.................493
Computing the Mean and Standard Deviation..............494
The Gaussian or Normal Distribution....................496
Drawing Integers.....................................497
Random Integer Functions...........................498
Example: Throwing a Die...........................498
Drawing a Random Element from a List..................501
Example: Drawing Cards from a Deck...................502
Example: Class Implementation of a Deck................504
Computing Probabilities................................507
Principles of Monte Carlo Simulation....................507
Example: Throwing Dice............................508
Example: Drawing Balls from a Hat.....................511
Random Mutations of Genes..........................513
Example: Policies for Limiting Population Growth...........519
Simple Games.......................................522
Guessing a Number...............................522
Rolling Two Dice.................................523
Monte Carlo Integration................................526
Derivation of Monte Carlo Integration...................526
Implementation of Standard Monte Carlo Integration.........528
Area Computing by Throwing Random Points..............531
Random Walk in One Space Dimension......................534
Basic Implementation..............................534
Visualization....................................535
Random Walk as a Difference Equation..................536
Computing Statistics of the Particle Positions..............536
Vectorized Implementation..........................537
Random Walk in Two Space Dimensions.....................539
Basic Implementation..............................539
Vectorized Implementation..........................541
Summary..........................................542
Chapter Topics..................................542
Example: Random Growth...........................544
Exercises..........................................549
Object-Oriented Programming..............................567
Inheritance and Class Hierarchies..........................567
A Class for Straight Lines...........................568
A First Try on a Class for Parabolas.....................569
A Class for Parabolas Using Inheritance..................569
Checking the Class Type............................571
Attribute vs Inheritance: has-a vs is-a Relationship...........572
Superclass for Defining an Interface.....................574
Class Hierarchy for Numerical Differentiation..................576
Classes for Differentiation...........................577
Verification.....................................579
A flexible Main Program............................581
Extensions.....................................582
Alternative Implementation via Functions.................585
Alternative Implementation via Functional Programming . 586
Alternative Implementation via a Single Class..............587
Class Hierarchy for Numerical Integration....................589
Numerical Integration Methods........................589
Classes for Integration..............................590
Verification.....................................594
Using the Class Hierarchy...........................595
About Object-Oriented Programming....................597
Class Hierarchy for Making Drawings.......................599
Using the Object Collection..........................600
Example of Classes for Geometric Objects................609
Adding Functionality via Recursion.....................614
Scaling, Translating, and Rotating a Figure................618
Classes for DNA Analysis...............................620
Class for Regions.................................620
Class for Genes..................................621
Subclasses......................................626
Summary..........................................627
Chapter Topics...................................627
Example: Input Data Reader..........................629
Exercises..........................................635

Sequences and Difference Equations..........................645
Mathematical Models Based on Difference Equations.............646
Interest Rates....................................647
The Factorial as a Difference Equation...................649
Fibonacci Numbers................................650
Growth of a Population.............................651
Logistic Growth..................................652
Payback of a Loan................................654
The Integral as a Difference Equation....................655
Taylor Series as a Difference Equation...................657
Making a Living from a Fortune.......................658
Newton’s Method.................................659
The Inverse of a Function............................663
Programming with Sound...............................665
Writing Sound to File..............................666
Reading Sound from File............................667
Playing Many Notes...............................667
Music of a Sequence...............................668
Exercises..........................................671
Introduction to Discrete Calculus.............................683
Discrete Functions....................................683
The Sine Function................................684
Interpolation....................................685
Evaluating the Approximation........................686
Generalization...................................687
Differentiation Becomes Finite Differences....................688
Differentiating the Sine Function.......................689
Differences on a Mesh..............................690
Generalization...................................692
Integration Becomes Summation...........................693
Dividing into Subintervals...........................693
Integration on Subintervals...........................695
Adding the Subintervals.............................696
Generalization...................................697
Taylor Series........................................699
Approximating Functions Close to One Point...............699
Approximating the Exponential Function.................699
More Accurate Expansions...........................700
Accuracy of the Approximation.......................702
Derivatives Revisited..............................704
More Accurate Difference Approximations................705
Second-Order Derivatives...........................707
Exercises..........................................709
Introduction to differential equations..........................715
The simplest case.....................................716
Exponential Growth...................................718
Logistic Growth......................................723
A Simple Pendulum...................................724
A Model for the Spreading of a Disease......................727
Exercises..........................................729
A Complete Differential Equation Project.......................731
About the Problem: Motion and Forces in Physics...............731
The Physical Problem..............................731
The Computational Algorithm........................733
Derivation of the Mathematical Model...................734
Derivation of the Algorithm..........................736
Program Development and Testing.........................737
Implementation..................................737
Callback Functionality.............................740
Making a Module.................................742
Verification.....................................743
Visualization........................................746
Simultaneous Computation and Plotting..................746
Some Applications................................748
Remark on Choosing L1t............................749
Comparing Several Quantities in Subplots.................750
Comparing Approximate and Exact Solutions..............751
Evolution of the Error as L1t Decreases..................752
Exercises..........................................755
Programming of Differential Equations........................757
Scalar Ordinary Differential Equations.......................758
Examples on Right-Hand-Side Functions.................758
The Forward Euler Scheme..........................759
Function Implementation............................760
Verifying the Implementation.........................761
From Discrete to Continuous Solution...................763
Switching Numerical Method.........................764
Class Implementation..............................764
Logistic Growth via a Function-Based Approach............769
Logistic Growth via a Class-Based Approach..............769
Systems of Ordinary Differential Equations...................772
Mathematical Problem.............................773
Example of a System of ODEs........................774
Function Implementation............................775
Class Implementation..............................777
The ODESolver Class Hierarchy...........................779



E.3.1 Numerical Methods . . . . . . . . . . . . . . . . . . . . . . . .


779

E.3.2 Construction of a Solver Hierarchy . . . . . . . . . . . . . . .


780

E.3.3 The Backward Euler Method . . . . . . . . . . . . . . . . . . .


783

E.3.4 Verification . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .


785

E.3.5 Example: Exponential Decay . . . . . . . . . . . . . . . . . . .


787

E.3.6 Example: The Logistic Equation with Problem and Solver


Classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .


789

E.3.7 Example: An Oscillating System . . . . . . . . . . . . . . . .


797

E.3.8 Application 4: The Trajectory of a Ball . . . . . . . . . . . .


799

E.3.9 Further Developments of ODESolver . . . . . . . . . . . . . .


801

E.4


Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .


802

Debugging.............................................835
Using a Debugger....................................835
How to Debug.......................................838
A Recipe for Program Writing and Debugging..............838
Application of the Recipe............................841
Getting Help from a Code Analyzer.....................853

G Migrating Python to Compiled Code . . . . . . . . . . . . . . . . . . . . .


857

G.1 Pure Python Code for Monte Carlo Simulation . . . . . . . . . . . .


857

G.1.1 The Computational Problem . . . . . . . . . . . . . . . . . . .


858

G.1.2 A Scalar Python Implementation . . . . . . . . . . . . . . . .


858

G.1.3 A Vectorized Python Implementation . . . . . . . . . . . . . .


859

G.2 Migrating Scalar Python Code to Cython . . . . . . . . . . . . . . . .


860

G.2.1 A Plain Cython Implementation . . . . . . . . . . . . . . . . .


860

G.2.2 A Better Cython Implementation . . . . . . . . . . . . . . . .


863

G.3 Migrating Code to C . . . . . . . . . . . . . . . . . . . . . . . . . . . .


865

G.3.1 Writing a C Program . . . . . . . . . . . . . . . . . . . . . . . .


865

G.3.2 Migrating Loops to C Code via F2PY . . . . . . . . . . . . .


866

G.3.3 Migrating Loops to C Code via Cython . . . . . . . . . . . .


867

G.3.4 Comparing Efficiency . . . . . . . . . . . . . . . . . . . . . . .


868

H


Technical Topics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .


871


H.1 Getting Access to Python . . . . . . . . . . . . . . . . . . . . . . . . .


871


H.1.1 Required Software . . . . . . . . . . . . . . . . . . . . . . . . .


871


H.1.2 Installing Software on Your Laptop: Mac OS X and

Windows . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .


872


H.1.3 Anaconda and Spyder . . . . . . . . . . . . . . . . . . . . . . .


873


H.1.4 VMWare Fusion Virtual Machine . . . . . . . . . . . . . . . .


874


H.1.5 Dual Boot on Windows . . . . . . . . . . . . . . . . . . . . . .


877


H.1.6 Vagrant Virtual Machine . . . . . . . . . . . . . . . . . . . . .


877


H.2 How to Write and Run a Python Program . . . . . . . . . . . . . . .


878


H.2.1 The Need for a Text Editor . . . . . . . . . . . . . . . . . . . .


878


H.2.2 Terminal Windows . . . . . . . . . . . . . . . . . . . . . . . . .


880


H.3 The SageMathCloud and Wakari Web Services . . . . . . . . . . . .


880


H.3.1 Basic Intro to SageMathCloud . . . . . . . . . . . . . . . . . .


880


H.3.2 Basic Intro to Wakari . . . . . . . . . . . . . . . . . . . . . . . .


881

H.3.3 Installing Your Own Python Packages...............881

Writing IPython Notebooks..............................882
A Simple Program in the Notebook.....................882
Mixing Text, Mathematics, Code, and Graphics.............882
Different Ways of Running Python Programs..................884
Executing Python Programs in iPython...................884
Executing Python Programs in Unix.....................884
Executing Python Programs in Windows..................885
Executing Python Programs in Mac OS X.................887
Making a Complete Stand-Alone Executable...............887
Doing Operating System Tasks in Python.....................888
Variable Number of Function Arguments.....................891
Variable Number of Positional Arguments................891
Variable Number of Keyword Arguments.................894
Evaluating Program Efficiency............................896
Making Time Measurements.........................896
Profiling Python Programs...........................898
Software Testing.....................................899
Requirements of the Test Function......................900
Writing the Test Function; Precomputed Data..............900
Writing the Test Function; Exact Numerical Solution.........901
Testing of Function Robustness........................902
Automatic Execution of Tests.........................904

References.............................................907

Index................................................909

List of Exercises

Exercise 1.1: Compute 1+1...................................42

Exercise 1.2: Write a Hello World program........................43

Exercise 1.3: Derive and compute a formula........................43

Exercise 1.4: Convert from meters to British length units...............43

Exercise 1.5: Compute the mass of various substances.................43

Exercise 1.6: Compute the growth of money in a bank.................43

Exercise 1.7: Find error(s) in a program...........................43

Exercise 1.8: Type in program text..............................43

Exercise 1.9: Type in programs and debug them.....................44

Exercise 1.10: Evaluate a Gaussian function........................45

Exercise 1.11: Compute the air resistance on a football.................45

Exercise 1.12: How to cook the perfect egg........................46

Exercise 1.13: Derive the trajectory of a ball.......................46

Exercise 1.14: Find errors in the coding of formulas...................47

Exercise 1.15: Explain why a program does not work..................47

Exercise 1.16: Find errors in Python statements.....................48

Exercise 1.17: Find errors in the coding of a formula..................48

Exercise 1.18: Find errors in a program...........................49

Exercise 2.1: Make a Fahrenheit-Celsius conversion table...............82

Exercise 2.2: Generate an approximate Fahrenheit-Celsius conversion table . 82 Exercise 2.3: Work with a list 82

Exercise 2.4: Generate odd numbers.............................82

Exercise 2.5: Compute the sum of the first n integers..................82

Exercise 2.6: Compute energy levels in an atom.....................82

Exercise 2.7: Generate equally spaced coordinates....................83

Exercise 2.8: Make a table of values from a formula..................83

Exercise 2.9: Store values from a formula in lists....................83

Exercise 2.10: Simulate operations on lists by hand...................84

Exercise 2.11: Compute a mathematical sum.......................84

Exercise 2.12: Replace a while loop by a for loop....................84

Exercise 2.13: Simulate a program by hand........................85

Exercise 2.14: Explore Python documentation......................85

Exercise 2.15: Index a nested list...............................85

Exercise 2.16: Store data in lists................................86

xxiii

Exercise 2.17: Store data in a nested list..........................86

Exercise 2.18: Values of boolean expressions.......................86

Exercise 2.19: Explore round-off errors from a large number of inverse

operations...................................87

Exercise 2.20: Explore what zero can be on a computer................87

Exercise 2.21: Compare two real numbers with a tolerance..............87

Exercise 2.22: Interpret a code.................................88

Exercise 2.23: Explore problems with inaccurate indentation.............88

Exercise 2.24: Explore punctuation in Python programs................89

Exercise 2.25: Investigate a for loop over a changing list...............89

Exercise 3.1: Implement a simple mathematical function...............127

Exercise 3.2: Implement a simple mathematical function with a parameter...127

Exercise 3.3: Explain how a program works.......................128

Exercise 3.4: Write a Fahrenheit-Celsius conversion functions...........128

Exercise 3.5: Write a test function for Exercise 3.4..................128

Exercise 3.6: Given a test function, write the function.................128

Exercise 3.7: Evaluate a sum and write a test function................129

Exercise 3.8: Write a function for solving ax2 bx c 0...........129

Exercise 3.9: Implement the sum function........................129

Exercise 3.10: Compute a polynomial via a product..................130

Exercise 3.11: Integrate a function by the Trapezoidal rule.............130

Exercise 3.12: Derive the general Midpoint integration rule.............131

Exercise 3.13: Make an adaptive Trapezoidal rule...................132

Exercise 3.14: Simulate a program by hand.......................133

Exercise 3.15: Debug a given test function........................134

Exercise 3.16: Compute the area of an arbitrary triangle...............134

Exercise 3.17: Compute the length of a path.......................135

Exercise 3.18: Approximate n................................135

Exercise 3.19: Compute the area of a polygon......................135

Exercise 3.20: Write functions................................136

Exercise 3.21: Approximate a function by a sum of sines..............136

Exercise 3.22: Implement a Gaussian function.....................137

Exercise 3.23: Wrap a formula in a function.......................137

Exercise 3.24: Write a function for numerical differentiation............137

Exercise 3.25: Implement the factorial function.....................137

Exercise 3.26: Compute velocity and acceleration from 1D position data....138

Exercise 3.27: Find the max and min values of a function..............138

Exercise 3.28: Find the max and min elements in a list................139

Exercise 3.29: Implement the Heaviside function....................139

Exercise 3.30: Implement a smoothed Heaviside function..............139

Exercise 3.31: Implement an indicator function.....................140

Exercise 3.32: Implement a piecewise constant function...............140

Exercise 3.33: Apply indicator functions.........................141

Exercise 3.34: Test your understanding of branching.................141

Exercise 3.35: Simulate nested loops by hand......................141

Exercise 3.36: Rewrite a mathematical function.....................142

Exercise 3.37: Make a table for approximations of cos x...............142

Exercise 3.38: Use None in keyword arguments....................143

Exercise 3.39: Write a sort function for a list of 4-tuples...............143

Exercise 3.40: Find prime numbers.............................145

Exercise 3.41: Find pairs of characters...........................145

Exercise 3.42: Count substrings...............................145

Exercise 3.43: Resolve a problem with a function...................145

Exercise 3.44: Determine the types of some objects..................146

Exercise 3.45: Find an error in a program.........................146

Exercise 4.1: Make an interactive program........................216

Exercise 4.2: Read a number from the command line.................216

Exercise 4.3: Read a number from a file..........................216

Exercise 4.4: Read and write several numbers from and to file...........217

Exercise 4.5: Use exceptions to handle wrong input..................217

Exercise 4.6: Read input from the keyboard.......................217

Exercise 4.7: Read input from the command line....................217

Exercise 4.8: Try MSWord or LibreOffice to write a program...........218

Exercise 4.9: Prompt the user for input to a formula..................218

Exercise 4.10: Read parameters in a formula from the command line.......218

Exercise 4.11: Use exceptions to handle wrong input.................218

Exercise 4.12: Test validity of input data.........................219

Exercise 4.13: Raise an exception in case of wrong input..............219

Exercise 4.14: Evaluate a formula for data in a file...................219

Exercise 4.15: Write a function given its test function.................219

Exercise 4.16: Compute the distance it takes to stop a car..............220

Exercise 4.17: Look up calendar functionality......................221

Exercise 4.18: Use the StringFunction tool........................221

Exercise 4.19: Why we test for specific exception types...............221

Exercise 4.20: Make a complete module.........................221

Exercise 4.21: Organize a previous program as a module..............222

Exercise 4.22: Read options and values from the command line..........222

Exercise 4.23: Check if mathematical identities hold.................222

Exercise 4.24: Compute probabilities with the binomial distribution.......224

Exercise 4.25: Compute probabilities with the Poisson distribution........224

Exercise 5.1: Fill lists with function values........................313

Exercise 5.2: Fill arrays; loop version...........................313

Exercise 5.3: Fill arrays; vectorized version.......................313

Exercise 5.4: Plot a function.................................313

Exercise 5.5: Apply a function to a vector........................313

Exercise 5.6: Simulate by hand a vectorized expression...............313

Exercise 5.7: Demonstrate array slicing..........................314

Exercise 5.8: Replace list operations by array computing...............314

Exercise 5.9: Plot a formula..................................314

Exercise 5.10: Plot a formula for several parameters..................314

Exercise 5.11: Specify the extent of the axes in a plot.................314

Exercise 5.12: Plot exact and inexact Fahrenheit-Celsius conversion formulas 314

Exercise 5.13: Plot the trajectory of a ball.........................314

Exercise 5.14: Plot data in a two-column file......................315

Exercise 5.15: Write function data to file.........................315

Exercise 5.16: Plot data from a file.............................316

Exercise 5.17: Write table to file...............................316

Exercise 5.18: Fit a polynomial to data points......................317

Exercise 5.19: Fit a polynomial to experimental data.................318

Exercise 5.20: Read acceleration data and find velocities..............318

Exercise 5.21: Read acceleration data and plot velocities...............319

Exercise 5.22: Plot a trip’s path and velocity from GPS coordinates.......319

Exercise 5.23: Vectorize the Midpoint rule for integration..............320

Exercise 5.24: Vectorize a function for computing the area of a polygon....320

Exercise 5.25: Implement Lagrange’s interpolation formula.............321

Exercise 5.26: Plot Lagrange’s interpolating polynomial...............321

Exercise 5.27: Investigate the behavior of Lagrange’s interpolating polynomials 322 Exercise 5.28: Plot a wave packet 322

Exercise 5.29: Judge a plot..................................322

Exercise 5.30: Plot the viscosity of water.........................323

Exercise 5.31: Explore a complicated function graphically.............323

Exercise 5.32: Plot Taylor polynomial approximations to sin x...........323

Exercise 5.33: Animate a wave packet...........................324

Exercise 5.34: Animate a smoothed Heaviside function...............324

Exercise 5.35: Animate two-scale temperature variations..............324

Exercise 5.36: Use non-uniformly distributed coordinates for visualization...325

Exercise 5.37: Animate a sequence of approximations to n.............325

Exercise 5.38: Animate a planet’s orbit..........................325

Exercise 5.39: Animate the evolution of Taylor polynomials............326

Exercise 5.40: Plot the velocity profile for pipeflow..................327

Exercise 5.41: Plot sum-of-sines approximations to a function...........327

Exercise 5.42: Animate the evolution of a sum-of-sine approximation to

a function...................................327

Exercise 5.43: Plot functions from the command line.................328

Exercise 5.44: Improve command-line input.......................328

Exercise 5.45: Demonstrate energy concepts from physics..............328

Exercise 5.46: Plot a w-like function............................328

Exercise 5.47: Plot a piecewise constant function....................329

Exercise 5.48: Vectorize a piecewise constant function................329

Exercise 5.49: Visualize approximations in the Midpoint integration rule....329

Exercise 5.50: Visualize approximations in the Trapezoidal integration rule . 330 Exercise 5.51: Experience overflow in a function 330

Exercise 5.52: Apply a function to a rank 2 array....................331

Exercise 5.53: Explain why array computations fail..................331

Exercise 5.54: Verify linear algebra results........................331

Exercise 6.1: Make a dictionary from a table.......................402

Exercise 6.2: Explore syntax differences: lists vs. dicts................402

Exercise 6.3: Use string operations to improve a program..............403

Exercise 6.4: Interpret output from a program......................403

Exercise 6.5: Make a dictionary...............................403

Exercise 6.6: Make a nested dictionary..........................404

Exercise 6.7: Make a nested dictionary from a file...................404

Exercise 6.8: Make a nested dictionary from a file...................404

Exercise 6.9: Compute the area of a triangle.......................405

Exercise 6.10: Compare data structures for polynomials...............405

Exercise 6.11: Compute the derivative of a polynomial................405

Exercise 6.12: Specify functions on the command line................405

Exercise 6.13: Interpret function specifications.....................406

Exercise 6.14: Compare average temperatures in cities................407

Exercise 6.15: Generate an HTML report with figures................407

Exercise 6.16: Allow different types for a function argument............408

Exercise 6.17: Make a function more robust.......................408

Exercise 6.18: Find proportion of bases inside/outside exons............408

Exercise 7.1: Make a function class.............................470

Exercise 7.2: Add a data attribute to a class.......................471

Exercise 7.3: Add functionality to a class.........................471

Exercise 7.4: Make classes for a rectangle and a triangle...............471

Exercise 7.5: Make a class for quadratic functions...................472

Exercise 7.6: Make a class for straight lines.......................472

Exercise 7.7: Flexible handling of function arguments................472

Exercise 7.8: Wrap functions in a class..........................473

Exercise 7.9: Flexible handling of function arguments................473

Exercise 7.10: Deduce a class implementation......................474

Exercise 7.11: Implement special methods in a class.................474

Exercise 7.12: Make a class for summation of series..................474

Exercise 7.13: Apply a numerical differentiation class................475

Exercise 7.14: Implement an addition operator.....................475

Exercise 7.15: Implement in-place += and -= operators................476

Exercise 7.16: Implement a class for numerical differentiation...........476

Exercise 7.17: Examine a program.............................477

Exercise 7.18: Modify a class for numerical differentiation.............477

Exercise 7.19: Make a class for the Heaviside function................478

Exercise 7.20: Make a class for the indicator function.................478

Exercise 7.21: Make a class for piecewise constant functions............479

Exercise 7.22: Speed up repeated integral calculations................479

Exercise 7.23: Apply a class for polynomials......................480

Exercise 7.24: Find a bug in a class for polynomials..................480

Exercise 7.25: Implement subtraction of polynomials.................480

Exercise 7.26: Test the functionality of pretty print of polynomials........480

Exercise 7.27: Vectorize a class for polynomials....................481

Exercise 7.28: Use a dict to hold polynomial coefficients..............481

Exercise 7.29: Extend class Vec2D to work with lists/tuples............482

Exercise 7.30: Extend class Vec2D to 3D vectors...................483

Exercise 7.31: Use NumPy arrays in class Vec2D...................483

Exercise 7.32: Impreciseness of interval arithmetics..................484

Exercise 7.33: Make classes for students and courses.................484

Exercise 7.34: Find local and global extrema of a function..............484

Exercise 7.35: Find the optimal production for a company..............485

Exercise 8.1: Flip a coin times................................549

Exercise 8.2: Compute a probability............................550

Exercise 8.3: Choose random colors............................550

Exercise 8.4: Draw balls from a hat.............................550

Exercise 8.5: Computing probabilities of rolling dice.................550

Exercise 8.6: Estimate the probability in a dice game.................550

Exercise 8.7: Compute the probability of hands of cards...............551

Exercise 8.8: Decide if a dice game is fair........................551

Exercise 8.9: Adjust a game to make it fair........................551

Exercise 8.10: Make a test function for Monte Carlo simulation..........551

Exercise 8.11: Generalize a game..............................551

Exercise 8.12: Compare two playing strategies.....................552

Exercise 8.13: Investigate strategies in a game.....................552

Exercise 8.14: Investigate the winning chances of some games...........552

Exercise 8.15: Compute probabilities of throwing two dice.............553

Exercise 8.16: Vectorize flipping a coin..........................553

Exercise 8.17: Vectorize a probablility computation..................553

Exercise 8.18: Throw dice and compute a small probability.............553

Exercise 8.19: Is democracy reliable as a decision maker?..............553

Exercise 8.20: Difference equation for random numbers...............555

Exercise 8.21: Make a class for drawing balls from a hat...............555

Exercise 8.22: Independent versus dependent random numbers..........555

Exercise 8.23: Compute the probability of flipping a coin..............556

Exercise 8.24: Simulate binomial experiments......................557

Exercise 8.25: Simulate a poker game...........................557

Exercise 8.26: Estimate growth in a simulation model................557

Exercise 8.27: Investigate guessing strategies......................557

Exercise 8.28: Vectorize a dice game...........................558

Exercise 8.29: Compute n by a Monte Carlo method.................558

Exercise 8.30: Compute n by a Monte Carlo method.................558

Exercise 8.31: Compute n by a random sum.......................558

Exercise 8.32: 1D random walk with drift........................558

Exercise 8.33: 1D random walk until a point is hit...................558

Exercise 8.34: Simulate making a fortune from gaming................559

Exercise 8.35: Simulate pollen movements as a 2D random walk.........559

Exercise 8.36: Make classes for 2D random walk....................559

Exercise 8.37: 2D random walk with walls; scalar version..............560

Exercise 8.38: 2D random walk with walls; vectorized version...........560

Exercise 8.39: Simulate mixing of gas molecules....................561

Exercise 8.40: Simulate slow mixing of gas molecules................561

Exercise 8.41: Guess beer brands..............................561

Exercise 8.42: Simulate stock prices............................562

Exercise 8.43: Compute with option prices in finance.................562

Exercise 8.44: Differentiate noise measurements....................563

Exercise 8.45: Differentiate noisy signals.........................564

Exercise 8.46: Model noise in a time signal.......................565

Exercise 8.47: Speed up Markov chain mutation....................566

Exercise 9.1: Demonstrate the magic of inheritance..................635

Exercise 9.2: Make polynomial subclasses of parabolas...............635

Exercise 9.3: Implement a class for a function as a subclass.............636

Exercise 9.4: Create an alternative class hierarchy for polynomials........636

Exercise 9.5: Make circle a subclass of an ellipse....................636

Exercise 9.6: Make super- and subclass for a point...................636

Exercise 9.7: Modify a function class by subclassing.................637

Exercise 9.8: Explore the accuracy of difference formulas..............637

Exercise 9.9: Implement a subclass.............................637

Exercise 9.10: Make classes for numerical differentiation..............638

Exercise 9.11: Implement a new subclass for differentiation............638

Exercise 9.12: Understand if a class can be used recursively............638

Exercise 9.13: Represent people by a class hierarchy.................638

Exercise 9.14: Add a new class in a class hierarchy..................639

Exercise 9.15: Compute convergence rates of numerical integration methods . 640 Exercise 9.16: Add common functionality in a class hierarchy 641

Exercise 9.17: Make a class hierarchy for root finding................641

Exercise 9.18: Make a calculus calculator class.....................641

Exercise 9.19: Compute inverse functions........................642

Exercise 9.20: Make line drawing of a person; program...............643

Exercise 9.21: Make line drawing of a person; class..................643

Exercise 9.22: Animate a person with waving hands..................643

Exercise A.1: Determine the limit of a sequence....................671

Exercise A.2: Compute n via sequences..........................672

Exercise A.3: Reduce memory usage of difference equations............672

Exercise A.4: Compute the development of a loan...................672

Exercise A.5: Solve a system of difference equations.................672

Exercise A.6: Modify a model for fortune development...............672

Exercise A.7: Change index in a difference equation.................673

Exercise A.8: Construct time points from dates.....................673

Exercise A.9: Visualize the convergence of Newton’s method...........674

Exercise A.10: Implement the secant method......................674

Exercise A.11: Test different methods for root finding................675

Exercise A.12: Make difference equations for the Midpoint rule..........675

Exercise A.13: Compute the arc length of a curve...................675

Exercise A.14: Find difference equations for computing sin x............676

Exercise A.15: Find difference equations for computing cos x...........677

Exercise A.16: Make a guitar-like sound.........................677

Exercise A.17: Damp the bass in a sound file......................677

Exercise A.18: Damp the treble in a sound file.....................678

Exercise A.19: Demonstrate oscillatory solutions of the logistic equation....678

Exercise A.20: Automate computer experiments....................679

Exercise A.21: Generate an HTML report........................679

Exercise A.22: Use a class to archive and report experiments............680

Exercise A.23: Explore logistic growth interactively.................681

Exercise A.24: Simulate the price of wheat........................681

Exercise B.1: Interpolate a discrete function.......................709

Exercise B.2: Study a function for different parameter values............710

Exercise B.3: Study a function and its derivative....................710

Exercise B.4: Use the Trapezoidal method........................711

Exercise B.5: Compute a sequence of integrals.....................711

Exercise B.6: Use the Trapezoidal method........................712

Exercise B.7: Compute trigonometric integrals.....................712

Exercise B.8: Plot functions and their derivatives....................713

Exercise B.9: Use the Trapezoidal method........................714

Exercise C.1: Solve a nonhomogeneous linear ODE..................729

Exercise C.2: Solve a nonlinear ODE...........................729

Exercise C.3: Solve an ODE for y.x/............................729

Exercise C.4: Experience instability of an ODE.....................730

Exercise C.5: Solve an ODE with time-varying growth................730

Exercise D.1: Model sudden movements of the plate.................755

Exercise D.2: Write a callback function..........................756

Exercise D.3: Improve input to the simulation program................756

Exercise E.1: Solve a simple ODE with function-based code............802

Exercise E.2: Solve a simple ODE with class-based code..............802

Exercise E.3: Solve a simple ODE with the ODEsolver hierarchy.........802

Exercise E.4: Solve an ODE specified on the command line............802

Exercise E.5: Implement a numerical method for ODEs...............803

Exercise E.6: Solve an ODE for emptying a tank....................803

Exercise E.7: Solve an ODE for the arc length.....................804

Exercise E.8: Simulate a falling or rising body in a fluid...............804

Exercise E.9: Verify the limit of a solution as time grows..............805

Exercise E.10: Scale the logistic equation.........................806

Exercise E.11: Compute logistic growth with time-varying carrying capacity . 806 Exercise E.12: Solve an ODE until constant solution 807

Exercise E.13: Use a problem class to hold data about an ODE...........807

Exercise E.14: Derive and solve a scaled ODE problem...............808

Exercise E.15: Clean up a file to make it a module...................809

Exercise E.16: Simulate radioactive decay........................809

Exercise E.17: Compute inverse functions by solving an ODE...........809

Exercise E.18: Make a class for computing inverse functions............810

Exercise E.19: Add functionality to a class........................810

Exercise E.20: Compute inverse functions by interpolation.............811

Exercise E.21: Code the 4th-order Runge-Kutta method; function.........811

Exercise E.22: Code the 4th-order Runge-Kutta method; class...........811

Exercise E.23: Compare ODE methods..........................811

Exercise E.24: Code a test function for systems of ODEs..............812

Exercise E.25: Code Heun’s method for ODE systems; function..........812

Exercise E.26: Code Heun’s method for ODE systems; class............812

Exercise E.27: Implement and test the Leapfrog method...............812

Exercise E.28: Implement and test an Adams-Bashforth method..........813

Exercise E.29: Solve two coupled ODEs for radioactive decay...........813

Exercise E.30: Implement a 2nd-order Runge-Kutta method; function......813

Exercise E.31: Implement a 2nd-order Runge-Kutta method; class........813

Exercise E.32: Code the iterated midpoint method; function............814

Exercise E.33: Code the iterated midpoint method; class...............814

Exercise E.34: Make a subclass for the iterated midpoint method.........815

Exercise E.35: Compare the accuracy of various methods for ODEs.......815

Exercise E.36: Animate how various methods for ODEs converge........815

Exercise E.37: Study convergence of numerical methods for ODEs........815

Exercise E.38: Find a body’s position along with its velocity............816

Exercise E.39: Add the effect of air resistance on a ball................816

Exercise E.40: Solve an ODE system for an electric circuit.............817

Exercise E.41: Simulate the spreading of a disease by a SIR model........817

Exercise E.42: Introduce problem and solver classes in the SIR model......819

Exercise E.43: Introduce vaccination in a SIR model.................820

Exercise E.44: Introduce a vaccination campaign in a SIR model.........820

Exercise E.45: Find an optimal vaccination period...................821

Exercise E.46: Simulate human-zombie interaction..................821

Exercise E.47: Simulate a zombie movie.........................823

Exercise E.48: Simulate a war on zombies........................824

Exercise E.49: Explore predator-prey population interactions............824

Exercise E.50: Formulate a 2nd-order ODE as a system...............825

imageExercise E.51: Solve u u 0...............................826

Exercise E.52: Make a tool for analyzing oscillatory solutions...........826

Exercise E.53: Implement problem, solver, and visualizer classes.........827

Exercise E.54: Use classes for flexible choices of models..............831

Exercise E.55: Apply software for oscillating systems................831

Exercise E.56: Model the economy of fishing......................832