$$ \newcommand{\Oof}[1]{\mathcal{O}(#1)} \newcommand{\F}{\boldsymbol{F}} \newcommand{\J}{\boldsymbol{J}} \newcommand{\x}{\boldsymbol{x}} \renewcommand{\c}{\boldsymbol{c}} $$

Contents
- Preface
- Why learn programming?
- Target audience and background knowledge
- Numerical methods
- The computer language: Matlab
- How this book is different
- Supplementary materials
- Acknowledgments
- The first few steps
- What is a program? And what is programming?
- A Matlab program with variables
- The program
- Dissection of the program
- Why not just use a pocket calculator?
- Why you must use a text editor to write programs
- Write and run your first program
- Write and run a program in Matlab
- Write a program in a text editor and run it in Octave
- A Matlab program with a library function
- A Matlab program with vectorization and plotting
- More basic concepts
- Using Matlab interactively
- Arithmetics, parentheses and rounding errors
- Variables
- Formatting text and numbers
- Arrays
- Plotting
- Error messages and warnings
- Input data
- Symbolic computations
- Concluding remarks
- Exercises
- Exercise 1: Error messages
- Exercise 2: Volume of a cube
- Exercise 3: Area and circumference of a circle
- Exercise 4: Volumes of three cubes
- Exercise 5: Average of integers
- Exercise 6: Interactive computing of volume and area
- Exercise 7: Update variable at command prompt
- Exercise 8: Formatted print to screen
- Exercise 9: Matlab documentation and random numbers
- Basic constructions
- If tests
- Functions
- For loops
- While loops
- Reading from and writing to files
- Exercises
- Exercise 10: Introducing errors
- Exercise 11: Compare integers a and b
- Exercise 12: Functions for circumference and area of a circle
- Exercise 13: Function for area of a rectangle
- Exercise 14: Area of a polygon
- Exercise 15: Average of integers
- Exercise 16: While loop with errors
- Exercise 17: Area of rectangle versus circle
- Exercise 18: Find crossing points of two graphs
- Exercise 19: Sort array with numbers
- Exercise 20: Compute \( \pi \)
- Exercise 21: Compute combinations of sets
- Exercise 22: Frequency of random numbers
- Remarks
- Exercise 23: Game 21
- Exercise 24: Linear interpolation
- Exercise 25: Test straight line requirement
- Exercise 26: Fit straight line to data
- Remarks
- Exercise 27: Fit sines to straight line
- Remarks
- Exercise 28: Count occurrences of a string in a string
- Computing integrals
- Basic ideas of numerical integration
- Computational example
- The composite trapezoidal rule
- The general formula
- Implementation
- Specific or general implementation?
- Implementation with functions
- Solving our specific problem in a session
- Solving our specific problem in a program
- Alternative flat special-purpose implementation
- The composite midpoint method
- The idea
- The general formula
- Implementation
- Comparing the trapezoidal and the midpoint methods
- Testing
- Problems with brief testing procedures
- Proper test procedures
- Hand-computed results
- Solving a problem without numerical errors
- Demonstrating correct convergence rates
- Finite precision of floating-point numbers
- Constructing unit tests and writing test functions
- Hand-computed numerical results
- Solving a problem without numerical errors
- Demonstrating correct convergence rates
- Vectorization
- Vectorizing the midpoint rule
- Vectorizing the trapezoidal rule
- Measuring computational speed
- Double and triple integrals
- The midpoint rule for a double integral
- Derivation via one-dimensional integrals
- Direct derivation
- Programming a double sum
- Reusing code for one-dimensional integrals
- Verification via test functions
- The midpoint rule for a triple integral
- Theory
- Implementation
- Monte Carlo integration for complex-shaped domains
- The Monte Carlo integration algorithm
- Implementation
- Verification
- Test function for function with random numbers
- Integral over a circle
- Exercises
- Exercise 29: Hand calculations for the trapezoidal method
- Exercise 30: Hand calculations for the midpoint method
- Exercise 31: Compute a simple integral
- Exercise 32: Hand-calculations with sine integrals
- Exercise 33: Make test functions for the midpoint method
- Exercise 34: Explore rounding errors with large numbers
- Exercise 35: Write test functions for \( \int_0^4\sqrt{x}dx \)
- Remarks
- Exercise 36: Rectangle methods
- Exercise 37: Adaptive integration
- Remarks
- Exercise 38: Integrating x raised to x
- Exercise 39: Integrate products of sine functions
- Exercise 40: Revisit fit of sines to a function
- Exercise 41: Derive the trapezoidal rule for a double integral
- Exercise 42: Compute the area of a triangle by Monte Carlo integration
- Solving ordinary differential equations
- Population growth
- Derivation of the model
- Numerical solution
- Programming the Forward Euler scheme; the special case
- Understanding the Forward Euler method
- Programming the Forward Euler scheme; the general case
- Making the population growth model more realistic
- Verification: exact linear solution of the discrete equations
- Spreading of diseases
- Spreading of a flu
- A Forward Euler method for the differential equation system
- Programming the numerical method; the special case
- Outbreak or not
- Abstract problem and notation
- Programming the numerical method; the general case
- Time-restricted immunity
- Incorporating vaccination
- Discontinuous coefficients: a vaccination campaign
- Oscillating one-dimensional systems
- Derivation of a simple model
- Numerical solution
- Programming the numerical method; the special case
- A magic fix of the numerical method
- The 2nd-order Runge-Kutta method (or Heun's method)
- Software for solving ODEs
- The 4th-order Runge-Kutta method
- The algorithm
- Application
- Implementation
- Derivation
- More effects: damping, nonlinearity, and external forces
- The Euler-Cromer scheme
- The 4-th order Runge-Kutta method
- Illustration of linear damping
- Illustration of linear damping with sinusoidal excitation
- Spring-mass system with sliding friction
- A finite difference method; undamped, linear case
- A finite difference method; linear damping
- Exercises
- Exercise 43: Geometric construction of the Forward Euler method
- Exercise 44: Make test functions for the Forward Euler method
- Exercise 45: Implement and evaluate Heun's method
- Exercise 46: Find an appropriate time step; logistic model
- Exercise 47: Find an appropriate time step; SIR model
- Exercise 48: Model an adaptive vaccination campaign
- Exercise 49: Make a SIRV model with time-limited effect of vaccination
- Exercise 50: Refactor a flat program
- Exercise 51: Simulate oscillations by a general ODE solver
- Exercise 52: Compute the energy in oscillations
- Exercise 53: Use a Backward Euler scheme for population growth
- Exercise 54: Use a Crank-Nicolson scheme for population growth
- Exercise 55: Understand finite differences via Taylor series
- Exercise 56: Use a Backward Euler scheme for oscillations
- Remarks
- Exercise 57: Use Heun's method for the SIR model
- Exercise 58: Use Odespy to solve a simple ODE
- Exercise 59: Set up a Backward Euler scheme for oscillations
- Exercise 60: Set up a Forward Euler scheme for nonlinear and damped oscillations
- Exercise 61: Discretize an initial condition
- Solving partial differential equations
- Finite difference methods
- Reduction of a PDE to a system of ODEs
- Construction of a test problem with known discrete solution
- Implementation: Forward Euler method
- Application: heat conduction in a rod
- Vectorization
- Using Odespy to solve the system of ODEs
- Implicit methods
- Exercises
- Exercise 62: Simulate a diffusion equation by hand
- Exercise 63: Compute temperature variations in the ground
- Exercise 64: Compare implicit methods
- Exercise 65: Explore adaptive and implicit methods
- Exercise 66: Investigate the \( \theta \) rule
- Remarks
- Exercise 67: Compute the diffusion of a Gaussian peak
- Remarks
- Exercise 68: Vectorize a function for computing the area of a polygon
- Exercise 69: Explore symmetry
- Remarks
- Exercise 70: Compute solutions as \( t\rightarrow\infty \)
- Remarks
- Exercise 71: Solve a two-point boundary value problem
- Solving nonlinear algebraic equations
- Brute force methods
- Brute force root finding
- Numerical algorithm
- Implementation
- Brute force optimization
- Numerical algorithm
- Implementation
- Model problem for algebraic equations
- Newton's method
- Deriving and implementing Newton's method
- Making a more efficient and robust implementation
- The secant method
- The bisection method
- Rate of convergence
- Solving multiple nonlinear algebraic equations
- Abstract notation
- Taylor expansions for multi-variable functions
- Newton's method
- Implementation
- Exercises
- Exercise 72: Understand why Newton's method can fail
- Exercise 73: See if the secant method fails
- Exercise 74: Understand why the bisection method cannot fail
- Exercise 75: Combine the bisection method with Newton's method
- Exercise 76: Write a test function for Newton's method
- Exercise 77: Solve nonlinear equation for a vibrating beam
- References

Programming for Computations - A Gentle Introduction to Numerical Simulations with MATLAB/Octave

Svein Linge [1, 2] Hans Petter Langtangen [2, 3]

[1] Department of Process, Energy and Environmental Technology, University College of Southeast Norway [2] Center for Biomedical Computing, Simula Research Laboratory [3] Department of Informatics, University of Oslo

This text teaches computer programming as a method for solving mathematical problems. There are two versions of this book, one for the MATLAB and one for Python. While it was inspired by the Springer text TCSE6: A Primer on Scientific Programming with Python (by Langtangen), its exposition is more accessible, simpler, and much shorter and aimed at engineering students. The authors have outlined the shortest possible path from zero knowledge about programming to a set of skills that will allow the students in engineering and science courses to write simple programs for solving common mathematical problems by numerical methods. This text places great emphasis on generic algorithms, clean program designs, function use, and automatic tests for verification.

Feb 29, 2016