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