# Programming for Computations (Python version)¶

Contents:

- Programming for Computations (Python version)
- Preface
- The first few steps
- What is a program? And what is programming?
- A Python program with variables
- A Python program with a library function
- A Python program with vectorization and plotting
- More basic concepts
- 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: Peculiar results from division
- Exercise 8: Update variable at command prompt
- Exercise 9: Formatted print to screen
- Exercise 10: Python documentation and random numbers

- Basic constructions
- If tests, colon and indentation
- Functions
- For loops
- While loops
- Lists and tuples - alternatives to arrays
- Reading from and writing to files
- Exercises
- Exercise 11: Errors with colon, indent, etc.
- Exercise 12: Compare integers a and b
- Exercise 13: Functions for circumference and area of a circle
- Exercise 14: Function for area of a rectangle
- Exercise 15: Area of a polygon
- Exercise 16: Average of integers
- Exercise 17: While loop with errors
- Exercise 18: Area of rectangle versus circle
- Exercise 19: Find crossing points of two graphs
- Exercise 20: Sort array with numbers
- Exercise 21: Compute \(\pi\)
- Exercise 22: Compute combinations of sets
- Exercise 23: Frequency of random numbers
- Exercise 24: Game 21
- Exercise 25: Linear interpolation
- Exercise 26: Test straight line requirement
- Exercise 27: Fit straight line to data
- Exercise 28: Fit sines to straight line
- Exercise 29: Count occurrences of a string in a string

- Computing integrals
- Basic ideas of numerical integration
- The composite trapezoidal rule
- The composite midpoint method
- Testing
- Vectorization
- Measuring computational speed
- Double and triple integrals
- Derivation via one-dimensional integrals
- Direct derivation
- Programming a double sum
- Reusing code for one-dimensional integrals
- Verification via test functions
- Theory
- Implementation
- The Monte Carlo integration algorithm
- Implementation
- Verification
- Test function for function with random numbers
- Integral over a circle

- Exercises

- 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
- More effects: damping, nonlinearity, and external forces
- 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 44: Geometric construction of the Forward Euler method
- Exercise 45: Make test functions for the Forward Euler method
- Exercise 46: Implement and evaluate Heun’s method
- Exercise 47: Find an appropriate time step; logistic model
- Exercise 48: Find an appropriate time step; SIR model
- Exercise 49: Model an adaptive vaccination campaign
- Exercise 50: Make a SIRV model with time-limited effect of vaccination
- Exercise 51: Refactor a flat program
- Exercise 52: Simulate oscillations by a general ODE solver
- Exercise 53: Compute the energy in oscillations
- Exercise 54: Use a Backward Euler scheme for population growth
- Exercise 55: Use a Crank-Nicolson scheme for population growth
- Exercise 56: Understand finite differences via Taylor series
- Exercise 57: Use a Backward Euler scheme for oscillations
- Exercise 58: Use Heun’s method for the SIR model
- Exercise 59: Use Odespy to solve a simple ODE
- Exercise 60: Set up a Backward Euler scheme for oscillations
- Exercise 61: Set up a Forward Euler scheme for nonlinear and damped oscillations
- Exercise 62: Discretize an initial condition

- Population growth
- Solving partial differential equations
- Finite difference methods
- Exercises
- Exercise 63: Simulate a diffusion equation by hand
- Exercise 64: Compute temperature variations in the ground
- Exercise 65: Compare implicit methods
- Exercise 66: Explore adaptive and implicit methods
- Exercise 67: Investigate the \(\theta\) rule
- Exercise 68: Compute the diffusion of a Gaussian peak
- Exercise 69: Vectorize a function for computing the area of a polygon
- Exercise 70: Explore symmetry
- Exercise 71: Compute solutions as \(t\rightarrow\infty\)
- Exercise 72: Solve a two-point boundary value problem

- Solving nonlinear algebraic equations
- Brute force methods
- Newton’s method
- The secant method
- The bisection method
- Rate of convergence
- Solving multiple nonlinear algebraic equations
- Exercises
- Exercise 73: Understand why Newton’s method can fail
- Exercise 74: See if the secant method fails
- Exercise 75: Understand why the bisection method cannot fail
- Exercise 76: Combine the bisection method with Newton’s method
- Exercise 77: Write a test function for Newton’s method
- Exercise 78: Solve nonlinear equation for a vibrating beam

- Appendix: Getting access to Python
- References