Here is list of projects from Fortran Code on Github that were added since the beginning of September. I can update this monthly if there is interest. For brevity I have excluded projects from domain-specific categories such as Astrophysics or Earth Science. They are on the main list. Some “new” projects are years old but were only recently added.
cumsum_benchmark: benchmarks for the cumulative sum of an array, in Fortran, C++, Matlab, and Python, using various methods
Simple N-Body with LeapFrog integrator: Implementation in C, Fortran, Go, Julia and Rust of a very simple N-Body simulator with 3 particles using a LeapFrog integrator. Presented in What can the programming language Rust do for astrophysics?, to appear in the Proceedings of the IAU Symposium 325 on Astroinformatics.
Traveling Salesman Problem Exact algorithm: fastest to slowest are C++, Rust, Go, C#, Fortran, Dart, and Python, by Luis Harvey Triana Vega
adjac: automatic differentiation for generating sparse Jacobians, using Fortran 95 and operator overloading, by pv.
autodiff: automatic differentiation for up to 4th derivatives, by Simon Geard
Fortran-RefCount: simple reference counting for Fortran
infnan: functions for checking Inf/NaN, Zaikun Zhang. They should work even if the compilers are invoked with aggressive optimization flags such as
gfortran -Ofast .
Object-oriented Fortran 2018 HDF5 interface: very simple single-file/module access to HDF5, by fccf. More advanced object-oriented Fortran HDF5 access is also available but not compatible with HDF5 1.10 like this program.
HDF5 wrapper: minimalistic hdf5 wrapper for Fortran90/95, by Matthias Pickem
M_display: standard Fortran 95 module for printing scalars, vectors, and matrices to external files, by urbanjost. The module can display variables of default kind of all intrinsic types (integer, real, complex, logical, and character), and add-on modules are provided for data of the nondefault kind.
mo_netcdf: object-oriented wrapper around the NetCDF Fortran 90 interface, by David Schaefer et al.
NetCDF95: interface to the NetCDF library, by Lionel Guez. Compared to the Fortran 90 NetCDF interface, the NetCDF95 interface is meant to be friendlier and more secure, for example freeing the user from the cumbersome task of handling the error status.
oo_hdf: object-oriented Fortran HDF5 module, by Ricardo Torres. This library aims to create a group of classes in Fortran to interact with HDF5.
cernlib: large collection of general purpose libraries and modules maintained and offered in both source and object code form on the CERN central computers. Most of these programs were developed at CERN and are therefore oriented towards the needs of a physics research laboratory that is general mathematics, data analysis, detectors simulation, data-handling etc… applicable to a wide range of problems.
f90getopt: getopt()- and getopt_long()-like functionality (similar to the C-functions) for Fortran 90, by Hani Andreas Ibrahim
Fortran General Library (FGL): code for bitstrings, exception handling, hash tables, lists, logging, queues, strings, sorting, JSON parsing, and other topics, from mobius-eng
Fortran Equation Parser (feqparse): equation parser Fortran class that is used to interpret and evaluate functions provided as strings, by Joe Schoonover
fortran-list: generic list implementation in Fortran 2003, by Vladimír Fuka. Uses unlimited polymorphics or parametric polymorphism.
Fortran Logging Library: Flogging: provides an easy-to-use interface for logging events and errors in Fortran applications and libraries, by Chris MacMackin. Its use and functionality is similar to that of logging library in Python.
Fortran Parameter List (FPL): Fortran 2003 library that can manage the parameters of a program from a single point, by victorsndvg. FPL is an extendible container (dictionary) of <Key, Value> pairs, where the Key is a character string and the Value can be, by the default, of the basic data types.
Fortran User Defined Exceptions Handler (ForEx): Fortran 2003 project taking advantage of the C preprocessor capabilities in order to emulate exception handling, by victorsndvg
FortranUtilities: functions for strings, numbers, precision, statistics and files, by Emilio Castro
fstack: custom stack type for Fortran 2003 that implements a C-style stack, by jake-87. The advantage of this model is that one can have multiple stacks at any one time, so there is no need to juggle them – just allocate another one.
Futility: utilities for definition of kinds for intrinsic numeric data types, a unit test harness, definitions for some basic extensions to the Fortran language, geometry definitions and intersection routines, file wrapper functions, parallel wrapper functions, math utilities, a lightweight profiling interface, and other miscellaneous routines, from CASL
futility: collection of modern Fortran utilities, including some numerical subroutines and a module for simplified input and output of arrays, by Chris MacMackin
gFTL: provides a mechanism to easily create robust containers and associated iterators which can be used within Fortran applications, from Goddard-Fortran-Ecosystem. The primary methods are intended to be as close to their C++ STL analogs as possible. Also see gFTL-shared
Jumble: library of various utilities in Fortran 2003, by Lionel Guez
LinkedList: simple implementation of heterogeneous linked list in a single module, by Pedro Ricardo C. Souza
M_calculator: parse Fortran-like double precision scalar expressions, by urbanjost
M_hashkeys: collection of hash key generator modules, by urbanjost
M_history: input line history editor, by urbanjost
M_msg: convert all common variables to a string in Fortran using unlimited polymorphic variables, by urbanjost
It allows the typical components of a pathname on a POSIX system (Such as GNU/Linux, Unix and Cygwin) to be accessed easily, to render the full pathname of the path and to get basic file properties (permissions, size, ownership, …).
PolyCon: abstract container derived type which can be used as a sort of unlimited polymorphic entity whose contents are retrievable with type-guards, by Chris MacMackin. Different subclasses are created in order to hold different data-types.
cairo-fortran: libcairo bindings for Fortran from the gtk-fortran project available as a separate fpm package, by Carlos Une
M_ncurses: module that allows use of the C Ncurses library for controlling and formatting terminal displays, by urbanjost
MatlabFortran: easily export data from Matlab to Fortran and back, by Alessandro Di Nola
python-fortran: Python-Fortran bindings examples, by Pierre Navaro
Mean-preserving interpolation (mp-interp): implements four approaches for mean-preserving interpolation as might be applied, for example, to the interpolation of pseudo-daily values from monthly means, that when averaged, reproduce those monthly means, by Pat Bartlein
ARPACK_PARPACK: solves large eigenvalue problems in double precision in standard Fortran 90, by KingJGod
blas-interface: interface declarations for basic linear algebra subprograms, by Sebastian Ehlert
Eigensolver_gpu: generalized eigensolver for symmetric/hermetian-definite eigenproblems with functionality similar to the DSYGVD/X or ZHEGVD/X functions available within LAPACK/MAGMA, by Josh Romero et al. This solver has less dependencies on CPU computation than comparable implementations within MAGMA, which may be of benefit to systems with limited CPU resources or to users without access to high-performing CPU LAPACK libraries.
libsparse: Fortran 2003 library that provides objects to create and handle rectangular and square sparse matrices using different formats: Linked List, COOrdinate storage (with elements stored using a hashing function), or Compressed Row Storage, by Jeremie Vandenplas. The library relies on different libraries, such as BLAS/LAPACK libraries, PARDISO (at this stage, Intel MKL PARDISO), and METIS 5.
LinAlgf90: modern Fortran wrappers for the eigenvalue functionality of Lapack, by Takayuki Miyagi
LUSOL: maintains LU factors of a square or rectangular sparse matrix. This repository provides LUSOL source code and a Matlab interface.
minila: lightweight, standalone set of common linear algebraic operations for vectors and matrices, by Gabriel Brown
moa-fortran: Mathematics of Arrays library for modern Fortran, by Wileam Y. Phan
Monolis: Morita’s non-overlapping / overlapping domain decomposition based linear equation solver. Has both a direct solver (LU) and many iterative solvers
Tangent-linear and adjoint test of a neural network (nn_tl_ad): fully-connected neural network implemented in Fortran, along with its “tangent-linear” and “adjoint” versions (i.e. the Jacobian and transpose of the Jacobian), by Sam Hatfield. It also includes standard tests for the consistency of these.
Field Abstract Calculus Type Usable and Aesthetic Library (FACTUAL): provides abstract types to represent mathematical fields in Fortran, by Chris MacMackin. These are both scalar and vector fields. It also contains (at present) one concrete implementation of these types, using a pseudo-spectral approach and tracking field values at Chebyshev collocation points.
GetRootsF: routines for finding the roots of linear/non-linear equations, with or without derivative information, by Andrew Senchuk
Modern Fortran Utilities (ModForUtils): variety of tasks including computing binomial coefficients, factorials, routines for checking for NaN and Infinity floating point exceptions, root finders, random number utils and array sorters, and findloc, by Richard Weed. Future releases will expand on these utilities and add interpolation routines and other utilities.
NITSOL: Newton-iterative solution of large-scale nonlinear systems, by Homer F. Walker
QD: double-double and quad-double package for Fortran and C++, by Michael Orlitzky and X. Sherry Li
FORbID: object-oriented Fortran 2008 library for numerical integration of definite integrals, by Giacomo Rossi and Stefano Zaghi
differential-evolution_f95: basic differential evolution optimization algorithm, by Ian Morrall
Differential Evolution Parallel Program (DEPP): designed to solve non-linear optimization problems of real-valued functions (objective functions) constrained to boxed domains, by gbertoldo. Additionally, this software is gradient-free, it is not code-invasive, i.e., objective function is treated as a “black-box”, it is tolerant to failures, to poor precision calculated or noisy objective functions, it uses parallelization, that is particularly useful for handling computationally expensive objective functions, and it allows a Response Surface Methodology-Differential Evolution hybridization for convergence acceleration.
Diver: fast parameter sampler and optimiser based on differential evolution, by Pat Scott et al.
Minpack: modernization of the original Fortran 77 code, by Jacob Williams
qnstop: suite of serial and parallel Fortran 95/2003 codes for deterministic global optimization and stochastic optimization by Layne Watson.
quadprog: quadratic programming routine based on R Package sources, by Pedro Ricardo C. Souza. Changed to have a Matlab like interface and usage examples in C and Fortran.
dmr: Fortran 2008 library for mimicking OpenMP device memory routines in Fortran, by Giacomo Rossi
Elements of high-performance computing: general level introduction to high-performance computing, from csc-training
Emulators: emulated collectives collection: collective subroutines and other procedures designed to emulate or extend standard language features, by Damian Rouson. Emulated features include the Fortran 2008 intrinsic function findloc and the Fortran 2018 collective subroutines co_sum and co_broadcast.
matmul_fortran_tensor_core: Example code for calling Tensor Core GEMM from Fortran, by Sam Hatfield
Particle-In-Cell Scalable Application Resource (PICSAR): high performance repository intended to help scientists porting their Particle-In-Cell (PIC) codes to the next generation of exascale computers. PICSAR exploits the three levels of parallelism that will be required to achieve good performances on future architectures: distributed memory parallelization (internode), shared memory parallelization (intranode) and vectorization.
ElliFEM: numerically solves the elliptic family of linear partial differential equations. Examples include the Poisson and Helmholtz equations. Reference: M. Drolia, et al. Enriched finite elements for initial-value problem of transverse electromagnetic waves in time domain. Computers & Structures, 182, 354-367, 2017.
PoisFFT: solves the Poisson equation on a uniform Cartesian grid using the Fast Fourier Transform, by Vladimír Fuka and Javier Alejandro Acevedo Barroso. It calls the library FFTW3 and (if MPI is used) also PFFT.
Spectral Element Libraries in Fortran (SELF): object-oriented Fortran library that support the implementation of Spectral Element Methods for solving partial differential equations, by Joe Schoonover. The SELF API is designed based on the assumption that SEM developers and researchers need to be able to implement derivatives in 1-D and divergence, gradient, and curl in 2-D and 3-D on scalar, vector, and tensor functions using spectral collocation, continuous galerkin, and discontinuous galerkin spectral element methods.
LEcuyer-RNG-Fortran90: pseudo-random number generator, more precisely, a combined multiple recursive generator (CMRG), MRG32k3a, proposed by L’Ecuyer “Good parameters and implementations for combined multiple recursive random number generators”. Operations Research. 1999 Feb;47(1):159-64, by p-serna. This algorithm is well suited for parallel computing as it can initialize many long streams and substreams, with a total period length of 2191 and it passes diehard tests.
pseudo_RNG_modules: pseudo-random number generator modules in Fortran, with option to compile as Python modules and some basic randomness tests in Python, from pointedsphere
amber: evaluate multivariate Bernstein polynomials for multivariate polynomial regression using de Casteljau’s algorithm, by R. Quast
sampleSTAT: command-line application to determine sampling distributions, by Hani Andreas Ibrahim. It goes a lot further than arithmetic mean and standard deviation.
SparseReg: Matlab toolbox for sparse regression calling Fortran code, by Hua-Zhou Hua Zhou and Brian Gaines
System of Sequential Assimilation Modules (sesam): perform the various basic operations that are required in sequential data assimilation systems. These operations include square root or ensemble observational updates (with global or local parameterization of the forecast error statistics), adaptive statistical parameterizations, anamorphosis transformations, or the computation of truncated Gaussian estimators.
M_match: basic implementation in Fortran of a subset of regular expressions as described in “Software Tools” by Kernighan and Plauger, 1976.
FyTest — Instant Fortran unit testing: lightweight unit testing framework for Fortran, by Bálint Aradi. Thanks to its header-only design, it can be easily bundled with any Fortran project without creating extra dependencies.
fortran-machine: MVC web stack written in Fortran 90, by Nick Doiron et al.