$$ \newcommand{\half}{\frac{1}{2}} \newcommand{\tp}{\thinspace .} \newcommand{\uex}{{u_{\small\mbox{e}}}} \newcommand{\Aex}{{A_{\small\mbox{e}}}} \newcommand{\E}[1]{\hbox{E}\lbrack #1 \rbrack} \newcommand{\Var}[1]{\hbox{Var}\lbrack #1 \rbrack} \newcommand{\Std}[1]{\hbox{Std}\lbrack #1 \rbrack} \newcommand{\Oof}[1]{\mathcal{O}(#1)} \newcommand{\stress}{\boldsymbol{\sigma}} $$

Contents
- Preface
- Algorithms and implementations
- Finite difference methods
- A basic model for exponential decay
- The exact solution
- A complete problem formulation
- The Forward Euler scheme
- Step 1: Discretizing the domain
- Step 2: Fulfilling the equation at discrete time points
- Step 3: Replacing derivatives by finite differences
- Step 4: Formulating a recursive algorithm
- Interpretation
- Computing with the recursive formula
- The Backward Euler scheme
- The Crank-Nicolson scheme
- The unifying $ \theta $-rule
- Constant time step
- Mathematical derivation of finite difference formulas
- The forward difference
- The backward difference
- The centered difference
- Compact operator notation for finite differences
- Implementation
- Computer language: Python
- Making a solver function
- Integer division
- Doc strings
- Formatting numbers
- Running the program
- Plotting the solution
- Verifying the implementation
- Running a few algorithmic steps by hand
- Computing the numerical error as a mesh function
- Computing the norm of the error mesh function
- Scalar computing
- Experiments with computing and plotting
- Combining plot files
- Plotting with SciTools
- Memory-saving implementation
- Exercises
- Exercise 1.1: Define a mesh function and visualize it
- Remarks
- Problem 1.2: Differentiate a function
- Problem 1.3: Experiment with divisions
- Problem 1.4: Experiment with wrong computations
- Problem 1.5: Plot the error function
- Problem 1.6: Change formatting of numbers and debug
- Analysis
- Experimental investigations
- Discouraging numerical solutions
- Detailed experiments
- Stability
- Exact numerical solution
- Stability properties derived from the amplification factor
- Accuracy
- Visual comparison of amplification factors
- Series expansion of amplification factors
- The ratio of numerical and exact amplification factors
- The global error at a point
- Integrated error
- Truncation error
- Consistency, stability, and convergence
- Various types of errors in a differential equation model
- Model errors
- Data errors
- Discretization errors
- Rounding errors
- Discussion of the size of various errors
- Exercises
- Problem 2.1: Visualize the accuracy of finite differences
- Problem 2.2: Explore the $ \theta $-rule for exponential growth
- Problem 2.3: Explore rounding errors in numerical calculus
- Generalizations
- Model extensions
- Generalization: including a variable coefficient
- Generalization: including a source term
- Implementation of the generalized model problem
- Deriving the $ \theta $-rule formula
- Python code
- Coding of variable coefficients
- Verifying a constant solution
- Verification via manufactured solutions
- Computing convergence rates
- Estimating $ r $
- Implementation
- Extension to systems of ODEs
- General first-order ODEs
- Generic form of first-order ODEs
- The $ \theta $-rule
- An implicit 2-step backward scheme
- Leapfrog schemes
- The ordinary Leapfrog scheme
- The filtered Leapfrog scheme
- The 2nd-order Runge-Kutta method
- A 2nd-order Taylor-series method
- The 2nd- and 3rd-order Adams-Bashforth schemes
- The 4th-order Runge-Kutta method
- The Odespy software
- Example: Runge-Kutta methods
- Remark about using the $ \theta $-rule in Odespy
- Example: Adaptive Runge-Kutta methods
- Exercises
- Exercise 3.1: Experiment with precision in tests and the size of $ u $
- Exercise 3.2: Implement the 2-step backward scheme
- Exercise 3.3: Implement the 2nd-order Adams-Bashforth scheme
- Exercise 3.4: Implement the 3rd-order Adams-Bashforth scheme
- Exercise 3.5: Analyze explicit 2nd-order methods
- Project 3.6: Implement and investigate the Leapfrog scheme
- Problem 3.7: Make a unified implementation of many schemes
- Models
- Scaling
- Dimensionless variables
- Dimensionless numbers
- A scaling for vanishing initial condition
- Evolution of a population
- Exponential growth
- Logistic growth
- Compound interest and inflation
- Newton's law of cooling
- Radioactive decay
- Deterministic model
- Stochastic model
- Relation between stochastic and deterministic models
- Generalization of the radioactive decay modeling
- Chemical kinetics
- Irreversible reaction of two substances
- Reversible reaction of two substances
- Irreversible reaction of two substances into a third
- A biochemical reaction
- Spreading of diseases
- Predator-prey models in ecology
- Decay of atmospheric pressure with altitude
- The general model
- Multiple atmospheric layers
- Simplifications
- Constant layer temperature
- One-layer model
- Compaction of sediments
- Vertical motion of a body in a viscous fluid
- Overview of forces
- Equation of motion
- Terminal velocity
- A Crank-Nicolson scheme
- Physical data
- Verification
- Scaling
- Viscoelastic materials
- Decay ODEs from solving a PDE by Fourier expansions
- Exercises
- Problem 4.1: Radioactive decay of Carbon-14
- Exercise 4.2: Derive schemes for Newton's law of cooling
- Exercise 4.3: Implement schemes for Newton's law of cooling
- Exercise 4.4: Find time of murder from body temperature
- Exercise 4.5: Simulate an oscillating cooling process
- Exercise 4.6: Simulate stochastic radioactive decay
- Problem 4.7: Radioactive decay of two substances
- Exercise 4.8: Simulate a simple chemical reaction
- Exercise 4.9: Simulate an $ n $-th order chemical reaction
- Exercise 4.10: Simulate a biochemical process
- Exercise 4.11: Simulate spreading of a disease
- Exercise 4.12: Simulate predator-prey interaction
- Exercise 4.13: Simulate the pressure drop in the atmosphere
- Exercise 4.14: Make a program for vertical motion in a fluid
- Project 4.15: Simulate parachuting
- Exercise 4.16: Formulate vertical motion in the atmosphere
- Exercise 4.17: Simulate vertical motion in the atmosphere
- Problem 4.18: Compute $ y=|x| $ by solving an ODE
- Problem 4.19: Simulate fortune growth with random interest rate
- Exercise 4.20: Simulate a population in a changing environment
- Exercise 4.21: Simulate logistic growth
- Exercise 4.22: Rederive the equation for continuous compound interest
- Exercise 4.23: Simulate the deformation of a viscoelastic material
- Scientific software engineering
- Implementations with functions and modules
- Mathematical problem and solution technique
- A first, quick implementation
- A more decent program
- Comments in a program
- Refactoring into functions
- Program file vs IDE vs notebook
- Prefixing imported functions by the module name
- Implementing the numerical algorithm in a function
- Do not have several versions of a code
- Making a module
- Example on extending the module code
- Documenting functions and modules
- Logging intermediate results
- Introductory example
- Using a logger in our solver function
- User interfaces
- Command-line arguments
- Positional command-line arguments
- Option-value pairs on the command line
- Creating a graphical web user interface
- Making a compute function
- Generating the user interface
- Running the web application
- Tests for verifying implementations
- Doctests
- Unit tests and test functions
- Two Python test frameworks: nose and pytest
- Test function requirements
- Comparison of real numbers
- Special assert functions from nose
- Locating test functions
- Running tests
- Embedding doctests in a test function
- Installing nose and pytest
- Test function for the solver
- Test function for reading positional command-line arguments
- Test function for reading option-value pairs
- Classical class-based unit testing
- Sharing the software with other users
- Organizing the software directory tree
- Distributing just a module file
- Distributing a package
- Publishing the software at GitHub
- Downloading and installing the software
- Installing just a module file
- Installing a package
- Classes for problem and solution method
- The problem class
- The solver class
- Combining the objects
- Improving the problem and solver classes
- A generic class for parameters
- Automating scientific experiments
- Available software
- The results we want to produce
- Combining plot files
- Running a program from Python
- The automating script
- Making a report
- Word, OpenOffice, GoogleDocs
- HTML with MathJax
- LaTeX
- Sphinx
- Markdown
- IPython/Jupyter notebooks
- Wiki formats
- DocOnce
- Publishing a complete project
- Exercises
- Problem 5.1: Make a tool for differentiating curves
- Problem 5.2: Make solid software for the Trapezoidal rule
- Problem 5.3: Implement classes for the Trapezoidal rule
- Problem 5.4: Write a doctest and a test function
- Problem 5.5: Investigate the size of tolerances in comparisons
- Remarks
- Exercise 5.6: Make use of a class implementation
- Problem 5.7: Make solid software for a difference equation
- Summarizing multiple-choice questions
- Quiz
- Exercise 6.1: Characterize a finite difference
- Exercise 6.2: Characterize a finite difference
- Exercise 6.3: What is the problem with this program?
- Exercise 6.4: Is the solution correct?
- Exercise 6.5: Is this a proper test function?
- Exercise 6.6: Rewrite an expression with array arithmetics
- Exercise 6.7: What is the truncation error?
- Exercise 6.8: Recognize a programming language
- Exercise 6.9: Recognize a programming language
- Exercise 6.10: Recognize a programming language
- Exercise 6.11: Recognize a programming language
- Exercise 6.12: What is SymPy?
- Exercise 6.13: Testing of code
- Exercise 6.14: What kind of scheme is this?
- Exercise 6.15: What kind of scheme is this?
- Exercise 6.16: What kind of scheme is this?
- References

References

L. N. Trefethen. Trefethen's index cards - Forty years of notes about People, Words and Mathematics, World Scientific, 2011.
H. P. Langtangen. A Primer on Scientific Programming with Python, fourth edition, Texts in Computational Science and Engineering, Springer, 2014.
J. D. Hunter, D. Dale, E. Firing and M. Droettboom. Matplotlib documentation, 2012, \urlhttp://matplotlib.org/users/, http://matplotlib.org/users/.
H. P. Langtangen. SciTools documentation, \urlhttp://hplgit.github.io/scitools/doc/web/index.html, http://hplgit.github.io/scitools/doc/web/index.html.
W. Gander, M. J. Gander and F. Kwok. Scientific Computing - An Introducting Using Maple and MATLAB, Texts in Computational Science and Engineering, Springer, 2015.
L. Petzold and U. M. Ascher. Computer Methods for Ordinary Differential Equations and Differential-Algebraic Equations, SIAM, 1998.
D. Griffiths, F. David and D. J. Higham. Numerical Methods for Ordinary Differential Equations: Initial Value Problems, Springer, 2010.
E. Hairer, S. P. N\orsett and G. Wanner. Solving Ordinary Differential Equations I. Nonstiff Problems, Springer, 1993.
G. Hairer and E. Wanner. Solving Ordinary Differential Equations II, Springer, 2010.
H. P. Langtangen and L. Wang. Odespy Software Package, \urlhttps://github.com/hplgit/odespy, https://github.com/hplgit/odespy.
H. P. Langtangen and G. K. Pedersen. Scaling of Differential Equations, SimulaSpringerBrief, Springer, 2015, \urlhttp://tinyurl.com/qfjgxmf/web, http://tinyurl.com/qfjgxmf/web.
D. B. Meade and A. A. Struthers. Differential Equations in the New Millenium: the Parachute Problem, International Journal of Engineering Education, 15(6), pp. 417-424, 1999, http://www.matematicas.unam.mx/gfgf/ode/ode_files/parachute.pdf.
H. P. Langtangen. Quick Intro to Version Control Systems and Project Hosting Sites, \urlhttp://hplgit.github.io/teamods/bitgit/html/, http://hplgit.github.io/teamods/bitgit/html/.