Contents Computing with Formulas

Transcription

1 Contents 1 Computing with Formulas The First Programming Encounter: a Formula Using a Program as a Calculator About Programs and Programming Tools for Writing Programs Writing and Running Your First Python Program Warning About Typing Program Text Verifying the Result Using Variables Names of Variables Reserved Words in Python Comments Formatting Text and Numbers Computer Science Glossary Another Formula: Celsius-Fahrenheit Conversion Potential Error: Integer Division Objects in Python Avoiding Integer Division Arithmetic Operators and Precedence Evaluating Standard Mathematical Functions Example: Using the Square Root Function Example: Computing with sinh x A First Glimpse of Rounding Errors Interactive Computing Using the Python Shell Type Conversion IPython Complex Numbers Complex Arithmetics in Python Complex Functions in Python Unified Treatment of Complex and Real Functions Symbolic Computing Basic Differentiation and Integration Equation Solving xi

2 xii Contents Taylor Series and More Summary Chapter Topics Example: Trajectory of a Ball About Typesetting Conventions in This Book Exercises Loops and Lists While Loops A Naive Solution While Loops Boolean Expressions Loop Implementation of a Sum Lists Basic List Operations For Loops Alternative Implementations with Lists and Loops While Loop Implementation of a for Loop The Range Construction For Loops with List Indices Changing List Elements List Comprehension Traversing Multiple Lists Simultaneously Nested Lists A table as a List of Rows or Columns Printing Objects Extracting Sublists Traversing Nested Lists Tuples Summary Chapter Topics Example: Analyzing List Data How to Find More Python Information Exercises Functions and Branching Functions Mathematical Functions as Python Functions Understanding the Program Flow Local and Global Variables Multiple Arguments Function Argument or Global Variable? Beyond Mathematical Functions Multiple Return Values Computing Sums Functions with No Return Values Keyword Arguments Doc Strings

3 Contents xiii Functions as Arguments to Functions The Main Program Lambda Functions Branching If-else Blocks Inline if Tests Mixing Loops, Branching, and Functions in Bioinformatics Examples Counting Letters in DNA Strings Efficiency Assessment Verifying the Implementations Summary Chapter Topics Example: Numerical Integration Exercises User Input and Error Handling Asking Questions and Reading Answers Reading Keyboard Input Reading from the Command Line Providing Input on the Command Line A Variable Number of Command-Line Arguments More on Command-Line Arguments Turning User Text into Live Objects The Magic Eval Function The Magic Exec Function Turning String Expressions into Functions Option-Value Pairs on the Command Line Basic Usage of the Argparse Module Mathematical Expressions as Values Reading Data from File Reading a File Line by Line Alternative Ways of Reading a File Reading a Mixture of Text and Numbers Writing Data to File Example: Writing a Table to File Standard Input and Output as File Objects What is a File, Really? Handling Errors Exception Handling Raising Exceptions A Glimpse of Graphical User Interfaces Making Modules Example: Interest on Bank Deposits Collecting Functions in a Module File Test Block Verification of the Module Code Getting Input Data

4 xiv Contents Doc Strings in Modules Using Modules Distributing Modules Making Software Available on the Internet Making Code for Python 2 and Basic Differences Between Python 2 and Turning Python 2 Code into Python 3 Code Summary Chapter Topics Example: Bisection Root Finding Exercises Array Computing and Curve Plotting Vectors The Vector Concept Mathematical Operations on Vectors Vector Arithmetics and Vector Functions Arrays in Python Programs Using Lists for Collecting Function Data Basics of Numerical Python Arrays Computing Coordinates and Function Values Vectorization Curve Plotting MATLAB-Style Plotting with Matplotlib Matplotlib; Pyplot Prefix SciTools and Easyviz Making Animations Making Videos Curve Plots in Pure Text Plotting Difficulties Piecewisely Defined Functions Rapidly Varying Functions More Advanced Vectorization of Functions Vectorization of StringFunction Objects Vectorization of the Heaviside Function Vectorization of a Hat Function More on Numerical Python Arrays Copying Arrays In-Place Arithmetics Allocating Arrays Generalized Indexing Testing for the Array Type Compact Syntax for Array Generation Shape Manipulation High-Performance Computing with Arrays Scalar Implementation Vectorized Implementation Memory-Saving Implementation

5 Contents xv Analysis of Memory Usage Analysis of the CPU Time Higher-Dimensional Arrays Matrices and Arrays Two-Dimensional Numerical Python Arrays Array Computing Matrix Objects Some Common Linear Algebra Operations Inverse, Determinant, and Eigenvalues Products Norms Sum and Extreme Values Indexing Transpose and Upper/Lower Triangular Parts Solving Linear Systems Matrix Row and Column Operations Computing the Rank of a Matrix Symbolic Linear Algebra Plotting of Scalar and Vector Fields Installation Surface Plots Parameterized Curve Contour Lines The Gradient Vector Field Matplotlib Surface Plots Contour Plots Vector Field Plots Mayavi Surface Plots Contour Plots Vector Field Plots A 3D Scalar Field and Its Gradient Field Animations Summary Chapter Topics Example: Animating a Function Exercises Dictionaries and Strings Dictionaries Making Dictionaries Dictionary Operations Example: Polynomials as Dictionaries Dictionaries with Default Values and Ordering Example: Storing File Data in Dictionaries Example: Storing File Data in Nested Dictionaries

6 xvi Contents Example: Reading and Plotting Data Recorded at Specific Dates Strings Common Operations on Strings Example: Reading Pairs of Numbers Example: Reading Coordinates Reading Data from Web Pages About Web Pages How to Access Web Pages in Programs Example: Reading Pure Text Files Example: Extracting Data from HTML Handling Non-English Text Reading and Writing Spreadsheet Files CSV Files Reading CSV Files Processing Spreadsheet Data Writing CSV Files Representing Number Cells with Numerical Python Arrays Using More High-Level Numerical Python Functionality Examples from Analyzing DNA Computing Frequencies Analyzing the Frequency Matrix Finding Base Frequencies Translating Genes into Proteins Some Humans Can Drink Milk, While Others Cannot Making Code that is Compatible with Python 2 and More Basic Differences Between Python 2 and Turning Python 2 Code into Python 3 Code Summary Chapter Topics Example: A File Database Exercises Introduction to Classes Simple Function Classes Challenge: Functions with Parameters Representing a Function as a Class The Self Variable Another Function Class Example Alternative Function Class Implementations Making Classes Without the Class Construct Closures More Examples on Classes Bank Accounts Phone Book A Circle Special Methods The Call Special Method

7 Contents xvii Example: Automagic Differentiation Example: Automagic Integration Turning an Instance into a String Example: Phone Book with Special Methods Adding Objects Example: Class for Polynomials Arithmetic Operations and Other Special Methods Special Methods for String Conversion Example: Class for Vectors in the Plane Some Mathematical Operations on Vectors Implementation Usage Example: Class for Complex Numbers Implementation Illegal Operations Mixing Complex and Real Numbers Dynamic, Static, Strong, Weak, and Duck Typing Special Methods for Right Operands Inspecting Instances Static Methods and Attributes Summary Chapter Topics Example: Interval Arithmetic Exercises Random Numbers and Simple Games Drawing Random Numbers The Seed Uniformly Distributed Random Numbers Visualizing the Distribution Vectorized Drawing of Random Numbers Computing the Mean and Standard Deviation The Gaussian or Normal Distribution Drawing Integers Random Integer Functions Example: Throwing a Die Drawing a Random Element from a List Example: Drawing Cards from a Deck Example: Class Implementation of a Deck Computing Probabilities Principles of Monte Carlo Simulation Example: Throwing Dice Example: Drawing Balls from a Hat Random Mutations of Genes Example: Policies for Limiting Population Growth Simple Games Guessing a Number Rolling Two Dice

8 xviii Contents 8.5 Monte Carlo Integration Derivation of Monte Carlo Integration Implementation of Standard Monte Carlo Integration Area Computing by Throwing Random Points Random Walk in One Space Dimension Basic Implementation Visualization Random Walk as a Difference Equation Computing Statistics of the Particle Positions Vectorized Implementation Random Walk in Two Space Dimensions Basic Implementation Vectorized Implementation Summary Chapter Topics Example: Random Growth Exercises Object-Oriented Programming Inheritance and Class Hierarchies A Class for Straight Lines A First Try on a Class for Parabolas A Class for Parabolas Using Inheritance Checking the Class Type Attribute vs Inheritance: has-a vs is-a Relationship Superclass for Defining an Interface Class Hierarchy for Numerical Differentiation Classes for Differentiation Verification A flexible Main Program Extensions Alternative Implementation via Functions Alternative Implementation via Functional Programming Alternative Implementation via a Single Class Class Hierarchy for Numerical Integration Numerical Integration Methods Classes for Integration Verification Using the Class Hierarchy About Object-Oriented Programming Class Hierarchy for Making Drawings Using the Object Collection Example of Classes for Geometric Objects Adding Functionality via Recursion Scaling, Translating, and Rotating a Figure Classes for DNA Analysis Class for Regions Class for Genes

9 Contents xix Subclasses Summary Chapter Topics Example: Input Data Reader Exercises A Sequences and Difference Equations A.1 Mathematical Models Based on Difference Equations A.1.1 Interest Rates A.1.2 The Factorial as a Difference Equation A.1.3 Fibonacci Numbers A.1.4 Growth of a Population A.1.5 Logistic Growth A.1.6 Payback of a Loan A.1.7 The Integral as a Difference Equation A.1.8 Taylor Series as a Difference Equation A.1.9 Making a Living from a Fortune A.1.10Newton s Method A.1.11The Inverse of a Function A.2 Programming with Sound A.2.1 Writing Sound to File A.2.2 Reading Sound from File A.2.3 Playing Many Notes A.2.4 Music of a Sequence A.3 Exercises B Introduction to Discrete Calculus B.1 Discrete Functions B.1.1 The Sine Function B.1.2 Interpolation B.1.3 Evaluating the Approximation B.1.4 Generalization B.2 Differentiation Becomes Finite Differences B.2.1 Differentiating the Sine Function B.2.2 Differences on a Mesh B.2.3 Generalization B.3 Integration Becomes Summation B.3.1 Dividing into Subintervals B.3.2 Integration on Subintervals B.3.3 Adding the Subintervals B.3.4 Generalization B.4 Taylor Series B.4.1 Approximating Functions Close to One Point B.4.2 Approximating the Exponential Function B.4.3 More Accurate Expansions B.4.4 Accuracy of the Approximation B.4.5 Derivatives Revisited B.4.6 More Accurate Difference Approximations

10 xx Contents B.4.7 Second-Order Derivatives B.5 Exercises C Introduction to differential equations C.1 The simplest case C.2 Exponential Growth C.3 Logistic Growth C.4 A Simple Pendulum C.5 A Model for the Spreading of a Disease C.6 Exercises D A Complete Differential Equation Project D.1 About the Problem: Motion and Forces in Physics D.1.1 The Physical Problem D.1.2 The Computational Algorithm D.1.3 Derivation of the Mathematical Model D.1.4 Derivation of the Algorithm D.2 Program Development and Testing D.2.1 Implementation D.2.2 Callback Functionality D.2.3 Making a Module D.2.4 Verification D.3 Visualization D.3.1 Simultaneous Computation and Plotting D.3.2 Some Applications D.3.3 Remark on Choosing t D.3.4 Comparing Several Quantities in Subplots D.3.5 Comparing Approximate and Exact Solutions D.3.6 Evolution of the Error as t Decreases D.4 Exercises E Programming of Differential Equations E.1 Scalar Ordinary Differential Equations E.1.1 Examples on Right-Hand-Side Functions E.1.2 The Forward Euler Scheme E.1.3 Function Implementation E.1.4 Verifying the Implementation E.1.5 From Discrete to Continuous Solution E.1.6 Switching Numerical Method E.1.7 Class Implementation E.1.8 Logistic Growth via a Function-Based Approach E.1.9 Logistic Growth via a Class-Based Approach E.2 Systems of Ordinary Differential Equations E.2.1 Mathematical Problem E.2.2 Example of a System of ODEs E.2.3 Function Implementation E.2.4 Class Implementation E.3 The ODESolver Class Hierarchy

11 Contents xxi E.3.1 Numerical Methods E.3.2 Construction of a Solver Hierarchy E.3.3 The Backward Euler Method E.3.4 Verification E.3.5 Example: Exponential Decay E.3.6 Example: The Logistic Equation with Problem and Solver Classes E.3.7 Example: An Oscillating System E.3.8 Application 4: The Trajectory of a Ball E.3.9 Further Developments of ODESolver E.4 Exercises F Debugging F.1 Using a Debugger F.2 How to Debug F.2.1 A Recipe for Program Writing and Debugging F.2.2 Application of the Recipe F.2.3 Getting Help from a Code Analyzer G Migrating Python to Compiled Code G.1 Pure Python Code for Monte Carlo Simulation G.1.1 The Computational Problem G.1.2 A Scalar Python Implementation G.1.3 A Vectorized Python Implementation G.2 Migrating Scalar Python Code to Cython G.2.1 A Plain Cython Implementation G.2.2 A Better Cython Implementation G.3 Migrating Code to C G.3.1 Writing a C Program G.3.2 Migrating Loops to C Code via F2PY G.3.3 Migrating Loops to C Code via Cython G.3.4 Comparing Efficiency H Technical Topics H.1 Getting Access to Python H.1.1 Required Software H.1.2 Installing Software on Your Laptop: Mac OS X and Windows H.1.3 Anaconda and Spyder H.1.4 VMWare Fusion Virtual Machine H.1.5 Dual Boot on Windows H.1.6 Vagrant Virtual Machine H.2 How to Write and Run a Python Program H.2.1 The Need for a Text Editor H.2.2 Terminal Windows H.3 The SageMathCloud and Wakari Web Services H.3.1 Basic Intro to SageMathCloud H.3.2 Basic Intro to Wakari

12 xxii Contents H.3.3 Installing Your Own Python Packages H.4 Writing IPython Notebooks H.4.1 A Simple Program in the Notebook H.4.2 Mixing Text, Mathematics, Code, and Graphics H.5 Different Ways of Running Python Programs H.5.1 Executing Python Programs in ipython H.5.2 Executing Python Programs in Unix H.5.3 Executing Python Programs in Windows H.5.4 Executing Python Programs in Mac OS X H.5.5 Making a Complete Stand-Alone Executable H.6 Doing Operating System Tasks in Python H.7 Variable Number of Function Arguments H.7.1 Variable Number of Positional Arguments H.7.2 Variable Number of Keyword Arguments H.8 Evaluating Program Efficiency H.8.1 Making Time Measurements H.8.2 Profiling Python Programs H.9 Software Testing H.9.1 Requirements of the Test Function H.9.2 Writing the Test Function; Precomputed Data H.9.3 Writing the Test Function; Exact Numerical Solution H.9.4 Testing of Function Robustness H.9.5 Automatic Execution of Tests References Index

13