Chapter 23 — Further Reading

Where to go deeper on numerical ODEs and their Fortran practice. Grouped by purpose; start with the suggested order at the end.

The canonical numerical-methods texts

• Press, Teukolsky, Vetterling & Flannery, Numerical Recipes (3rd ed., Cambridge). Chapter 17 ("Integration of Ordinary Differential Equations") is the standard practical treatment of Euler, Runge-Kutta, adaptive step control, and stiff solvers, with real code. Older editions ship Fortran 77 and Fortran 90 versions of every routine — worth reading as legacy examples even as you write modern Fortran.
• Hairer, Nørsett & Wanner, Solving Ordinary Differential Equations I: Nonstiff Problems (Springer), and Volume II: Stiff and Differential-Algebraic Problems. The definitive scholarly reference. Volume I is the authority on Runge-Kutta methods and error control; Volume II is the book on stiffness. The authors' dopri5 and radau Fortran codes are widely used production integrators.
• Ascher & Petzold, Computer Methods for Ordinary Differential Equations and Differential-Algebraic Equations (SIAM). A clear, modern graduate treatment that connects ODE methods to the method of lines and PDEs — exactly the bridge this chapter builds toward Chapter 24.

Free and online

• fortran-lang.org — Fortran standard library (stdlib). The community standard library's numerical modules are the modern, fpm-installable place to get vetted routines; consult its documentation before writing your own production integrator.
• Netlib ODEPACK (www.netlib.org/odepack). The classic public-domain Fortran ODE suite — lsode/lsoda are battle-tested adaptive solvers that switch between nonstiff and stiff methods automatically. Reading lsoda's interface is a lesson in what a real solver's API looks like.
• SUNDIALS (computing.llnl.gov/projects/sundials). Lawrence Livermore's modern successor to ODEPACK (CVODE, IDA, ARKODE), with a documented Fortran 2003 interface. The state of the art for large-scale and stiff systems.
• GCC/gfortran documentation (gcc.gnu.org/onlinedocs/gfortran). The reference for the abstract interface, procedure dummy arguments, and array-valued functions this chapter leans on.

Primary sources

• ISO/IEC 1539-1:2018 (the Fortran standard). The normative definition of procedure pointers, abstract interfaces, and assumed-shape arguments — the machinery behind a model-agnostic solver.
• Dormand & Prince, "A family of embedded Runge-Kutta formulae," J. Comput. Appl. Math. 6 (1980). The paper behind dopri5, ode45, and SciPy's default solve_ivp — the embedded pair mentioned in §23.3.

Tools

• SciPy solve_ivp documentation. Even if you write Fortran, read it: it is the clearest modern catalogue of methods (RK45, RK23, DOP853, Radau, BDF, LSODA) and when to choose each. The Fortran you write here is what its fast paths ultimately call.
• Compiler Explorer (godbolt.org). Paste an rk4_sys and watch the compiler vectorize the whole-array stage arithmetic — the performance payoff of writing stages as array operations.

Suggested order

1. Skim Numerical Recipes Ch. 17 for the practical landscape (Euler → RK4 → adaptive → stiff).
2. Read the SciPy solve_ivp method list to see how those choices are packaged for a user.
3. Study ODEPACK's lsoda interface (or SUNDIALS' ARKODE) to see a production Fortran solver's API.
4. For depth on error control and stiffness, go to Hairer, Nørsett & Wanner — Volume I first, then II.
5. Keep the fortran-lang stdlib docs open as your modern, installable default.