Fortran 2018 is a minor revision of Fortran 2008. Most new features in Fortran 2018 are defined in two Technical Specification (TS) documents:
Current F2018 Working Document as of April 2018: Fortran 2018 Draft International Standard for Ballot (ISO/IEC JTC1/SC22/WG5 N2146)
The new planned features and changes in Fortran 2018 are also summarized by John Reid in a report titled The new features of Fortran 2018 (ISO/IEC JTC1/SC22/WG5 N2145).
Fortran compilers that support fpp
or cpp
generally define preprocessor macros that can be used to adapt code based on compiler-dependent features.
Below are examples for some compilers that support fpp
or cpp
. Eventually, this could be expanded to show values for different host architectures and compilation options. For example, a compiler may define _OPENMP
when compiled to support OpenMP.
Unfortunately, there is no common convention for the information supplied, and they do not define the Fortran language revision.
Uses a built-in cpp
in traditional mode with the flag -cpp
. You can determine the predefined macros by using the preprocess-only flag -E
and the cpp
flag -dM
, for example:
gfortran -cpp -E -dM empty.f90
The following macros are predefined in version 4.8 on x86_64-linux-gnu (sorted alphabetically):
#define __ATOMIC_ACQ_REL 4
#define __ATOMIC_ACQUIRE 2
#define __ATOMIC_CONSUME 1
#define __ATOMIC_RELAXED 0
#define __ATOMIC_RELEASE 3
#define __ATOMIC_SEQ_CST 5
#define __BIGGEST_ALIGNMENT__ 16
#define __BYTE_ORDER__ __ORDER_LITTLE_ENDIAN__
#define __CHAR_BIT__ 8
#define __FINITE_MATH_ONLY__ 0
#define __FLOAT_WORD_ORDER__ __ORDER_LITTLE_ENDIAN__
#define __GFORTRAN__ 1
#define __GNUC__ 4
#define __GNUC_MINOR__ 8
#define __GNUC_PATCHLEVEL__ 5
#define _LANGUAGE_FORTRAN 1
#define __LP64__ 1
#define _LP64 1
#define __ORDER_BIG_ENDIAN__ 4321
#define __ORDER_LITTLE_ENDIAN__ 1234
#define __ORDER_PDP_ENDIAN__ 3412
#define __SIZEOF_DOUBLE__ 8
#define __SIZEOF_FLOAT__ 4
#define __SIZEOF_INT__ 4
#define __SIZEOF_LONG__ 8
#define __SIZEOF_LONG_DOUBLE__ 16
#define __SIZEOF_LONG_LONG__ 8
#define __SIZEOF_POINTER__ 8
#define __SIZEOF_SHORT__ 2
#define __SIZEOF_SIZE_T__ 8
#define __STDC_HOSTED__ 0
#define __VERSION__ "4.8.5"
Invokes fpp
externally when given the option -fpp
or -cpp
. You can determine the predefined macros via:
ifx -E -fpp empty.f90 -dryrun 2>&1 | perl -lne 'print for /-D(\S+)/'
The following macros are predefined:
#define __INTEL_COMPILER 1100
#define __INTEL_COMPILER_BUILD_DATE 20081105
#define _MT 1
#define __ELF__ 1
#define __PTRDIFF_TYPE__ long
#define __SIZE_TYPE__ unsigned long
#define __WCHAR_TYPE__ int
#define __WINT_TYPE__ unsigned int
#define __INTMAX_TYPE__ long int
#define __UINTMAX_TYPE__ long unsigned int
#define __LONG_MAX__ 9223372036854775807L
#define __unix__ 1
#define __unix 1
#define __linux__ 1
#define __linux 1
#define __gnu_linux__ 1
#define unix 1
#define linux 1
#define __x86_64 1
#define __x86_64__ 1
Invokes fpp
externally when given the option -fpp
. It can also invoke an external cpp
. The following macros are predefined:
#define __SUNPRO_F90 0x830
#define __SUNPRO_F95 0x830
#define unix 1
#define __unix 1
#define __unix__ 1
#define __linux 1
#define __linux__ 1
#define linux 1
#define __gnu__linux__ 1
#define i386 1
#define __i386 1
This page is for linking to available Fortran libraries and source code repositories. See Software repositories for collections of libraries and see Library distribution for methods for packaging and distributing Fortran libraries. Awesome Fortran is another list of libraries.
Libraries linked here are classified as follows:
When available, the above tags should link to the license page for a particular library.
Fortran Standard Library - Utilities (containers, strings, files, OS/environment integration, unit testing & assertions, logging, …) Algorithms (searching and sorting, merging, …) Mathematics (linear algebra, sparse matrices, special functions, fast Fourier transform, random numbers, statistics, ordinary differential equations, numerical integration, optimization, …)(OS: MIT)
BeFoR64 - Base64 encoding/decoding library for FoRtran poor men, is a pure Fortran (KISS) library for base64 encoding/decoding for modern (2003+) Fortran projects. (OS: GPL)
coretran - easy-to-follow library to make Fortran easier in general with wrapped interfaces, sorting routines, kD-Trees, and other algorithms to handle scientific data and concepts.
erloff - make error-handling in Fortran a bit more flexible (OS: MIT)
fdict - native Fortran 90 dictionary with hash tables for retaining any data-type in a Python-like dictionary. (OS: MPL-2)
ferror - library to assist with error handling in Fortran projects.
ffhash generic and fast hash table similar to khash in C, by Jannis Teunissen.
FGSL - Fortran interface to the GNU Scientific Library. (OS: GPL)
FIAT - Fortran Implementation of Abstract Types
flib - standard library, function library, a tridiagonal matrix solver, and code for a doubly linked list, optimization, and interpolation. (OS: GPL-3.0 License)
FLIBS - collection of Fortran modules by Arjen Markus and Michael Baudin. (OS: BSD)
flink - Flexible Fortran Modules and Subroutines for Scientific Computing. (OS: GPL-3.0 License)
Focal - modern Fortran module library which wraps calls to the OpenCL runtime API with a higher abstraction level appropriate to the Fortran language. (OS: MIT)
forpy - use Python in Fortran and vice versa. (OS:LGPL)
FortranCL - Fortran interface for OpenCL, allows to execute code on GPUs and accelerators directly from Fortran. (OS: LGPL)
FortCUDA - Fortran interface to the CUDA GPU library. Contains a Python pre-processor to parse the CUDA C headers and creates ISO_C_BINDING interfaces for the method calls. Comes with a fairly complex example. (OS: GPL)
Fortran exceptions library - provides exception handling for Fortran 2003 and later, based on the methodology of Poppe et al. 2012 (OS: MIT)
fortranlib - Collection of personal scientific routines in Fortran. (OS: BSD-2-Clause License)
Fortran-Library - Code for geometry transformations, nonlinear optimization, Fourier transforms, clustering, statistics, mathematics, linear algebra, strings, and chemistry. (OS: GPL-3.0 License)
fortran_notes - containers and advanced data structures, hash functions, and design patterns (OS: MIT)
Fortran Template Library (FTL) - generic containers, versatile algorithms, easy string manipulation, and more. (OS: GPL-3)
Fortran Template Library (FTL) - Object oriented implementation of generic containers similar to the C++ STL (Standard Template Library) in native Fortran 2003. (OS: LGPL-3)
fortran-utils - Various utilities for Fortran programs, including types, constants, sorting, saving/loading 2D arrays, meshes, cubic splines, saving/loading PPM images, Lapack interface, HDF5 interface, special functions, and optimization, by Ondrej Certik et al.
ForUtils - Fortran 2008 utility functions and reusable classes
FTObjectLibrary - provides a collection of reference counted Fortran 2003 classes to facilitate writing generic object oriented Fortran programs (OS: MIT)
functional-fortran - library for functional programming in modern Fortran. (OS: BSD)
fycollections - generic collection templates for Fortran
IMSL - most comprehensive mathematics and statistics library available. (C)
JAMS - collection of general Fortran modules offering miscellaneous functions in the categories Computational, Date and Time, Input / Output, Math / Numerics, Screening, Sensitivity Analysis and Optimising / Fitting, and Miscellaneous. Written by Matthias Cuntz, Juliane Mai and Stephan Thober. (OS: MIT)
jsonff - Fortran library for dealing with JSON data (OS: MIT)
json-fortran - Fortran 2003/2008 JSON API. (OS: BSD)
kdtree2 - kd-tree implementation in C++ (and Fortran) by Matthew B. Kennel
libGPF - General Purpose Fortran Collection. Updated at GitHub.(OS: MIT)
NAG - world’s largest collection of robust, documented, tested and maintained numerical algorithms for users of the Fortran programming language. (C)
NEC Numeric Library Collection - collection of mathematical libraries that powerfully supports the development of numerical simulation programs in a wide range of fields. The libraries are available on Vector Engine. (C)
NPY-for-Fortran allows the developer to save Fortran arrays in Numpy’s .npy format. (OS:MIT)
parff - (almost) functional style parser combinator library for Fortran (OS: MIT)
PENF - Fortran (standard 2003) module useful to achieve portable codes. The module makes available portable kind-parameters and some useful procedures to deal with them. (OS: GPL)
petaca - collection of modern Fortran modules that provide broadly useful capabilities – things that the author has found himself using repeatedly across many projects. A unifying feature of the modules is their object-oriented interfaces and implementation. (OS:MIT)
qContainers - container library for Fortran language. It enables to store any internal Fortran data type and any derived data type to the container. It implements containers for key/value pairs: tree table and hash table, and containers for objects: list and vector. (OS: BSD)
Processor - F95 compliant general purpose library version 1.8.6 with HTML documentation. Covers string/array manipulations, stacks, hashes, noise, interpolation, smoothing, physical constants, and dates. Includes wrapper modules for several OS/compiler combinations for specific system access functions.(OS: LGPL)
S-EXPTRAN - Fortran library for reading and writing S-expressions. (OS: MIT)
VectorClass Fortran 2003 dynamic memory array that functions similarly (but not identically) to the C++ Vector class, by Tyler Chang. (OS: MIT)
Fortran Character String Utilities - library of string manipulation routines by George Benthien
fortran_pcre - Fortran wrapper around the C PCRE regular expression library. (OS:MIT)
iso_varying_string - implementation of the ISO standard for varying strings (OS: MIT)
M_strings - modules for processing strings. Routines for parsing, tokenizing, changing case, substituting new strings for substrings, locating strings with simple wildcard expressions, removing tabs and line terminators and other string manipulations are included. (OS)
strff - library of convenient string functions (OS: MIT)
afnl - Fortran 90 numerical library with modules for numerical types, constants, error handling, integration, optimization, linear algebra, sorting and search, special functions, statistics, polynomials, root-finding, Fourier transforms, and dates and times, by Alberto Ramos (OS: GPL-2.0 License)
ARPREC - C++/Fortran 90 library for arbitrary precision math. Includes a complete interactive high-precision arithmetic computing interpreter (“toolkit”) written in Fortran, that will integrate symbolic expressions etc. (OS: BSD)
CERNLIB - collection of FORTRAN 77 libraries and modules maintained by CERN. (OS: GPL)
datapac - Fortran 77 statistical library written by James Filliben (at NIST) (PD)
DATAPLOT - powerful and flexible program for performing scientific, engineering, statistical, mathematical, and graphical analysis. At GitHub
Emmix Fits a mixture model of multivariate normal or t-distributions to a user supplied data set via the EM algorithm. With gfortran, must be compiled with -std=legacy option.
faiNumber-Fortran - A fast, flexible, and secure numerical library for Fortran with fast number parsing as one of its features. (OS: MIT)
FMLIB - David M. Smith’s libraries for multiple precision computation. The package performs multiple-precision real, complex, and integer arithmetic, providing the intrinsic Fortran numerical functions, as well as many special functions. An existing Fortran program can be checked by converting it from double precision to FM arithmetic. (NC)
forSISL - Modern Fortran interfaces to the SINTEF Spline Library (SISL)
FURY - Fortran Units (environment) for Reliable phYsical math, by Stefano Zaghi
GMP Fortran library - Fortran binding for GNU Multiple Precision Arithmetic library.
HSL Mathematical Software Library - free for academic use.
lookup_table_fortran A module for linear lookup tables. Supports multiple columns and various ways to read values from the table.
MP - Fortran multiple-precision arithmetic package by Richard Brent.
MPFUN2020 - thread-safe arbitrary precision package by David H. Bailey
MPFUN90 (broken link) - a pure Fortran 90 library for arbitrary precision math. Includes a complete interactive high-precision arithmetic computing interpreter (“toolkit”) written in Fortran, that will integrate symbolic expressions etc. (OS: BSD)
Muesli - A free numerical and graphical Fortran 95 library written by Edouard Canot at Univ of Rennes (?)
National Wind Technology Center Subroutine Library - A library of general-use Fortran 2003 routines used in many NWTC computer-aided engineering tools (OS: GPL)
NumDiff - A modern Fortran numerical differentiation library by Jacob Williams (OS: BSD).
NumericalHUB - Set of modern Fortran numerical libraries covering: zeroes of Systems of Equations, Lagrange Interpolation, Finite Differences, Cauchy Problems, Boundary Value Problems, and Initial Boundary Value Problems, associated with book How to learn Applied Mathematics through modern FORTRAN
Numerical methods in Fortran - solving linear, nonlinear equations, integral, ordinary differential equations, … using numerical methods in Fortran, by Carlos Planelles Alemany
Numerical methods in Fortran - numerical analysis and statistics algorithms, by Murat Koptur.
Numerical Methods for Scientists and Engineers, code in Fortran 77 and C from book by H. M. Antia (OS: GPL-2.0 License)
Numerical Methods of Statistics, Fortran 95 code from book by John Monahan.
SLATEC - Common Mathematical Library: a comprehensive software library containing over 1400 general purpose mathematical and statistical routines written in Fortran 77. (PD)
SLATEC - Fortran 90 version by John Burkardt. (?)
SLICOT - The Control and Systems Library (GPL)
starpac, Standards Time Series and Regressions Package in Fortran 77(PD), translated to Fortran 90 here.
stspac, A Fortran 77 statistical library written by Charlie Reeves (at NIST) (PD)
TOMS - code from the journal Transactions on Mathematical Software. Many programs were translated to Fortran 90 by Alan Miller and John Burkardt
physunits - Automated Computation and Consistency Checking of Physical Dimensions and Units in Scientific Programs, by Grant Petty
quaff - A library for making math with units a lot easier and more convenient (OS: MIT)
SciFortran - A library of fortran modules and routines for scientific calculations (in a way just like scipy for python). (OS: LGPL-3.0 License)
Simfit - package for simulation, statistical analysis, curve fitting and graph plotting, using models from a compiled library or from ASCII text files supplied by the user. Source code for over two hundred NAG library subroutines called by the Academic version of the Simfit package is available.
Tensor Toolbox for Modern Fortran (ttb)(OS: MIT License)
Freely Available Software for Linear Algebra (September 2018)
arpack-ng is a collection of Fortran77 subroutines designed to solve large scale eigenvalue problems.
BLAP95 (broken link) - a Fortran 95 interface to the Level 3 BLAS routines and key LAPACK computational and driver routines. (?)
BLAS: Basic Linear Algebra Subprograms that provide standard building blocks for performing basic vector and matrix operations (PD). Also OpenBLAS
DBCSR - Distributed Block Compressed Sparse Row matrix library (OS: GPL-2.0 License)
ELPA - Eigenvalue Solvers for Petaflop Applications (OS: LGPL-3.0)
LAPACK is the standard package for numerical linear algebra. (OS: BSD)
LIBXSMM - library for specialized dense and sparse matrix operations as well as for deep learning primitives such as small convolutions.
linalg - linear algebra library that provides a user-friendly interface to several BLAS and LAPACK routines. (OS:GPL-3.0 License)
Fortran_Davidson - Modern Fortran implementation of the Davidson diagonalization algorithms. (OS:Apache-2.0 License)
fortran_lsp - Fortran routines from “Solving Least Squares Problems” by C. Lawson and R. Hanson, with improved interfaces.
JADAMILU - computes eigenvectors of large sparse symmetric matrices. Provided as a precompiled library
MUMPS - parallel sparse direct solver
NTPoly - massively parallel library for computing the functions of sparse matrices.(OS: MIT License)
PROPACK - set of functions for computing the singular value decomposition of large and sparse or structured matrices. GitHub
PSBLAS3 - Parallel Sparse Basic Linear Algebra Subroutines (OS: BSD)
qrupdate - library for fast updates of QR and Cholesky decompositions.
qr_mumps - package for the solution of sparse, linear systems on multicore computers
Sparskit - basic tool-kit for sparse matrix computations (Version 2)
UMFPACK Fortran interface - mUMFPACK module provides a Fortran-2003 implementation of the full UMFPACK interface closely corresponding to that defined in the UMFPACK User Guide.
Alan Miller’s Fortran Software for subset selection in regression, random number generation, logistic regression, linear least squares, and other topics.
apstat, a collection of subroutines (AS1 - AS319) published in the journal Applied Statistics 1968-1994. Most are Fortran. Personal favourites include AS319 and AS164. Many have been translated to Fortran 90 by John Burkardt and Alan Miller
BMSL mathematical and statistical libraries, geared toward environmental / hydrological applications, by Ben Renard.
Climate time series analysis by Manfred Mudelsee.
CONFINT - sample size calculation for confidence intervals
datapac, A Fortran 77 statistical library written by James Filliben (at NIST) (PD)
Fast Statistical Methods, by Rybicki and Press.
Fortran Programs for Global Optimization, etc programs for econometric analysis such as Non-linear Least Squares, Robust Regression, Robust Two-Stage Least Squares, Ordinal Canonical Correlation, Ordinal Principal Component Analysis, Hybridization of canonical correlation and principal component analysis, fitting origin-displaced logarithmic spiral to data, solving the nearest correlation matrix problem, completing the correlation matrix, construction of composite indices by linear aggregation, etc. some of which are based on global optimization.
Least squares approximations in Fortran 90 by J-P Moreau. Also statistical programs in Fortran
MCMC f90 library - do Markov chain Monte Carlo simulation from a posterior distribution of unknown model parameters defined by a likelihood function and prior
MISCLIB, a library of statistical and support routines, written by Barry Brown (M.D.Anderson Cancer Institute) - open source
Modified Burg Algorithms in Multivariate Subset Autoregressive Modeling by A. Alexandre Trindade
MultiNest - Bayesian inference tool which calculates the evidence and explores the parameter space which may contain multiple posterior modes and pronounced (curving) degeneracies in moderately high dimensions, by Farhan Feroz and Mike Hobson
Multiple stream Mersenne Twister pseudorandom number generator (OS: BSD)
Multitaper Spectrum Estimation Library by Germán A. Prieto.
Multivariate Data Analysis Software in Fortran (and C) by Fionn Murtagh
Nonsmooth Clustering by Napsu Karmitsa. Also codes for regression and imputation
Oak Leaf - robust statistical estimates by Filip Hroch
ParaMonte - Plain Powerful Parallel Monte Carlo and MCMC Library for Python, MATLAB, Fortran, C++, C (OS: MIT License)
Random by Richard Brent. ranut is a uniform pseudo-random number generator which uses recurrences based on primitive trinomials, or in some cases trinomials which have large primitive factors (over the field GF(2)). rannw is a Fortran 77 pseudo-random number generator which uses a variant of Chris Wallace’s method to generate normally distributed (i.e. Gaussian) numbers.
RANDLIB - routines for nonuniform random number generation
rng_fortran, Fast pseudorandom number generator based on Xoroshiro128+. Supports OpenMP.
SLICE, efficient N-Dimensional Monte Carlo inversion algorithm.
STATPACK - Fortran 95/2003 library for solving the most commonly occurring mathematical and statistical problems in the processing of (huge) climate model outputs and datasets, and more generally in data analysis
stspac, A Fortran 77 statistical library written by Charlie Reeves (at NIST) (PD)
SEQBIN - Bayesian/Frequentist Designs for Sequential/Group-Sequential Trials of a Single Binomial Parameter
STPLAN - performs power, sample size, and related calculations needed to plan frequentist studies
TIMSAC package for analysis, prediction and control of time series
Applied Statistics algorithm 298 Hybrid minimization routine using simulated annealing and a user-supplied local minimizer.
Applied Statistics algorithm 319 Variable metric unconstrained function minimization without derivatives.
cobyla.f90 Mike Powell’s routine for minimization of non-linear functions with smooth non-linear constraints, using local linear approximations to the constraints.
conmin.zip The classic CONMIN package for constrained minimization updated to Fortran 90.
CUTEst - Constrained and Unconstrained Testing Environment with safe threads for optimization software
DualSimplex Fortran 90 module for solving linear programs of the form max c^T x s.t. A x <= b where, c is a cost vector and A x <= b is a system of linear inequality constraints, by Tyler Chang.
FilterSD - Fortran 77 subroutines for solving nonlinear programming problems and linearly constrained problems in continuous optimization
GALAHAD is a library of modern Fortran modules for nonlinear optimization. (OS: lgpl-3.0)
global.f90 At Arnold Neumaier’s site, this is recommended as the most successful of the global optimization packages.
libga - genetic algorithm optimisation library by Alberto Ramos
lm.zip Levenberg-Marquardt algorithm for non-linear least squares (unconstrained). This is a translation of the MINPACK routines, LMDER & LMDIF.
minim.f90 The Nelder-Mead simplex algorithm for unconstrained minimization. It does NOT require or use derivatives.
MINPACK contains routines for solving nonlinear equations and nonlinear least squares problems. (OS: BSD)
minuit - Fortran 77 library for function minimization and error Analysis by F. James (OS: GPL-2.0)
NonSmooth Optimization (NSO) Software by Napsu Karmitsa and coworkers
Optimization codes by Andrei Neculai THREECG: A simple three-term conjugate gradient algorithm which satisfies both the descent and the conjugacy conditions. DESCON: Conjugate Gradient Algorithm with guaranteed descent and conjugacy conditions for large-scale Unconstrained Optimization. ASCALCG: Accelerated Scaled Conjugate Gradient Algorithms for Unconstrained Optimization. AHYBRIDM: Accelerated Hybrid Conjugate Gradient Algorithm with Modified Secant Condition for Unconstrained Optimization. CONMIN: Shanno Conjugate Gradient with Beale restart memoryless variable metric algorithm for Unconstrained Optimization. ASA: Anticipative Scalar Approximation of Hessian for Unconstrained Optimization. RELAXED: Relaxed Gradient Descent Method with Backtracking for Unconstrained Optimization. UNO Fortran subroutines library for unconstrained optimization using searching methods.SPENBAR Sparse PENalty BARrier package for solving general nonlinear programming problems with equality and inequality constraints and simple bounds on variables. All the constrained are penalized. Minimization of the penalty function is given by TN package of S. Nash. FIBO Fibonacci method for function minimization. MAXFUN Powell direct search method for function maximization. ZERO Simple algorithms for computing zeros of a nonlinear function of a variable in a given interval.
PCx - interior-point predictor-corrector linear programming package
pikaia - Modern Fortran Edition of the Pikaia Genetic Algorithm by Jacob Williams
Software by M. J. D. Powell and Powell’s Derivative-Free Optimization solvers (PDFO) by Zaikun Zhang
PowellOpt is a collection of derivative-free optimization algorithms by M.J.D. Powell.
qnstop suite of serial and parallel Fortran 95/2003 codes for deterministic global optimization and stochastic optimization by Layne Watson.
RALFit - non-linear least squares solver that is primarily developed by the Numerical Analysis group at STFC Rutherford Appleton Laboratory.
Roots of a real function in Fortran 90 by J-P Moreau
simulated-annealing - Simulated Annealing with Modern Fortran by Jacob Williams
tapenade - tool for automatic differentiation (forward/reverse) of Fortran and C programs
TENSOLVE contains both TOMS 739 (UNCMIN) for unconstrained minimization, and TOMS 768 (TENSOLVE) for the solution of sets of non-linear equations.
TOMS algorithm 778 solves bound-constrained optimization problems by using the compact formula of the limited memory BFGS updates.
TOMS algorithm 813 is for local minimization, with or without convex constraints. It requires the user to supply first derivatives. This version is in standard Fortran. It uses the so-called spectral projected gradient (SPG) method.
tn.zip Stephen Nash’s truncated-Newton code for the minimization of continuous functions. It can use differences instead of derivatives, and bounds may be imposed on the parameters.
tron.zip Newton’s method for large bound-constrained optimization problems by Chih-Jen Lin & Jorge More’, a MINPACK-2 project.
uobyqa.f90 Mike Powell’s package for unconstrained minimization when derivatives are not available.
VTDIRECT95: Fortran 95 implementation of D. R. Jones’ deterministic global optimization algorithm called DIRECT, which is widely used in many multidisciplinary design optimization problems
autofit is a Fortran code for fitting permutationally invariant polynomials (PIPs). (OS: Apache-2.0 License)
FortLearner - linear regression, logistic regression, stochastic gradient descent, decision trees, ensemble trees, boosting trees, and dimension reduction.
gpf - small Fortran library for Gaussian process regression. It currently implements value predictions with dense Gaussian processes, and projected-process approximate Gaussian processes. (OS: Apache-2.0 License)
neural-fortran is a parallel neural net microframework. (OS: MIT)
NN_MOD - Fortran 2008 Module/Class for training neural network regressors
accis - Fortran plotting and graphics library
cairo-fortran: Fortran bindings for libcairo. (GPL v3)
DISLIN - high-level scientific data plotting library. (NC)
EGGX/ProCALL - X11 graphics library for C and FORTRAN created to achieve extreme simplicity. Uses only (OS: GPL)
gtk-fortran - cross-platform library to build Graphical User Interfaces (GUI). It is a GTK / Fortran 2003 binding based on the ISO_C_BINDING module. (OS: GPL)
GNUFOR2 - Fortran 90 interface to Gnuplot which helps to plot graphs, surfaces, histograms and images. (?)
GnuplotFortran - Fortran Interface to Gnuplot. (OS: LGPL)
F03GL - Fortran 2003 bindings for OpenGL, GLU and GLUT (?)
F90GL - Fortran 90 bindings for OpenGL and the GL Utility Toolkit (GLUT) (PD)
fortran-sdl2 - Fortran interface to Simple DirectMedia Layer 2.0 (SDL 2.0). It uses the ISO_C_BINDING module. (OS: ISC)
fortran-xlib - interface to (a subset) of Xlib. (OS: ISC)
g2 - easy to use, portable and powerful 2D graphics library. Currently supported devices: PostScript, X11, PNG and JPEG (using gd) and Win32 (xfig in development). g2 is written in C (ANSI) and has a Fortran interface. (OS: LGPL)
g95gl - alternate Fortran 95 (interop) bindings for OpenGL and the GL Utility Toolkit (GLUT)
giza - scientific plotting library for C/Fortran, meant as a replacement for pgplot, by Daniel Price
grapheps - port of a very compact Postscript library
GrWin - Windows graphics library for FORTRAN and C.
libvogle - basic vector-based graphics library in C, but Fortran-callable
Lib_VTK_IO - pure Fortran library to write and read data conforming the VTK standard. This library is not a porting or a wrapper of the VTK code, but it is only an exporter/importer of VTK data format written in pure Fortran language (standard Fortran 2003). (OS: GPL)
MathGL - library for making high-quality scientific graphics under Linux and Windows via Qt, FLTK or OpenGL. (OS: GPL)
ogpf - object-based Fortran 2003/2008 code for 2D, 3D plotting and animation, implements an interface to gnuplot. (PD)
plotterf90 - graphics subroutine library producing Postscript written by Masao Kodama. (?)
pltFor - Fortran-Python interface library to plot figures directly in Fortran, by DamienMinenna
Pyplot-Fortran - simple module for generating plots from Fortran using Python’s matplotlib.pyplot.
text_viz - Text-mode 2D-Graphics for Fortran. (?)
Fortran and Matlab Codes for differential equations - from Ernst Hairer
FOODIE - Fortran Object-Oriented Differential-equations Integration Environment.
ODEPACK is a systematized collection of ODE solvers. (PD)
PETSc The Portable, Extensible Toolkit for Scientific Computation (PETSc, pronounced PET-see; the S is silent), is a suite of data structures and routines developed by Argonne National Laboratory for the scalable (parallel) solution of scientific applications modeled by partial differential equations.
PoisFFT - Free parallel fast Poisson solver.
numerical-anal boundary value problems and heat transfer.
Differential equations in Fortran by J-P Moreau
dop853 - Modern Fortran Edition of Hairer’s DOP853 ODE Solver, by Jacob Williams
ddeabm - Modern Fortran implementation of the DDEABM Adams-Bashforth algorithm, by Jacob Williams
INTEGRAL - routines for the integration of functions of various types and for integration of systems of ordinary differential equations (ODEs)
Quadrule - sets up a variety of quadrature rules, used to approximate the integral of a function over various domains in 1D, by John Burkardt. He has many other quadrature codes linked there
quadrature-fortran - Adaptive Gaussian Quadrature with Modern Fortran, by Jacob Williams
stroud - routines from the book Gaussian quadrature formulas by Stroud & Secrest (1966), translated to modern Fortran by Ivan Pribec
Fortran-parallel-sort Fortran library to perform parallel sorts using OpenMP, by Corentin Cadiou (OS: CC0-1.0 License)
hs-sort sorting routines in Fortran 77 by Houlsby & Sloan, with a modern Fortran wrappers by Ivan Pribec
ORDERPACK - library with routines for unconditional, unique, and partial ranking, sorting, and permutation. (?)
DelaunaySparse serial and parallel codes, written in FORTRAN 2003 with OpenMP 4.5, for performing interpolation in medium to high dimensions via a sparse subset of the Delaunay triangulation.
bspline-fortran - multidimensional B-spline interpolation of data on a regular grid, by Jacob Williams.
finterp - multidimensional linear interpolation with modern Fortran, by Jacob Williams.
WenOOF - WENO interpolation Object Oriented Fortran library
NIST Digital Library of Mathematical Functions has a software index for special functions
Special functions in Fortran 90 and Bessel programs in Fortran 90 by J-P Moreau
Special_Functions translated code from book “Computation of Special Functions” by Shanjie Zhang and Jian-Ming Jin to Fortran 90 by John Burkardt. Links to other codes for special functions are provided.
FFTPack provide an easily usable package of functions using FFTPack library (Fortran 77).
fftpack51 computes the Fast Fourier Transform, using double precision arithmetic, translated to Fortran 90 by John Burkardt
fortran-csv-module - read and write CSV Files using Modern Fortran.
csvio-f90, the CSVIO F90 module, is a Fortran 90 module for easily reading and writing CSV files. (OS: BSD)
WKML is based on FoX, and writes KML (Keyhole Markup Language). (OS: BSD)
xml (?)
xml-fortran (OS: BSD)
fortranposix - An implementation of some POSIX functions in Fortran 90/95. (OS: LGPL)
fortyxima/filesys - Modern Fortran wrappers around the file system interface of libc as part of the Fortyxima library: rename and remove files, recursively create and remove directories, obtain filenames in a directory, check whether a given file exists and if a directory or a symbolic link, obtain the current working directory and change to a directory, create hard links and symbolic links, resolve the target of symbolic links, canonize path names. Fortyxima/filesys replaces the old modfilesys library. (OS: BSD)
Posix90 - The Fortran 90 Posix interface project. (OS: GPLv2+)
This two day practical hands-on workshop is aimed at Fortran programmers who want to write modern code, or to modernize existing codes, to make it more maintainable by encouraging good software engineering practices. Tools, scientific libraries and techniques for Fortran are covered to help you develop sustainable software for your academic research in a collaborative environment, with an emphasis on writing performance portable Fortran. There will be an section on parallel computing and the latest Fortran 2018 standard. Click here for further information
Fortran is the primordial HPC language. Its handling of multidimensional arrays have ensured that compilers can produce highly efficient code, and inclusion of coarrays in the 2008 standard made it the first major programming language with builtin support for parallelism. The 2008 inclusion of object-oriented modernised the language, bringing it on par with many of its contenders. In 2019 the Fortran standards committee started work on generics (templates). Templates are planned for the 202y release of Fortran, the one after the upcoming 2023 release.
Unlike C++ templates, Fortran templates are type-safe (strong concepts) and does not support meta-programming. This enables some very powerful programming techniques not matched by other high performance languages.
In this workshop we will give a hands-on preview of such techniques. This includes defining your own Fortran integrated domain specific programming languages (IDSLs) while benefitting from Fortran’s efficient code generation. We also look at the dichotomy between well-structured code and efficient code, and show some systematic transformations between these. Lastly, we suggest just-in-time compilation and interpreters for user defined Fortran IDSLs, achieving much of the same flexibility as the current integration of Fortran and Python.
Targeted at scientists who wish to extend their knowledge of Fortran to cover advanced features of the language.
Three day course is targeted at scientists with little or no knowledge of the Fortran programming language, but need it for participation in projects using a Fortran code base, for development of their own codes, and for getting acquainted with additional tools like debugger and syntax checker as well as handling of compilers and libraries. The language is for the most part treated at the level of the Fortran 95 standard; features from later Fortran standard editions are limited to improvements on the elementary level.
Fortran is a course introduced by Prof. Paul Tackley in earth science teaches modern Fortran 95 and review briefly Fortran 2003/2008 at ETH.
Description From the web page
FORTRAN 95 is a modern programming language that is specifically designed for scientific and engineering applications. This course gives an introduction to programming in this language, and is suitable for students who have only minimal programming experience, for example with MATLAB scripts. The focus will be on Fortran 95, but Fortran 77 will also be covered for those working with already-existing codes. A hands-on approach will be emphasized rather than abstract concepts, using example scientific problems relevant to Earth science.
Scientific Computing II by Antti Kuronen
Scientific Programing and Numerical Computation taught by Wu-ting Tsai
Object-oriented Programming with Fortran
Fortran by David Apsley. Originally based on an undergraduate course. Subsequently extended to more advanced Fortran.
1.Modern Programming Languages: Fortran90/95/2003/2008
This course provides an introduction to some of the most widely used methods of computational physics, including numerical solutions of differential equations (initial and boundary value prob- lems) in classical and quantum mechanics, Monte Carlo simulations, and numerical diagonalization of quantum many-body Hamiltonians. In addition to giving the students a basic working knowledge of these particular techniques, the goal is to make them comfortable with scientific computing in general, so that they will be prepared to tackle also other computational problem that they may encounter in the future. The Fortran 90 programming language will be used.
This function returns .true. if the string matches the given pattern which will normally include wild-card characters ? and/or , otherwise .false.
This version, match_wild3, includes an important bug fix provided by David Kinniburgh
LOGICAL FUNCTION match_wild3(pattern, string) result(match_wild)
! https://www.star.le.ac.uk/~cgp/match_wild.f90
! compare given string for match to pattern which may
! contain wildcard characters:
! "?" matching any one character, and
! "*" matching any zero or more characters.
! Both strings may have trailing spaces which are ignored.
! Authors: Clive Page, userid: cgp domain: le.ac.uk, 2003 (original code)
! Rolf Sander, 2005 (bug fixes and pattern preprocessing)
! Minor bug fixed by Clive Page, 2005 Nov 29, bad comment fixed 2005 Dec 2.
! Bug fix by David Kinniburgh - at line 137 lenp->lenp2
! and added trivial test at line 45. 2022 Oct 25
! This program is free software; you can redistribute it and/or modify
! it under the terms of the GNU General Public License as published by
! the Free Software Foundation; either version 2 of the License, or
! (at your option) any later version.
!
! This program is distributed in the hope that it will be useful,
! but WITHOUT ANY WARRANTY; without even the implied warranty of
! MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
! GNU General Public License for more details.
!
! You should have received a copy of the GNU General Public License
! along with this program; if not, write to the Free Software
! Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
! 02110-1301 USA
!
IMPLICIT NONE
CHARACTER(LEN=*), INTENT(IN) :: pattern ! pattern may contain * and ?
CHARACTER(LEN=*), INTENT(IN) :: string ! string to be compared
INTEGER :: lenp, lenp2, lens, n, p2, p, s
INTEGER :: n_question, n_asterisk
CHARACTER(LEN=LEN(pattern)) :: pattern2
lens = LEN_TRIM(string)
lenp = LEN_TRIM(pattern)
! If the pattern is empty, always return true
IF (lenp == 0) THEN
match_wild = .TRUE.
RETURN
! dgk add this trivial solution
ELSEIF (lens == 0) THEN
match_wild = .FALSE.
RETURN
ENDIF
! The pattern must be preprocessed. All consecutive occurences of
! one or more question marks ('?') and asterisks ('*') are sorted and
! compressed (**?*?* -> ??*). The result is stored in pattern2.
pattern2(:)=''
p = 1 ! current position in pattern
p2 = 1 ! current position in pattern2
DO
IF ((pattern(p:p) == '?').OR.(pattern(p:p) == '*')) THEN
! a special character was found in the pattern
n_question = 0
n_asterisk = 0
DO WHILE (p <= lenp)
! count the consecutive question marks and asterisks
IF ((pattern(p:p) /= '?').AND.(pattern(p:p) /= '*')) EXIT
IF (pattern(p:p) == '?') n_question = n_question + 1
IF (pattern(p:p) == '*') n_asterisk = n_asterisk + 1
p = p + 1
ENDDO
IF (n_question>0) THEN ! first, all the question marks
pattern2(p2:p2+n_question-1) = REPEAT('?',n_question)
p2 = p2 + n_question
ENDIF
IF (n_asterisk>0) THEN ! next, the asterisk (only one!)
pattern2(p2:p2) = '*'
p2 = p2 + 1
ENDIF
ELSE
! just a normal character
pattern2(p2:p2) = pattern(p:p)
p2 = p2 + 1
p = p + 1
ENDIF
IF (p > lenp) EXIT
ENDDO
!! lenp2 = p2 - 1
lenp2 = len_trim(pattern2)
! The modified wildcard in pattern2 is compared to the string:
p2 = 1
s = 1
match_wild = .FALSE.
DO
IF (pattern2(p2:p2) == '?') THEN
! accept any char in string
p2 = p2 + 1
s = s + 1
ELSEIF (pattern2(p2:p2) == "*") THEN
p2 = p2 + 1
IF (p2 > lenp2) THEN
! anything goes in rest of string
match_wild = .TRUE.
EXIT ! .TRUE.
ELSE
! search string for char at p2
n = INDEX(string(s:), pattern2(p2:p2))
IF (n == 0) EXIT ! .FALSE.
s = n + s - 1
ENDIF
ELSEIF (pattern2(p2:p2) == string(s:s)) THEN
! single char match
p2 = p2 + 1
s = s + 1
ELSE
! non-match
EXIT ! .FALSE.
ENDIF
IF (p2 > lenp2 .AND. s > lens) THEN
! end of both pattern2 and string
match_wild = .TRUE.
EXIT ! .TRUE.
ENDIF
!! IF (s > lens .AND. (pattern2(p2:p2) == "*") .AND. p2 == lenp2) THEN
!! above line buggy since p2 can be beyond end of string pattern2 by this point. CGP
! IF (s > lens .AND. p2 == lenp) THEN
IF (s > lens .AND. p2 == lenp2) THEN !!dgk should this be lenp2?
IF(pattern2(p2:p2) == "*") THEN
! "*" at end of pattern2 represents an empty string
match_wild = .TRUE.
EXIT
END IF
ENDIF
IF (p2 > lenp2 .OR. s > lens) THEN
! end of either pattern2 or string Bug fixed in line above
EXIT ! .FALSE.
ENDIF
ENDDO
END FUNCTION match_wild3
License: GPL license
Fortran 95 and earlier had no standard support for obtaining command-line arguments. However, with Fortran 2003, several new standard procedures were added to help parse command-line arguments: get_command_argument, get_command, and command_argument_count.
krackenis an open-source library for parsing Unix-like command-line arguments. It is now provide in Github as an General-Purpose-Fortran library (GPF) with a lot more functions than CLI option parsing.
M_CLI use a command prototype to define and read command-line arguments and leverages NAMELIST so no type conversion from strings is required
M_CLI2 use a command prototype to define and read command-line arguments including support of response files for abbreviating command calls with many options
f2kcli is an implementation of the Fortran 2003 command line interface for compilers which do not support Fortran 2003.
getopt.f90 by Mark Gates is no longer available under http://ews.uiuc.edu/~mrgates2/research/getopt.f90. But Hani Andreas Ibrahim forked the module and provides an extended version in GitHub. It parses GNU- and POSIX-style CLI-options with and without arguments. Just one module and can be learned in minutes. Wiki, sample program provided.
CLAF90 is a f90-module for parsing command line arguments.~ Not available anymore.
CLAF90 –alternate source
FLAP a Fortran command Line Arguments Parser for poor people. A KISS pure Fortran Library for building powerful, easy-to-use, elegant command line interfaces.
Fortran Unit Test Framework (FRUIT)
Fytest Note Fytest is deprecated, you should consider to use the Fortuno unit testing framework instead.
toast - Testing Or ASsertion Toolkit - Fortran unit testing library
FortUTF - Unit Test framework written purely in Fortran to be compatible with as many projects as possible
XFunit - Native Fortran 2003 Unit Testing Framework
Fortuno User friendly, flexible and extensible object-oriented Fortran unit testing framework for testing serial, MPI-parallelized and coarray-parallelized applications .
Compiler support for Fortran 2008 and 2018 - PDF file. This is updated regularly and also appears in ACM Fortran Forum.
fortran-compiler-tests collection of Fortran compiler bug examples and tests.
doi
) developed in BSC is going to be developed further to simulate the ABL flows in Marenostrum supercomputer at BSC.Fortran
, this language is an intimate part of my research work.Visit my portfolio for more info: tariqridwan.github.io
If you are new to the wiki, here is one way to introduce yourself:
Edit this page by clicking the “Edit” link at the bottom and add your name to the list below surrounded by square brackets to create a wiki link.
Type your name again in the “Submit as” field at the bottom of the page and save your changes by clicking the “Submit” button.
When the page reloads, your name should appear in the list followed by a question mark, indicating a link to a page which doesn’t exist yet. Follow this link to create your user page.
Edit and save your user page, optionally adding some information about yourself such how you use Fortran or a link to your homepage.
I and colleague Ian Chivers give Fortran training courses and are authors of Introduction to Programming with Fortran, 4th edition. We also have a very useful Fortran resource file
Curcic, Milan (2019). Modern Fortran: Building Efficient Parallel Applications. Manning Publications.
Metcalf, M., J. Reid, and M. Cohen (2018). Modern Fortran Explained: Incorporating Fortran 2018. Oxford University Press.
Ray, Subrata (2019). Fortran 2018 with Parallel Programming CRC
Brainerd, Walter S. (2015). Guide to Fortran 2008 Programming. Springer.
Chivers, Ian D. and Jane Sleightholme (2018) Introduction to Programming with Fortran (4th Edition). Springer.
Chapman, Stephen J. (2018). Fortran for Scientists and Engineers (Fourth Edition). McGraw-Hill Education.
Hanson, R. J. and Hopkins, T. (2013). Numerical Computing With Modern Fortran. SIAM.
Metcalf, M., J. Reid, and M. Cohen (2011). Modern Fortran Explained. Oxford University Press.
Numrich, Robert W. (2018). Parallel Programming with Co-Arrays. Chapman & Hall/CRC.
Adams, J. C., W. S. Brainerd, R. A. Hendrickson, R. E. Maine, J. T. Martin, and B. T. Smith (2008). The Fortran 2003 Handbook. Springer.
Brainerd, Walter S. (2009) Guide to Fortran 2003 Programming. Springer.
Metcalf, M., J. Reid, and M. Cohen (2004). Fortran 95/2003 Explained. Oxford University Press.
Chapman, S. J. (2007). Fortran 95 and 2003 for Scientists and Engineers. McGraw-Hill Education.
Adams, Brainerd, Martin, Smith and Wagener (1997). Fortran 95 Handbook. MIT.
Akin, E. (2003). Object-Oriented Programming Via Fortran 90 and 95. Cambridge University Press. (pdf)
Chapman, S. J. (1997). Introduction To Fortran 90 and 95. McGraw-Hill College.
Chapman, S. J. (2004). Fortran 90 and 95 for Scientists and Engineers. 2nd ed. McGraw Hill. (Publisher’s site)
Lemmon, D. R. and J. L. Schafer. (2005). Developing Statistical Software in Fortran 95. Springer.
McCormack, D. (2009). Scientific Software Development with Fortran. Lulu.
Ellis, T.M.R., Ivor R. Phillips, and Thomas M. Lahey (1994) Fortran 90 Programming Addison Wesley
Landau, Rubin (2005) A First Course in Scientific Computing: Symbolic, Graphic, and Numeric Modeling Using Maple, Java, Mathematica, and Fortran90. Princeton University Press
Akaike, Hirotsugu (1975). TIMSAC-74, a time series analysis and control program package Institute of Statistical Mathematics. R package timsac: Time Series Analysis and Control has Fortran code.
Akin, J. E. (1994). Finite Elements for Analysis and Design Academic Press
Alexandrou, Andreas N. (2001). Principles of Fluid Mechanics Prentice-Hall
Algazin, Sergey D., and Igor A. Kijko (2015). Aeroelastic Vibrations and Stability of Plates and Shells De Gruyter
Allen, Michael P. and Dominic J. Tildesley (2017). Computer Simulation of Liquids, 2nd. ed. Oxford University Press. code at GitHub
Anagnostopoulos, Konstantinos (2016). Computational Physics freely available in Fortran and C++ versions
Angell, Ian O., and Gareth Griffith (1987). High-resolution Computer Graphics Using FORTRAN 77 Palgrave Macmillan
Antia, H.M. (2012). Numerical methods for scientists and engineers, 3rd ed. Hindustan Book Agency.
Bartschat, Klaus (Ed.) (1996). Computational Atomic Physics: Electron and Positron Collisions with Atoms and Ions Springer
Bathe, Klaus-Jurgen (2014). Finite Element Procedures, 2nd ed. Prentice Hall. Text here Related code ADINA, OpenSTAP, and STAP90
Beer, Gernot, Ian Smith, and Christian Duenser (2008). The Boundary Element Method with Programming For Engineers and Scientist Springer
Beer, Gernot (2001). Programming the Boundary Element Method: An Introduction for Engineers Wiley
Berg, Bernd A (2004). Markov Chain Monte Carlo Simulations and Their Statistical Analysis – With Web-Based Fortran Code World Scientific
Bestehorn, Michael (2018). Computational Physics With Worked Out Examples in FORTRAN and MATLAB De Gruyter
Bhatt, Prab (2003). Programming the Dynamic Analysis of Structures CRC
Bierman, Gerald J. (1977). Factorization Methods for Discrete Sequential Estimation Academic Press (contains Fortran pseudo-code for numerically stable Kalman filters)
Blazek, Jiri (2015). Computational Fluid Dynamics: Principles and Applications, 3rd ed. Butterworth-Heinemann
Bloomfield, Peter (1976). Fourier Analysis of Time Series, 1st ed. First edition has Fortran code, the 2nd edition, published in 2000, has S-PLUS code.
Boor, Carl de (1978). A Practical Guide to Splines Springer. PPPACK Fortran 90 code here
Bose, Sujit Kumar (2019). Numerical Methods of Mathematics Implemented in Fortran Springer. reviewed here
Boyd, John P. (2001). Chebyshev and Fourier Spectral Methods Dover. Modified code here
Brandt, Siegmund (1999). Data Analysis: Statistical and Computational Methods for Scientists and Engineers Springer
Brent, Richard (1973). Algorithms for Minimization without Derivatives Prentice-Hall
Britz, Dieter, and Jörg Strutwolf (2016). Digital Simulation in Electrochemistry Springer. Appendix E describes a number of example programs in Fortran.
Burden, Richard, L., J. Douglas Faires and Annette M. Burden (2016). Numerical Analysis, 10th ed. Cengage. FORTRAN 77 code here
Chandra, Rohit, Ramesh Menon, Leo Dagum, David Kohr, Dror Maydan, and Jeff McDonald (2000). Parallel Programming in OpenMP Morgan Kaufmann
Chapman, Barbara et al. (2007). Using OpenMP - Portable Shared Memory Parallel Programming. MIT Press.
Cheney, Ward and David Kincaid (2012). Numerical Mathematics and Computing, 7th ed. Brooks/Cole: Cengage Learning
Chung, T. J. (2010). Computational Fluid Dynamics, 2nd ed. Cambridge University Press
Clerman, Norman S. and Spector, Walter (2011). Modern Fortran - Style and Usage. Cambridge University Press. reviewed in the Journal of Statistical Software
Coker, A. Kayode (1995). Fortran Programs for Chemical Process Design, Analysis, and Simulation Gulf Professional
Crawley, Stanley W., and Robert M. Dillon (1993) Steel Buildings: Analysis and Design, 4th ed. Wiley
Cullum, Jane K. and Ralph A. Willoughby (1985) Lanczos Algorithms for Large Symmetric Eigenvalue Computations: Vol. I: Theory Birkhauser. Code and text of 2nd volume at Netlib
Curotto, Emanuele (2009). Stochastic Simulations of Clusters: Quantum Methods in Flat and Curved Spaces CRC
Dagpunar, John (1988). Principles of Random Variate Generation Oxford University Press. Related Fortran 90 code from Alan Miller.
Davies, R.G. (1971). Computer Programming in Quantitative Biology Academic Press
Davis, Mark E. (1984). Numerical Methods & Modeling for Chemical Engineers Wiley
Davis, Philip J., and Philip Rabinowitz (1984). Methods of Numerical Integration, 2nd. ed. Academic Press
Day, A. Colin (1972). Fortran Techniques with Special Reference to Non-numerical Applications Cambridge University Press
De Gooijer, Jan G. (2017). Elements of Nonlinear Time Series Analysis and Forecasting Springer
Dennis, Jr., J.E., and Robert B. Schnabel (1996). Numerical Methods for Unconstrained Optimization and Nonlinear Equations SIAM. Fortran 90 code for UNCMIN at Alan Miller’s site
Deutsch, C.V. and A.G. Journel (1997). GSLIB: Geostatistical Software Library and Users Guide, 2nd. ed. Oxford University Press. Code here
DeVries, Paul L. (1994). A First Course in Computational Physics Wiley. reviewed here
Devroye, Luc (1986). Non-Uniform Random Variate Generation Springer. Devroye says“Alan Miller … programmed most algorithms” from the book.
Dierckx, Paul (1993). Curve and Surface Fitting with Splines Oxford. code here
Engeln-Müllges, Gisela and Uhlig, Frank (2013). Numerical Algorithms with Fortran. Springer.
Epps, Thomas W. (2007). Pricing Derivative Securities, 2nd. ed. World Scientific
Evensen, Geir (2009). Data assimilation, The Ensemble Kalman Filter, 2nd ed. Springer
Farrashkhalvat, M., and J.P. Miles (2003). Basic Structured Grid Generation, with an introduction to unstructured grid generation Butterworth-Heinemann
Fehr, Hans and Kindermann, Fabian (2018). Introduction to Computational Economics Using Fortran. Oxford University Press.
Fenner, D. N. (1987). Engineering stress analysis: A finite element approach with FORTRAN 77 software Ellis Horwood
Fenner, Roger T. (2013). Finite Element Methods For Engineers, 2nd ed. Imperial College Press
Fenton, Gordon A., and D. V. Griffiths (2008). Risk Assessment in Geotechnical Engineering Wiley
Ferziger, Joel H., Peric, Milovan, and Street, Robert L. (2002). Computational Methods for Fluid Dynamics Springer
Finlayson, Bruce A. (1980). Nonlinear Analysis in Chemical Engineering McGraw-Hill.
Fletcher, C. A. J. (1998). Computational Techniques for Fluid Dynamics 1: Fundamental and General Techniques Springer
Fletcher, C. A. J. (1991). Computational Techniques for Fluid Dynamics 2: Specific Techniques for Different Flow Categories Springer
Fletcher, C. A. J. (1984). Computational Galerkin Methods Springer
Fletcher, R. (2000). Practical Methods of Optimization, 2nd Edition Wiley
Fornberg, Bengt (1998). A Practical Guide to Pseudospectral Methods Cambridge University Press.
Forsythe, George E., Michael A. Malcolm, and Cleve B. Moler (1977). Computer Methods for Mathematical Computations Prentice-Hall. Code at Netlib
Francq, Christian and Jean‐Michel Zakoian (2019). GARCH Models: Structure, Statistical Inference and Financial Applications, 2nd. ed. Wiley. Code at Francq’s site
Fuller, W. R. (1977). FORTRAN Programming: A Supplement for Calculus Courses Springer
Garcia, Alejandro L. (1994). Numerical Methods for Physics Prentice Hall
Gibbs, B. P. (2011). Advanced Kalman Filtering, Least-Squares, and Modeling, A Practical Handbook Wiley. The software is included in a single zip file (Gibbs_Software_1_2.zip) located at web site ftp://ftp.wiley.com/public/sci_tech_med/least_squares/
Gill, Philip E., Walter Murray, Margaret H. Wright (1981). Practical Optimization Academic Press
Giordano, Nicholas J., and Hisao Nakanishi (2005). Computational Physics Prentice-Hall
Golub, Gene, and Charles Van Loan (2013). Matrix Computations, 4th ed. Johns Hopkins
Gonin, Rene, and Arthur H. Money (1989). Nonlinear Lp-Norm Estimation CRC
Green, Peter J., Nils Lid Hjort, and Sylvia Richardson (2003). Highly Structured Stochastic Systems Oxford University Press. Related code at Green’s site
Greenspan, Donald (2005). Molecular and Particle Modelling of Laminar and Turbulent Flows World Scientific
Greenspan, Donald (1991). Quasimolecular Modelling World Scientific
Griffiths, P., and Ian D. Hill (1985). Applied Statistics Algorithms Ellis Horwood. Applied statistics codes here.
Griffiths, D. Vaughan, and I.M. Smith (2006). Numerical Methods for Engineers, 2nd ed. CRC. Code at Griffiths’ site
Gropp W., Lusk, E. and Skjellum, A. (1999). Using MPI - Portable Parallel Programming with the Message Passing Interface. The MIT Press.
Gu, Chong (2013). Smoothing Spline ANOVA Models, 2nd ed.
Hageman, L. and D. M. Young (1981). Applied Iterative Methods Academic Press. Related package: NSPCG
Hager, Georg and Gerhard Wellein (2010). Introduction to High Performance Computing for Scientists and Engineers CRC
Hairer, Ernst, Syvert P. Nørsett, and Gerhard Wanner (1993). Solving Ordinary Differential Equations I: Nonstiff Problems Springer. code at Hairer’s site
Hairer, Ernst, and Gerhard Wanner (1996). Solving Ordinary Differential Equations II: Stiff and Differential-Algebraic Problems Springer. code at Hairer’s site
Hartigan, J. A. (1975). Clustering Algorithms Wiley. Code in the Cluster section of CMLIB.
Hinton, E, and D. Owen (1979). Finite Element Programming Academic Press
Hjorth-Jensen, Morton (2008). Computational Physics
Hock, W., and Klaus Schittkowski (1981). Test Examples for Nonlinear Programming Codes Springer. Code here
Huang, Haibo, Michael C. Sukop, and Xi-Yun Lu (2015). Multiphase Lattice Boltzmann Methods: Theory and Application Wiley
Hughes, Thomas J. R. (1987). The Finite Element Method: Linear Static and Dynamic Finite Element Analysis Prentice-Hall. Related code DLEARN
Itkin, A. L., and E. G. Kolesnichenko (1997). Microscopic Theory of Condensation in Gases and Plasma World Scientific
Izaac, Joshua, and Jingbo Wang (2018). Computational Quantum Mechanics Springer
Javanbakht, Zia, and Andreas Öchsner (2017). Advanced Finite Element Simulation with MSC Marc: Application of User Subroutines Springer
Jeppson, Roland W. Jeppson (1976). Analysis of Flow in Pipe Networks Butterworth-Heinemann. Modernization of codes discussed in Recovery of Jeppson Pipe Network Analysis Software by Bob Apthorpe
Jones, Russell K., and Tracy Crabtree (1988). FORTRAN Tools for VAX/VMS and MS-DOS Wiley
Kagiwada, Harriet, Robert Kalaba, Nima Rasakhoo, and Karl Spingarn (1986). Numerical Derivatives and Nonlinear Analysis
Kahaner, David, Cleve Moler, and Stephen Nash (1998). Numerical Methods and Software Prentice Hall. Fortran 90 code here
Kampf, Jochen (2010). Advanced Ocean Modelling: Using Open-Source Software Springer
Kantz, Holger, and Thomas Schreiber (2010). Nonlinear Time Series Analysis Cambridge University Press. Associated software: TISEAN
Katz, Joseph and Allen Plotkin (2001). Low-Speed Aerodynamics Cambridge University Press. Code at GitHub
Kearfott, R. Baker (1996). Rigorous Global Search: Continuous Problems Kluwer
Kernighan, Brian W. and Pike, Rob (1999). The Practice of Programming. Addison-Wesley.
Kincaid, David and Ward Cheney (2002). Numerical Analysis: Mathematics of Scientific Computing, 3rd ed. American Mathematical Society. Code here
Kitagawa, Genshiro (2020). Introduction to Time Series Modeling with Applications in R CRC. Associated R package TSSS: Time Series Analysis with State Space Model has Fortran code.
Klein, Andi, and Alexander Godunov (2006). Introductory Computational Physics Cambridge University Press. codes in Fortran and C++
Koonin, Steven E., and Dawn C. Meredith (1990). Computational Physics: Fortran Version Westview Press
Kopriva, David (2009). Implementing Spectral Methods for Partial Differential Equations: Algorithms for Scientists and Engineers Springer. Has Fortran-friendly pseudo-code. The author has contributed routines to the HORSES2D high-order spectral element solver in Fortran.
Kuester, James L., and Joe H. Mize (1973). Optimization Techniques with Fortran McGraw-Hill
Land, A., and S. Powell (1973). Fortran codes for mathematical programming: linear, quadratic and discrete Wiley
Lau, Hang Tong (1989). Algorithms on Graphs Tab Books. Fortran 90 version of code at Burkardt’s site
Lau, Hang Tong (1986). Combinatorial Heuristic Algorithms with FORTRAN Springer
Lawson, Charles L., and Richard J. Hanson (1995). Solving Least Squares Problems SIAM original code at Netlib, modernized code at GitHub. Bounded Variable Least Squares Solver here, Nonnegative Least Squares here.
LeVeque, Randall J. (2012). Finite Volume Methods for Hyperbolic Problems Cambridge University Press
Lee, H.J., and W.E. Schiesser (2003). Ordinary and Partial Differential Equation Routines in C, C++, Fortran, Java, Maple, and MATLAB Chapman and Hall/CRC
Lee, Wen Ho (2018). Computational Solid Mechanics for Oil Well Perforator Design World Scientific
Lucquin, Brigitte, and Olivier Pironneau (1998). Introduction to Scientific Computing Wiley. Fortran and C code at Pironneau’s site
Marazzi, Alfio (1993). Algorithms, Routines, and S-Functions for Robust Statistics Chapman and Hall/CRC. FORTRAN 77 code available in robeth R package
Markus, Arjen (2012). Modern Fortran in Practice Cambridge University Press. Reviewed here
Marple, S. Lawrence (1987). Digital Spectral Analysis with Applications Prentice-Hall. Reviewed here. Second edition has Matlab code.
Mattson, Timothy G., Yun (Helen) He, and Alice E. Koniges (2019). The OpenMP Common Core: Making OpenMP Simple Again MIT Press
Mielke, Jr., Paul W., and Kenneth J. Berry (2007). Permutation Methods: A Distance Function Approach Springer. code at Mielke’s site
Miller, Alan (2002). Subset Selection in Regression, 2nd ed. Chapman and Hall/CRC. code at Miller’s site
Monahan, John F. (2011). Numerical Methods of Statistics, 2nd ed. Cambridge University Press
Moran, Jack (1984). An Introduction to Theoretical and Computational Aerodynamics Wiley. Reviewed here
Moré, Jorge J. and Stephen J. Wright (1993). Optimization Software Guide SIAM. Wright helped create the NEOS Guide
Moursund, David G., and Charles S. Duris (1988). Elementary Theory and Application of Numerical Analysis Dover
Nazareth, J.L. (2001). DLP and Extensions: An Optimization Model and Decision Support System Springer. DLPEDU code here
Neculai, Andrei (2020). Nonlinear Conjugate Gradient Methods for Unconstrained Optimization Springer. Fortran codes at author’s site
Newton, H. Joseph (1988). Timeslab: A Time Series Analysis Laboratory Wadsworth & Brook/Cole. Timeslab code at author’s site
Nguyen, Duc Thai (2002). Parallel-Vector Equation Solvers for Finite Element Engineering Applications Springer
Nocedal, Jorge, and Stephen J. Wright (2006). Numerical Optimization Springer. Related code at Nocedal’s site
Oliveira, Suely and Stewart, David (2006). Writing Scientific Software - A Guide to Good Style. Cambridge University Press.
Olver, Frank W. J., Daniel W. Lozier, Ronald F. Boisvert, and Charles W. Clark (2010). NIST Handbook of Mathematical Functions Cambridge University Press. Associated with the NIST Digital Library of Mathematical Functions
Orfanidis, Sophocles J. (1988). Optimum Signal Processing Wiley
Osyczka, Andrzej (1984). Multicriterion Optimization in Engineering with FORTRAN Programs Halsted/Wiley
Pang, Tao (2006). An Introduction to Computational Physics, 2nd Edition Cambridge University Press
Pao, Yen-Ching (1998). Engineering Analysis: Interactive Methods and Programs with FORTRAN, QuickBASIC, MATLAB, and Mathematica CRC Press
Pozrikidis, C. (2017). Fluid Dynamics: Theory, Computation, and Numerical Simulation, 3rd ed. Springer
Pozrikidis, C. (2008). Numerical Computation in Science and Engineering, 2nd. ed. Oxford University Press
Pozrikidis, C. (2011). Introduction to Theoretical and Computational Fluid Dynamics, 2nd. ed. Oxford
Pozrikidis, C. (1999). Little Book of Streamlines Academic Press
Prausnitz, J., T. Anderson, E. Grens, C. Eckert, R. Hsieh, and J. O’Connell, (1980). Computer Calculations for Multicomponent Vapor-Liquid and Liquid-Liquid Equilibria Prentice-Hall.
Press, Flannery, Teukolsky, and Vetterling (1992). Numerical Recipes in Fortran 77. Cambridge University Press.
Press, Teukolsky, Vetterling and Flannery (1996). Numerical Recipes in Fortran 90 - The Art of Parallel Scientific Computing. Cambridge University Press
Rabiner, Lawrence R., and Bernard Gold (1975). Theory and Application of Digital Signal Processing Prentice Hall
Ramkarthik, M.S., and Payal D. Solanki (2021) Numerical Recipes in Quantum Information Theory and Quantum Computing: An Adventure in FORTRAN 90 CRC Press
Ramos, Juan Antonio Hernandez, and Lopez, Javier Escoto (2020). How to learn Applied Mathematics through modern FORTRAN. Independently published code and text
Reddy, J. N. (2005). An Introduction to the Finite Element Method, 3rd ed. McGraw-Hill. Code here
Robey, Robert and Yuliana Zamora (2021). Parallel and High Performance Computing Manning
Roe, Byron P. (2001). Probability and Statistics in Experimental Physics Springer
Røed, Lars Petter (2019). Atmospheres and Oceans on Computers: Fundamental Numerical Methods for Geophysical Fluid Dynamics Springer. Has appendix Introduction to Fortran 2003 via Examples
Rouson, D., J. Xia, and X. Xu (2011). Scientific Software Design - The Object-Oriented Way. Cambridge University Press.
Ruetsch, Gregory and Fatica, Massimiliano (2013). CUDA Fortran for Scientists and Engineers. Morgan Kaufmann.
Saad, Yousef (2003). Iterative Methods for Sparse Linear Systems, 2nd Edition SIAM
Saad, Yousef (2011). Numerical Methods for Large Eigenvalue Problems - 2nd Edition SIAM
Salmi, Tapio, Johan Wärnå , José Rafael Hernández Carucci and César A. de Araújo Filho (2020). Chemical Reaction Engineering: A Computer-Aided Approach De Gruyter
Santner, Thomas J., Brian J. Williams, and William I. Notz (2003). The Design and Analysis of Computer Experiments Springer
Schittkowski, Klaus (2002). Numerical Data Fitting in Dynamical Systems - A Practical Introduction with Applications and Software Kluwer
Schittkowski, Klaus (1987). More Test Examples for Nonlinear Programming Codes Springer. Code here
Schittkowski, Klaus (1980). Nonlinear Programming Codes: Information, Tests, Performance Springer
Schmidt, Bernd (1987). Model Construction with GPSS-FORTRAN Version 3 Springer.
Scott, L. Ridgway, Terry Clark, and Babak Bagheri (2005). Scientific Parallel Computing Princeton University Press
Sewell, Granville (2018). Solving Partial Differential Equation Applications with PDE2D Wiley
Sewell, Granville (2015) The Numerical Solution of Ordinary and Partial Differential Equations, 3rd Ed. World Scientific
Sewell, Granville (2014). Computational Methods of Linear Algebra, 3rd ed. World Scientific
Shampine, Lawrence, and Marilyn Gordon (1975). Computer Solution of Ordinary Differential Equations: The Initial Value Problem Freeman. Code translated to Fortran 90 by John Burkardt.
Singh, Nathi (2017). Computational Methods for Physics and Mathematics: With Fortran and C Programmes Alpha Science
Sinha, Mihir K., and Larry R. Padgett (1985). Reservoir Engineering Techniques Using Fortran Springer
Siouris, George M. (1996). An Engineering Approach to Optimal Control and Estimation Theory Wiley
Smetana, Frederick O. (1997). Introductory Aerodynamics and Hydrodynamics of Wings and Bodies: A Software-Based Approach American Institute of Aeronautics & Astronautics
Smetana, Frederick O. (1981). Fortran Codes for Classical Methods in Linear Dynamics McGraw-Hill
Smith, I.M., D. V. Griffiths, and L. Margetts (2013). Programming the Finite Element Method, 5th Edition Wiley. Code at Griffiths’ site
Smylie, D. E. (2013). Earth Dynamics: Deformations and Oscillations of the Rotating Earth Cambridge University Press
Snir, Marc and Gropp, William (1998). MPI - The Complete Reference. The MIT Press.
Späth, Helmuth (1995). Two Dimensional Spline Interpolation Algorithms CRC
Späth, Helmuth (1995). One Dimensional Spline Interpolation Algorithms CRC
Späth, Helmuth (1991). Mathematical Algorithms for Linear Regression Academic Press. Fortran 90 code at John Burkardt’s site
Späth, Helmuth (1980). Cluster Analysis Algorithms Halsted Press. Fortran 90 code at John Burkardt’s site
Stearns, Samuel D., and Ruth A. David (1992). Signal Processing Algorithms in Fortran and C Prentice-Hall
Tanizaki, Hisashi (2004). Computational Methods in Statistics and Econometrics CRC Press
Thompson, William J. (1997). Atlas for Computing Mathematical Functions: An Illustrated Guide for Practitioners with Programs in FORTRAN and Mathematica Wiley
Tikhonov, A.N., Goncharsky, A., Stepanov, V.V., and Yagola, A.G. (1995). Numerical Methods for the Solution of Ill-Posed Problems Springer
Trapp, Michael, and Andreas Öchsner (2018). Computational Plasticity for Finite Elements: A Fortran-Based Introduction Springer
Villadsen, John, and Michael L. Michelsen (1978). Solution of Differential Equations Models by Polynomial Approximation Prentice-Hall
Vowels, Robin A. (1998). Algorithms and Data Structures in F and Fortran Unicomp
Walker, Darren (2016). Computational Physics Mercury Learning. Code at GitHub.
Wang, H. F., and M. P. Anderson (1982). Introduction to groundwater modeling: Finite difference and finite element methods Freeman. Code at Wang’s site
Watson, Neville, and Jos Arrillaga (2003). Power Systems Electromagnetic Transients Simulation Institution of Engineering and Technology
Wesseling, Pieter (1992). An Introduction to Multigrid Methods Wiley. Code by Wesseling here
Weiland, Claus (2010). Computational Space Flight Mechanics Springer
White, Robert E. (2016). Computational Mathematics Models, Methods, and Analysis with MATLAB® and MPI, 2nd ed. CRC
Yanushevsky, Rafael (2019). Modern Missile Guidance, 2nd ed. CRC
Zubairi, Omair and Fridolin Weber (2018). Introduction to Computational Physics for Undergraduates Morgan & Claypool
https://link.springer.com/book/10.1007/978-3-319-75502-1