The majority of the documentation is in HTML at the Documentation page.
This repository concentrates on those "other" Fortran procedures that solve the day-to-day non-numeric(mostly) issues in programming. Large repositories of numeric algorithms written in Fortran exist at such sites as the netlib repository.
Modern Fortran is quite capable of accessing many commonly available C libraries or expressing many commonly desired utility procedures directly, but the standard language does not define many of these basic interfaces. Because of Fortran's expressiveness and power in HPC environments ( Coarrays, MPI, OpenMP, matrix operators and the many numeric libraries available in Fortran) I prefer we bring these general-purpose utilities to Fortran instead of bringing Fortran to other languages. With that in mind I placed some such modules I have here. I hope others will find them useful (and expand upon them).
GPF(General Purpose Fortran) is the main repository that contains man(1) pages, utility programs, extended examples and unit tests. As generally useful modules mature simpler stand-alone versions are created from this base. That is because the full GPF (General Purpose Fortran repository) has many interdependencies. The extracated stand-alone individual modules are more appropriate if only a specific module is required, and can be found as additional repositories at the GPF site.
But if you want to work with the entire repository this is where new development (and a lot more functionality) is concentrated!
git clone https://github.com/urbanjost/general-purpose-fortran
cd general_purpose-fortran/src
# you might have to change "-lncurses" to "-lncurses -ltinit"
# depending on how ncurses(3c) was built on your machine, and
# have ncurses(3c), readline(3c), sqlite3(3c), X11(3c) and lua(3c)
# installed for all the interfaces to build, but the most
# commonly used interfaces should build without problems.
make -kTo build some of the optional components you may have to install several packages. Starting from a base MINT 20.1 platform (2021-03-07), for example:
sudo apt-get install gfortran
sudo apt-get install libx11-dev
sudo apt-get install sqlite3 libsqlite3-dev
sudo apt-get install libcurl4-gnutls-dev
sudo apt-get install libreadline libreadline-dev
you might want to edit hershey.sh to select where hershey font files will be installed (default is /usr/share/hershey), and then enter ...
bash hershey.sh
if you do not have bash(1) or a Posix shell you will have to run the h2v program for each font, as illustrated by the simple hershey.sh script.
By default, the graphics routines require X11, the ncurses interface assumes libncurses is installed, the SQLite3 interface needs the libsqlite3 library, and the readline interface needs libreadline. These libraries are commonly available on many platforms but you may have to remove some of the files from Makefile if you do not want to build those interfaces.
The GPF (General-Purpose Fortran) repository consists of Fortran modules and libraries (and in some cases their associated C support routines) providing
- command line parsing
- string operations
- a date and time module
- a module that supports basic integrated unit testing
- simple numeric expression parsing
- command line history editing
- The low-level M_draw graphics library, and the beginnings of a pixel graphics module -- both similar to the VOGLE graphics library interface
- libraries for message handling and debugging
- a growing number of Fortran interfaces to common C routines, including
- many POSIX system routines
- a module for reading and writing lines to a process (a popen(3c) interface)
- an interface to the ncurses(3c) terminal screen handling library
- an interface to the sqlite3(3c) SQL file library
- an interface to the regex(3c) Regular Expression library
- routines for controlling the X11 Windows attributes of an xterm(1) terminal emulator, including the program setxt(1)
The majority of these routines come with a man(1) page in *roff and HTML format. An index into the documentation is contained in this distribution and available on the home page
- [overview]
- A collection of programs that use the repository code are included. These range from useful utilities (a pre-processor, an SCCS-style meta-data reader, regression testing utilities, ...) to simple example programs that exercise the modules.
Code additions are strongly encouraged (This is intended to be a development of the Fortran community).
The Fortran Wiki fortranwiki.org contains information on many Fortran resources (If you do not see a link there to your favorites please add them.)
A modern Fortran compiler is assumed. This code has been tested using gfortran GNU Fortran (GCC) 8.3.1 .
M_KRACKEN(3fm): command line arguments
The M_KRACKEN(3f) module makes cracking Unix-like arguments off the command line easy. This version is expanded to allow use in configuration files and interactive input as well, and incorporates additional modules. It requires many other components from the GPF collection, and is used to generate programs that use shell-like input as well as crack command lines.
The M_args(3fm) module supports cracking Unix-like arguments off the command line as a string that can be read as a NAMELIST, eliminating the typical additional steps needed to convert the strings found on the command line to other types.
M_GETOPT(3fm): command line arguments
The M_GETOPT(3fm) module by Mark Gates supports cracking Unix-like arguments off the command line in much the same way as the C getopt(3c) procedure.
M_GETOPT_LONG(3fm): command line arguments
The M_GETOPT_LONG(3fm) module by Joe Krahn supports cracking Unix-like arguments off the command line in much the same way as the SunOS getopt_long(3c) procedure.
convert case, change numbers to strings, strings to numbers, parse on delimiters,edit strings, ... .
Calculate and display date and time values
M_calculator(3fm) is a module for evaluating expressions. The primary routine is JUCALC(3f). JUCALC(3f) evaluates simple numeric and string expressions. This allows your input to use expressions and variable names instead of simple values. You will have to comment out or supply some of the functions called, depending on how f2003-compliant your compiler is.
M_HISTORY(3fm): An interactive input editor module
Acting much like a line-mode editor, the REDO(3f) procedure lets you list, edit, save, and modify your interactively entered program input. Built-in help and no dependence on terminal control sequences makes this a simple-to-master and portable input history editor.
M_READLINE(3fm): calling readline(3c) from Fortran
The readline(3c) routine lets you edit and then execute previously entered commands. An interface using a small C routine and the standard ISO_C_BINDING module lets the commonly available C routine be called from Fortran. The readline(3c) library is required.
M_JOURNAL(3fm), M_MESSAGES(3fm)
journaling, logging, and general messaging routines that let you have a single routine filter output to journal files; display attention-grabbing messages or reformat messages.
These routines are useful for constructing unit tests for code and for adding debug modes to routines and applications.
The PARANOID program converted into subroutines that can be called from your programs to verify compiler behavior.
M_LOGIC(3fm): conditionally select input
The M_LOGIC(3f) module allows you to use if/else/elseif/endif directives in your input; allowing conditional selection of input lines. Requires an expression parser. It uses JUCALC(3f) by default.
Input/Output
GETKEY(3f): read a character from the keyboard in "immediate mode"
A simple C routine for most Unix and GNU/Linux systems that immediately reads a single character keystroke from the keyboard without waiting for a carriage return. An interface using the ISO_C_BINDING interface allows the routine to be called from Fortran.
Read and write from a process using popen(3c)
- Environment
- Directories
- File status and attributes
- Error code
- Process management
And other commonly called C system routines interfaced to Fortran. Makes heavy use of the ISO_C_BINDING module introduced as part of Fortran 2003.
Call the POSIX regular expression library.
A basic interface to the SQLite3 library using the ISO_C_BINDING module and C/Fortran interoperability modeled iniitially on the FLIB interface.
M_NCURSES(3fm), M_FIXEDFORM(3fm)
A Fortran module and a few related files create an interface from Fortran to the C ncurses(3c) library; allowing Fortran programs to read function keys and characters one at a time and to control the characters on the screen on a character-cell by character-cell basis.
File characteristics
Input/Output
Signal management
Sockets
database
encryption
internet
runtime
opengl
parallel
overloading
structures
Additional Utilities
Routine Categories Descriptions
A Fortran module containing routines to perform equality and relational comparisons on floating point numbers. That is, you can more safely compare real numeric values.
Fortran KIND definitions used by other parts of the basic utilities
compare two real numbers only up to a specified number of digits
The M_draw module is an interface to a C library based on the VOGLE graphics library. It is supplemented by higher level modules.
The M_pixel module is a PRELIMINARY collection of routines that use 2D- vector routines to create or modify a pixel array, which can then be written as a GIF file.
The M_color module is a collection of color-related procedures. Routines to convert between different color models, return RGB values given common X11 color names, and other simple color-related operations.
The M_xterm module is a collection of routines that use escape sequences to set and query xterm(1) X11 Windows attributes such as window size, background and foreground color, font, and cursor color. The program setxt(1), included in the GPF distribution, allows for easily using the module capabilities from the command line.
sorting routines encapsulated in a module
simple generic sort procedure
swap two variables
A collection of routines for basic geometry, curve fitting and interpolation, basic statistics, ...
A collection of unit conversions and constants. Allow degrees instead of radians in trig functions; convert between Celcius and Fahrenheit, ...
An example program that combines many of the components into a simple calculator-like utility that parses command line arguments, evaluates Fortran- like expressions, draws in pixel arrays, allows calls to ncurses, has interactive command history recall and editing, and supports if/else/elseif/endif directives can be found in shell.ff.
GPF is bundled as an fpm package.
Download the github repository and build it with
fpm ( as described at Fortran Package Manager )
git clone https://github.com/urbanjost/general-purpose-fortran.git
cd general-purpose-fortran
fpm test # build and then run unit testsor just list it as a dependency in your fpm.toml project file.
[dependencies]
general-purpose-fortran = { git = "https://github.com/urbanjost/general-purpose-fortran.git" }- A
fordconfiguration file is available to build documentation - A
doxygenconfiguration file is available to build documentation