Up: Linux Software Encyclopedia
Last checked or modified: Dec. 15, 1999
- An attribute grammar (AG) system based on strongly non-circular AGs
that perform extensive space optimizations.
The features include:
- an input language containing sublanguages including
attributed abstract syntaxes (ASX), attribute grammars and
declaration and definition modules;
- efficiency via completely deterministic generated evaluators that
also allow the application of effective space optimization techniques;
- a choice of exhaustive, incremental, and parallel attributes
- a choice of implementation languages including
C and ML.
FNC-2 contains several companion processors for building complete
- a generator for abstract tree constructors;
- a generator for unparsers of attributed abstract trees;
- a tool for describing the modules of an application;
- an interactive application description utility;
- an interactive circularity tracing system; and
- source-level optimizations of AGs resulting from descriptional
- A documentation tool for Fortran 90 written by Erik
Demaine. f90doc generates pages of HTML documentation from Fortran 90
source. The documentation is derived from comments prefixed with !! written
(if desired) in a simple and intuitive documentation language whose source is
easily readable in the code itself, while formatting nicely in HTML. f90doc is
similar to javadoc, but does not require comments to be written in HTML.
- A Fortran interface for
GLUT which can also be used
with other implementations of
It provides interfaces for both Fortran 77 and Fortran 90.
- A Fortran 90 to C
compiler in the very early stages of development (6/99).
- A Fortran 90
to C++ converter that's
in the early alpha stage of development (6/99).
- A package of elementary and special functions extracted from
the SLATEC library for the
The functions can be divided into several categories
according to functionality.
The intrinsic and fundamental functions include:
R9UPAK and R9PAK, to unpack and pack floating point
INITS, to initialize an orthogonal polynomial series; and
CSEVL, to evaluate a Chebyshev series.
The elementary functions include:
CBRT, for cube roots; and
EXPREL, relative error exponential from first order;
CLOG10, common logarithm; and
ALNREL, the relative error logarithm.
The trigonometric and hyperbolic functions include:
COT, SINDG, COSDG,
CASIN, CACOS, CATAN, CSINH, CCSOH,
CTANH, ASINH, ACOSH, ATANH.
The exponential integrals and related functions include:
EI and E1, exponential integrals; and
ALI, the logarithmic integral.
Gamma and related functions include:
GAMLIM, gamma with under- and over-flow limits;
GAMR, reciprocal gamma;
ALNGAM, log absolute gamma;
GAMI, incomplete gamma;
GAMIC, complementary incomplete gamma;
GAMIT, Tricomi's incomplete gamma;
PSI, psi (digamma);
POCH, Pochhammer's generallized symbol;
ALBETA, log beta;
BETAI, incomplete beta;
ERF, error function;
ERFC, complementary error function;
and DAWS, Dawson's function.
Several Bessel functions are available including:
Bessel functions of special integer order of the first and second
kind and order zero and one;
modified (hyperbolic) Bessel functions and those scaled by
an exponential of the same varieties;
sequences of Bessel functions of general order of modified first,
first, second, and modified third kinds; and
sequences scaled by an exponential.
Available Bessel functions of fractional order include:
AI, Airy functions;
AIE, exponentially scaled Airy functions; and
CHU, confluent hypergeometric functions.
A source code distribution of this package is available.
All of the routines are written in Fortran 77 and are
documented via comment lines within each source code file.
This is part of CMLIB via
- An experimental CORBA ORB written in
Fnorb gives the Python programmer access to CORBA by supporting
all CORBA 2.0 datatypes and providing a full implementation of
It can be used as a CORBA scripting tool and for building test
harnesses for CORBA development projects as well as for prototyping
Fnorb requires a 3rd party interface repository to parse and store
IDL definitions. The OmniBroker
package is recommended by the developers.
- A mathematical visualization system that provides a
purely functional, collection-oriented language with
symbolic differentiation and optimization. You can type
in a parametric equation and see the resulting curve or
surface. The source code is available as are binaries
for Sun SPARC, SGI IRIX, and Linux platforms. A manual
is available in PostScript
- The Fast Operating Algebraic Manipulator
is a computer algebra program for high energy physics.
The capabilities of FOAM include:
- substitutions of products;
- vectors, vector indices, and metric tensors with high energy
physics constructions such as massless vectors, orthogonal
vectors, symbolic or numeric dimensions, and parenthesized
- jumping symbols which enable complex numbers, nth roots, and
truncated expressions to be implemented;
- optimization for calculations where large numbers of terms are
equal to zero;
- built-in debugging;
- modular C++ code which allows any algebraic abstraction to
be plugged into the existing data structures via inheritance;
- substitutions of sums;
- rational arithmetic and division of polynomials;
- Levi-Civita or alernating tensors;
- gamma matrices and spinor products; and
- user-defined functions.
A source code distribution of FOAM is available. It is
written in C++ and can be compiled
with most C++ compilers.
The front end also uses Bison, Flex, and
Perl to generate files.
The documentation is presently (7/97) scattered in
various hypertext files online.
- The FOrm-based Customizable User Shell is
a form processor that provides an easy way to maintain a set of fill-in
forms that can be submitted via email.
In a broader sense, FOCUS is an interactive interpreter and displayer
of forms written in Focal (i.e. the Form Composition Almost-Language).
It was originally designed as an interactive form processor but evolved
into a general purpose front-end that can be used in almost any
UNIX application and which provides a hypertext-like method of
navigation between forms.
A form in the context of FOCUS is a description of a screen that can
contain straight text, editable text fields, text fields with a finite
number of preset values, and buttons that can perform some action.
Forms can also be modified in several ways, with the options available
in the creation of forms including non-editable text fields, fields
which require a value, fields for which the entered value must fulfill
a specific requirement, default values, variables, dialog boxes,
selection boxes, display boxes, and conditionally invisible lines.
These capabilities provide a unified screen-based environment for
users in the UNIX environment who for whatever reason don't want or
have an X11-based GUI alternative.
A source code distribution of FOCUS is available.
Installation and use also requires the prior installation of
Documentation is included in the distribution.
- Fred's Own Filemanager is a graphical filemanager
that acts as a front-end to several UNIX
It is intended to provide a powerful user interface with contextual
menus, drag and drop, multiple windows, and many other features.
It is also highly customizable, allowing new programs and menus
to be created.
This is part of the eXode project.
- An astrophysical program which uses the
Friends-Of-Friends method to find groups in
the output file generated by an N-body simulation.
A particle belongs to a friends-of-friends group if it is within
some linking length of any other particle in the group. After
all such groups are found those with less than a specified number
of group members are rejected. FOF reads files in the
TIPSY array format and writes output to
The source code for FOF is available. It is written in ANSI C
and can be compiled on generic UNIX platforms.
It is documented in a man page.
FOF is part of the
HPCCSOFT Tools suite.
- A set of TeX macros that allow users to install
virtual fonts. Fontinst can convert fonts from Adobe Font Metric
(afm) or TeX Property List (pl) format into
Virtual Property List (vpl) format. These Virtual
Fonts (vfs) can then be used by device drivers such
The features of the package include:
A source code distribution of fontinst is available.
It is written in TeX and documented in LaTeX format.
- written in TeX for maximum portability;
- support for the OT1 (Computer Modern) and T1 (Cork) encodings;
- allowing fonts to be generated in an arbitrary encoding, e.g.
the `ij' character can be faked by putting an `i' next to a `j';
- allowing caps and small caps fonts with letter spacing and kerning;
- allowing kerning to be shared between characters, e.g. `ij' can be
kerned on the left/right as if it were an `i'/`j';
- allowing the generation of math fonts with nextlarger, varchar, and
arbitrary font dimensions;
- allowing more than one PostScript font to contribute to a TeX font;
- automatic generation of an fd file for use with
- user-customizable to deal with arbitrary font encodings.
- Available programs for working with fonts in various formats as well as the
fonts themselves include:
- A command-line utility program for building a 3-D model (i.e. object
description) of a word or phrase in any
TrueType font. The generated
model can be used by a rendering program to generate nice looking images.
The features include:
A source code distribution is available.
- support for both Macintosh and Windows TrueType fonts;
- beveling with either flattened or rounded edges;
- use of interpolated triangle patches to build a smooth text object;
- storing frequently used options in config files;
- including length, width and height information in the output file;
- assigning a separate texture identifier to each part of an object; and
- controlling the visibility of each part of an object.
- A graphical interface to Font3D built using
the XForms library.
- Font Utilities
- The GNU font utilities are a package of
tools for manipulating fonts in various ways.
The capabilities include converting scanned images into bitmap
fonts, hand editing bitmaps, conversion of bitmap fonts to
outline fonts, and more.
With this package you can start with a scanned image of artwork
and finish with a font complete with accented characters,
ligatures, and the works.
The font formats used by these programs are mostly those used
by the TeX package, although output of
PostScript Type 1 fonts is also
The programs in the Font Utilities include:
- Imageto, which converts an image file (in either PBM
or IMG format) to either a bitmap font or an Encapsulated
PostScript File (EPSF);
- IMGrotate, which rotates an IMG file either 90 or 180
- Fontconvert, which performs various manipulations such as conversion
to other formats, merging multiple fonts, adjusting individual
characters, and moving characters around within a font;
- Charspace, which allows you to add side bearings (i.e. the
blank spaces on either side of a character) to a bitmap font;
- Limn, which converts a font from a bitmap to an outline
by fitting curves to the pixels;
- BZRto, which translates an outline font in BZR outline font
format to other formats including Metafont,
Type 1 and Type 3 PostScript, and BPL;
- BPLtoBZR, which translates a human-readable text file in
BPL format to a binary BZR font format;
- XBfe, an X Bitmap Font Editor which allows the hand-editing
of the shapes and the metric information of a bitmap font;
- BZRedit, which allows the hand-editing of outline fonts in
BZR font format as output by Limn; and
- GSrenderfont, which uses GhostScript
to rasterize a PostScript outline font at a particular point size
A source code distribution of the Font Utilities is available.
It is written in C and can be compiled and installed via the
included configure script.
It is documented in a 95 page user's manual available in
- The Fuzzy Organizer OLdenburg is a graphical
user interface used to develop
fuzzy rulebases. It can be
used to create and maintain a database which specifies the
behavior of a fuzzy controller.
FOX is a small but powerful fuzzy engine which reads data
from this database along with some input values and then
calculates new control values.
The features of FOOL/FOX include:
- an interactive FOOLproff development interface based on
the XView library;
- support for most known fuzzy operators (36 to date) and
full support of parameterized operators;
- five types of standard membership functions plus an unlimited
number of user defined membership functions;
- user-defined internal calculation precision;
- fuzzy and/or crisp input and output values;
- building multi-stage and/or parallel fuzzy
systems via shell scripts;
- an ASCII database format for better readability; and
- visualization of linguistic variables and operators via either
Khoros or Gnuplot.
The FOOL/FOX package is available as source code or in binary
format for Linux Intel, DEC OSF/1 and Ultrix, and Sun Solaris platforms.
It is written in ANSI C for portability and includes an
autoconfig file for easy compilation.
The GUI requires the XView library and visualization of results
either Khoros or Gnuplot.
The package is documented in a 100+ page user's manual in
- A print formatter driven by XSL formatting
objects, i.e. a Java application that reads
a formatting object tree and turns it into a
The formatting object tree can be in the form of an
XML dcoment or can be passed in memory
as a DOM document or
- This is a computerized symbolic manipulation program designed
for virtually infinite formulae. As such it is less general than
other such programs (e.g. Mathematica, Maple, etc.), but the
design differences allow it to perform calculations involving
formulas with over a hundred thousand terms efficiently where
the other systems might fail or be undesireably slow. This is
an earlier version of what is now a commercial product. There
is a 250 page manual in
dvi format at the same site.
- formal methods
- Format methods are mathematical techniques for the specification and
design of hardware or software systems.
The are used to reason about requirements and to detect inconsistencies,
investigate the consequences of design decisions, and test the
suitability of an implementation before a system is built.
Systems that implement some form of formal methods include:
- Forte for Java
- An IDE for Java built on top of NetBeans for modularity and
The features of the freely available Community Edition include:
- a suite of tools inclding an application browser, Java source
editor, debugger, compiler and online help;
- a modular framework source code based on open APIs allowing
the easy development of plug-ins;
- support for the latest standards, e.g. Java 2, Swing, JFC,
Java2D, Collections and accessibility APIs;
- a form editor providing a graphical development environment;
- a class browser for displaying the structure of class files without
- an HTML browser for online help and tutorial access;
- a deployment wizard for quickly creating deployable JAR files of
applets, applications and JavaBeans; and
- an advanced debugger with conditional breakpoints, breakpoint
logging, an evaluator, code stepping and watches for finding bugs.
- A stack-based, extensible language without type checking which
uses postfix, i.e. reverse Polish, notation. The fundamental
program unit in Forth is the word, i.e. a named data item, subroutine
or operator, and programming consists of defining new
words in terms of existing words.
Forth was invented in 1970 and was reknowned for high performance
as well as an economical use of memory, with the latter quality
keeping it popular for use in embedded microcontroller systems.
The interactive nature of Forth streamlines the testing
and development of new hardware.
The features which facilitate this include
a fast program-debug cycle,
full interactive access to any level of the program,
and the ability to work at a high level of abstraction.
Freely available implementations of Forth include:
An interesting project for scientists using Forth is the
Forth Scientific Library Project.
Introductory textbooks are
Katzen (1981), and
Kelly and Spies (1986).
More advanced texts include
Noble (1992), and
A history of the language can be
found in Rather et al. (1993).
- A Fortran 77 code for calculating ocean
acoustic transmission using the parabolic equation method.
The only substantial documention for this seems to be buried
in an old technical report, i.e. Botseas et al. (1987).
- A package that translates Forth source code to
C source code.
This is implemented as an enhancement to the
gforth compiler system.
- A compiler and interpreter which runs most Forth
A source code distribution is available which can be compiled
on most UNIX flavors.
Extensive documentation is available in ASCII format.
- Forth Scientific Library
- A project to write a set of Forth words
to implement such (currently available in
Fortran) scientific libraries
as the ACM libraries, BLAS,
A reasonably large selection of special functions and integrals,
interpolators, transforms, and matrix algorithms are
currently (10/97) available.
- A Forth-to-C compiler.
- The FORmula TRANslation
programming language was the
first successful so-called high level language (HLL) wherein
source code was compiled to object code using an optimizing compiler.
It is still the most widely used language for scientific and
numerical work for a couple of reasons. First, the currently available
compilers still produce the fastest executable code most of the time,
although significant advances have been made on C++
compilers in recent years.
Second, there is a huge amount of legacy or dusty deck code written
in Fortran as well as a couple of generations of dusty deck scientists
and programmmers that supply significant inertia for its further use.
The gap is closing fast, though. A brief perusal of the
C++ section of this document will show an
enormous amount of work and code produced for numerical purposes in
just the last five years, and there is an almost continuous debate over
the relative merits of the languages on various Usenet groups.
The first version was called FORTRAN I with the compiler designed and
written by a group at IBM from 1954-1957 led by John Backus (who also
co-designed to IBM 704 computer that ran the compiler).
FORTRAN II in 1958 added capabilities for separate compilation of
modules and linking assembly language modules.
This was quickly followed by FORTRAN III in the same year which, although
never publicly released, made it possible to embed or inline assembly
code within Fortran code.
FORTRAN IV, released in 1961, provided many fixes and improvements over
II along with a II to IV translator to ensure backward compatibility.
The development of a FORTRAN standard began in 1962 and culminated in
the 1966 ASA standard commonly referred to as FORTRAN 66.
This remained the standard until the adoption of FORTRAN 77 a little
over a decade later.
The adoption of the next standard, eventually to be called Fortran 90, was
a long time coming. It was informally called Fortran 8X until the process
dragged into the 1990s, a delay which mainly allowed other languages,
chiefly C and C++, to significantly catch up as competitor numerical
computation languages. Fortran 90 was a significant advance over the previous
version and included such major changes and features as:
Fortran 90 is, with a few exceptions, a superset of Fortran 77.
As such, compilers should be able to compile most standard-conforming
legacy Fortran 77 codes.
- array processing extensions to allow arrays to be
accessed and treated as variables;
- dynamic memory allocation;
- user-defined types and operators for improved data abstraction;
- extended control of numerical precision for increased architecture
- object-oriented programming features such as derived types and
- stream character-oriented I/O;
- more modern control structures such as CASE and DO WHILE;
- the use of modules and procedures for writing more reusable code;
- many new intrinsic functions;
- pointers for the more flexible control of data placement; and
- a free format source code form.
The most recent (11/98) version of the Fortran Base Language Standard
was published in December 1997 and is known as Fortran 95.
It is mostly a minor enhancement of Fortran 90, consisting of a few
new features along with corrections to defects found in Fortran 90.
The new features include:
- the FORALL statement as an alternative to DO;
- partial nesting of FORALL and WHERE statements;
- a masked ELSEWHERE statement;
- pure and elemental procedures;
- revised MINLOC and MAXLOC;
- extensions to CEILING and FLOOR with the KIND
- pointer initialization;
- increased compatibility with IEEE arithmetic;
- a CPU_TIME intrinsic subroutine;
- automatic deallocation of allocatable arrays at exist of scoping unit;
- NAMELIST comments; and
- a complete version of END INTERFACE.
A major revision informally called Fortran 2000 is currently being
developed and will include such major new features as:
- exception handling;
- facilities to simplify interoperability with C so operating system
features can be more readily accessed;
- improvements to derived data types to allow allocatable components
and parameterized types;
- new I/O capabilities such as asynchronous and derived type I/O; and
- new object-oriented programming features.
There are several freely available options for those who want to
use some version of Fortran on Linux systems including:
There are also several commercially available
options, the details of which can be found at the URLs given below.
- ADAPTOR, translates HPF into Fortran 77/90
with message passing commands;
- g77, a Fortran front-end to the GNU
- egcs, a development version of the GNU
compiler suite that includes g77;
- F90toC++, a Fortran
90 to C++ converter;
- f2c, a Fortran to C translator;
- fort77, a script front-end to f2c;
- F, a compiler that implements a subset of
- OOF, a set of object-oriented extensions to
Fortran that require that a Fortran compiler already be present on
- SHPF, a public domain
HPF 2.0 compilation system; and
- vf90, a F90 compiler that works with
Useful Fortran resources include:
Metcalf and Reid (1996),
Ortega (1994a) and
Press et al. (1994b).
Fortran 90/95 related programs include:
- ISO-VST, a 95 module for manipulating character
strings of arbitrary and dynamically variable length
- VPA, a 95 module supporting variable and arbitrary
precision floating point arithmetic
Fortran-related programming tools include:
- Basis, a system for developing interactive
programs in Fortran;
- cfortran, for creating machine-independent
interfaces between Fortran and C;
- egcs, a Fortran compiler system;
- F, a compiler for a subset of Fortran 90;
- fgen, a makefile and dependencies generator for
Fortran 77 and 90;
- FLIB, a library for non-standard tasks;
- flib2c, a program for calling Fortran libraries
from C programs;
- Flop/Flow, for checking Fortran code and
creating summary reports about its structure;
- f90doc, a documentation tool for Fortran 90;
- f90gl, an interface to Mesa;
- f2c, a Fortran to C translator;
- f2cl, a Fortran to Lisp translator;
- Fortran Test Suite, for determining
how much a compiler conforms to the FIPS Fortran standard;
- fort77, a driver for f2c;
- ForUtil, utilities for performing bookkeeping,
database and flow tracking chores;
- ftnchek, a Fortran code checker;
- fxdr, for converting from internal to XDR format
- FXDR, for making calls to XDR routines from Fortran;
- GDB, a debugging program with Fortran support;
- gema, a general purpose macro processor;
- g77, a Fortran compiler system;
- HPF, a set of Fortran extensions for distributed
and parallel processing;
- HPFfe, an HPF front-end;
- libU77, a Fortran system library for UNIX;
- m4, a macro preprocessor;
- MPFUN, for performing multiprecision calculations;
- NetCDF, a scientific data format library;
- plusFort, a toolkit for Fortran programmers;
- PREP, a preprocessor for Fortran programs;
Software libraries written in Fortran include:
- AGL, a graphics library with a Fortran interface;
- ALFPACK, for computing Legendre functions;
- AMOSLIB, routines for evaluating special
functions of mathematical physics;
- ARCH, statistical programs for working
with univariate models;
- ARPACK, for solving large eigenvalue problems;
- AtmosThermoPack, programs for the
analysis of thermodynamic quantities;
- BAYESPACK, routines for Bayesian analysis;
- BLACS, linear algebra programs for distributed
- BLZPACK, an implementation of the block
Lanczos algorithm in linear algebra;
- BPKIT, block preconditioners for the
iterative solution of linear systems;
- BSPLINE, for manipulating B-splines;
- Cheney-Kincaid, programs from a
textbook on numerical mathematics;
- CLAWPACK, for solving hyperbolic systems
of conservation laws;
- CMLIB, a huge collection of packages for
various numerical tasks;
- CONFPACK, for conformal mapping;
- DCDFLIB, statistical programs for computing
cumulative distribution functions and related quantities;
- DEPAK, for solving ODE initial value problems;
- DIERCKX/FITPACK, subroutines for
calculating smoothing and tensor product splines;
- DISLIN, a graphics library;
- dsplib, a library of digital signal processing
- DT-NURBS, a spline geometry library;
- EDA, routines for exploratory data analysis;
- EISPACK, for computing eigen-quantities;
- FC, a library for least squares problems;
- FCNPACK, for computing Legendre functions and
- FFTPACK, for performing FFTs;
- FISHPAK, for solving elliptic PDEs;
- FITPACK, a general purpose curve fitting package;
- FNLIB, a library of special functions;
- GBIT, a library for handling binary packing;
- GENZPACK, a library for the numerical computation
of multiple integrals;
- GEOMPACK, for generating meshes using geometric
- GEOPACK, subroutines for magnetospheric modeling
- GPLOT, a plotting library for creating CGM files;
- GSLIB, for performing various geostatistical tasks;
- HDF, a library for converting data to a standard
- HOMPACK, subroutines for solving nonlinear
systems of equations via homotopy methods;
- HOPDM, a library for solving large-scale
linear programming problems;
- INTLIB, a portable interval arithmetic library;
- iplib, for interpolating between almost any
types of grids;
- ITPACK, for solving large, sparse systems of
linear equations using accelerated iterative algorithms;
- LANCZOS, for finding eigen-quantities using
- LAPACK, for solving almost any problem related
to linear algebra;
- Lawson-Hanson, for solving least squares
- LINDRV, an interface to LINPACK for the solution
of linear systems in several forms;
- LINPACK, routines for analyzing and solving
linear equations and least-squares problems;
- L-moments, for statistical analysis using
- MANPAK, for computations with manifolds implicitly
defined by systems of nonlinear equations;
- MAP, for calculating the material properties of
steel, nickel and crystals;
- MARS, for using multivariate adaptive regression
splines for data fitting and function approximation;
- MIEPACK, for calculations in electromagnetic
- MINPACK-2, for solving systems of nonlinear
equations, nonlinear least squares problems, and minimization problems;
- MUDPACK, for solving linear elliptic PDEs
using multigrid algorithms;
- NAPACK, for numerical linear algebra and
- NSPCG, for solving large sparse systems of
linear equations via iterative methods;
- NSWC Library, a little bit of everything;
- ODEPACK, for solving the initial value problem
- ODRPACK, for fitting a model to data;
- ParPre, parallel preconditioners for iterative
solvers of linear systems;
- PCG, for solving linear equation systems using
gradient-type iterative methods;
- PCHIP, for the piecewise cubic Hermite
interpolation of data;
- PDELIB, for solving systems of nonlinear,
initial and boundary value PDEs;
- PGPLOT, a graphics library;
- PIM, for solving systems of linear equations on
parallel computers using iterative methods;
- PlotPlus, a scientific graphics library;
- PLplot, a scientific graphics library;
- PORT, a huge library of mathematical subroutines;
- PRL, a family of libraries for data types, system
functions, and graphics;
- PROFIL/BIAS, for interval arithmetic;
- PseudoPack, for numerical differentiation
by pseudospectral methods;
- PSPLOT, for generating 2-D PostScript graphics;
Fortran programs or small groups of programs include:
- ACDC, an automatic continuation code for
solving boundary value problems;
- Acoustics Toolbox, a set of
packages for ocean acoustics modeling;
- ADAPT, an adaptive multidimensional integration
- ADAPTOR, an HPF package;
- ADIFOR, for the automatic differentiation
of Fortran 77 programs;
- ALCON1, ALCON2 and
ALCON-S, for solving algebraic systems of
equations via the continuation method;
- ANRAY, seismological programs for the
computation of rays;
- ARTA, a time series analysis package;
- ASURV, statistical programs for censored data;
- AUTO, for working with continuation and
bifurcation problems in ODEs;
- BALNINPT, for chemical reactions between
ground water and minerals or gases;
- BASIN, a
finite element program for simulating
the filling in of a sedimentary basin;
- BIE, a boundary element package;
- BILUM, for solving sparse linear systems;
- BL2D, for creating 2-D anisotropic or
- BMP, a multi-precision package;
- BOCLS, for solving bounded and constrained
linear least squares problems;
- BPMPD, a primal-dual interior point
algorithm for solving optimization problems;
- BTN, for unconstrained nonlinear minimization;
- BVPLSQ, for highly nonlinear two-point BVPs;
- BVPSOG, for two-point BVPs;
- CCP5, molecular dynamics programs;
- CDRIV, programs for solving ODEs with
- clusfind, programs for cluster analysis;
- CLUSTER, multivariate cluster algorithms;
- COLNEW, for solving boundary value problems;
- CONTIN, a continuation algorithm for nonlinear
- COSMICS, for cosmological modeling;
- COUPLE, for underwater acoustics modeling;
- CPQR79, for computing zeros of polynomials;
- CUTE, routines for linear and nonlinear
- DASSL, for solving differential-algebraic
- ddcon2d, for solving the 2-D Navier-Stokes
equations for Boussinesq convection;
- DDSCAT, for scattering and absorption of
- DIFEX1, DIFEX2 and
DIFEXM, for integrating non-stiff ODE systems;
- DISORT, for radiative transfer calculations
in multi-layered plane-parallel media;
- DOM, a radiative transfer model;
- EPIC, an oceanographic data analysis system;
- EULEX and EULSIM,
integrators for non-stiff ODE systems;
- EVP, a sea-ice dynamics model;
- FANTOM, for calculating properties of
proteins and polypeptides;
- FEAT, for solving PDEs using
- FitExp, for least-squares fitting of data;
- FLEXTRA, a kinematic trajectory model;
- GAM, for solving 1st-order stiff and non-stiff
- GBIT, for solving large, nonsymmetric linear systems;
- GELDA, for solving linear differential-algebraic
equations with variable coefficients;
- GEO-CGM, for calculating corrected geomagnetic
- GIANT, for solving large-scale, highly nonlinear
- HARPA, HARPO and
HARPX, 3-D Hamiltonian ray tracing programs;
- HSPF, a hydrological simulation program;
- HYPOELLIPSE, for determining the hypocenters
of local or regional earthquakes;
- ICAM, an idealized atmospheric circulation model;
- KEPLEX, an explicit extrapolation integrator
for non-stiff 2nd-order ODE systems;
- KRONOS, a 3-D cosmological hydrodynamics code;
- LANCELOT, for solving large-scale nonlinearly
constrained optimization problems;
- LANZ, for solving the large sparse symmetric
- LARKIN, for solving large systems arising in
chemical reaction kinetics;
- LASO, for computing a few eigenvalues of large
sparse symmetric matrices;
- LIMEX and LIMEXS, for
solving linearly implicit differential-algebraic systems;
- LOTPS, for solving the scattered data
- Madpack5, a multigrid package for
- mc-layer, a Monte Carlo radiative transfer
program for atmospheres;
- MEBDFDAE, for solving stiff initial value
problems and DAE in linearly implicit form;
- METAN, an integrator for stiff systems of
- MEXX, for integrating constrained mechanical
- MGGHAT, a multigrid program for solving
2nd-order linear elliptic PDEs;
- MIEV, for electromagnetic scattering from
a homogeneous sphere;
- MM5, a meteorological circulation model;
- MOM, a modular ocean circulation model;
- MTM-SVD, for climate signal detection;
- MWMOD, a radiative transfer code for microwave
- MXENTRP, for computing maximum entropy
estimates of time series data;
- NETPATH, for calculating geochemical mass
balance reactions in hydrology;
- NLEQ1 and NLEQ2, for
solving nonlinear equations;
- NLSCON and NL2SN, for
solving nonlinear least squares problems;
- NNES, for solving nonlinear equations;
- OASES, an ocean acoustics propagation package;
- PCCM, an atmospheric general circulation model;
- PolRadTran, an atmospheric radiative transfer
- POM, an ocean circulation model;
- PSTSWM, a shallow water circulation model;
- Fortran Test Suite
- A suite of programs for determining the degree to which a Fortran compiler
conforms to the FIPS Fortran standard.
The suite consists of programs containing features of Standard Fortran,
their related data, and an executive program that prepares the audit
routines for compilation.
- A compiler-like driver for f2c (written in perl) that
will allow you to transparently compile Fortran code using
your C compiler and the f2c translation package.
- A collection of Fortran 77 utilities for performing various
bookkeepping, database, and flow tracking tasks. The utilities
also three tools for the creation (scan_commons),
examination (list_commons) and
of a database that contains all common statements defined in a
collection of Fortran include files. The source code for ForUtil
is available as well as binaries for Linux (a.out and ELF),
SunOS, HP-UX, IRIX and MS-DOS systems. The documentation is
contained within man pages for each program.
- fflow, a program to generate graphs that indicate the flow
in a program;
- ffscan, a subroutine argument checker; and
- ftags, a tag generator that generates case-insensitive
tags in Fortran files and is used with the vi editor.
- A standards-based suite of software for web application
development. The components include:
- 4DOM, a implementation of the standard
DOM API for HTML and XML content manipulation, with
full distributed-object support based on the IDL used in the formal
- 4XSLT, an XSLT processor implementing
the full XSLT 1.0 specification for, e.g. rendering XML documents as
customized and stylized HTML and providing an API for applications to use
for low-level, customized transformations of XML documents;
- 4XPath, a library implementing the full
XPath 1.0 specification for indicating and
selecting portions of an XML document;
- 4ODS, a Python implementation of the
ODMG 3.0 object database standard;
- 4RDF, a library implementing the RDF
specification for managing metadata in distributed applications and
on the web; and
- 4XLink, an extended link toolkit implementing an extensible
linking language for XML objects.
- A numerical model for simulating unsteady, one-dimensional flow in
networks of open channels.
FOURPT includes several useful options including the selection
of governing equations (kinematic, diffusion, or dynamic),
boundary value perturbations, and user-programmable constraint
It can simulate non-trivial concepts such as flow in complex
interconnected channel networks, meandering channels with variable
effective flow lengths, hydraulic structures define by unique
three parameter relations, and density-driven flow.
Channel geometry can be rectangular, trapezoidal, or irregular
depending on whcih channel property module is used.
FOURPT uses a four-point-implicit finite difference solution scheme.
The simultaneous equations are solved by Gaussian elimination using an
indexed, asymmetric, sparse matrix solver particularly useful for
applications involving large, complex networks of interconnected
All relations that constrain unknown variables, discharge and water
surface elevation at boundaries and channel junctions are implemented
A source code distribution of FourPt for UNIX platforms is
The primary documentation is contained within
DeLong et al. (1997).
This is part of the USGS
Water Resources Applications Software
- Free Objects for X is
a C++-based toolkit for developing GUIs.
FOX includes a wide range of controls and provides state of the
art facilities such as drag and drop, selection, and
OpenGL widgets for 3-D graphical manipulation.
It also implements icons, images, and user conveniences features such
as status line help and tooltips.
FOX is designed to be fast, to minimize memory use, and to be easy to
program (with most controls capable of being created with a single
line of code).
The modern GUI features of FOX include:
A source code distribution of FOX is available. It was designed and
built on a Linux box.
- easy to use facilities for creating and using icons and images with
support for both GIF and BMP formats;
- support for tool tips and balloon help;
- support for more extensive help information via the status line;
- tab books for allowing several panels of GUI widgets to be placed
on top of each other and flipped through like file folders;
- tree lists for providing a concise view of a hierarchy and allowing
users to open and close sublists with a mouseclick;
- Multiple Document Interface (MDI) widgets for supporting both single
and multiple document interface applications;
- 3-D OpenGL widgets;
- support for drag and drop using XDND;
- the transfer of data between widgets via the X Selection mechanism; and
- support for both scheduled timers and idle processing.
- A visual development environment for the FOX
- A Python interface modules that provides an
interface to the FOX GUI library.
- fOX Project
- An attempt to create a suite of useful applications for
UNIX in an organized fashion.
The project uses the Xclass
toolkit to provide a simple and uniform way for programmers
to access widgets which have the Win95 3-D look and feel.
The goal of the fOX Project is to provide X11 applications
to the UNIX community which will allow them to make full use
of the operating system without having to resort to the use
of Windows emulation software, with the applications portable
to any machine on which Xclass will compile.
- A 32-bit Pascal compiler. PFKPascal features include
generation of true 32-bit code (i.e. no 64 kB limit for arrays
or 640kB limit for programs and data), close compatibility with
Turbo Pascal 7 (including objects, graph unit and FreeVision),
some extensions from C++ (i.e. procedure overloading and
exception handling), availability of the Pascal source code of
the compiler (which can compile itself), and more.
It presently (9/96) has only a command line interface although
and integrated development environment (IDE) with and editor
and debugger is in the works.
- The Frexx Programming Language is an interpreted
or macro language in a shared library designed to be flexible
and easily embedded in any code.
FPL is a complete script programming language that bears more than
a little resemblance to C.
A source code distribution is available as are several documents
describing its use.
- Functional PostScript is a portable
system for doing device- and resolution-independent
graphics from Scheme programs.
It is PostScript with the
Forth computational engine replaced
with Scheme. It is tightly based on PostScript and uses
exactly the PostScript base rendering primitives, e.g. lines,
curves, arcs, glyphs, and bitmaps. Full control of the
rendering engine's style parameters such as line width and
capital style is provided, and interchangeable RGB, CMYK,
and HSB color models are provided.
The source code to FPS is available, and its use requires
the scsh package. ASCII documentation
is available as well as example programs.
- A fractal analysis toolbox for signal processing. The
toolbox is supposed to be ready for release by the end of March 1997.
Versions will exist for both Matlab and
- A spatial pattern analysis program for quantifying landscape
It offers a comprehensive selection of landscape metrics
and was designed to be as versatile as possible. The metrics
available include a variety of area metrics, patch density,
size and variability metrics, edge metrics, shape metrics,
core area metrics, diversity metrics, and contagion and
interspersion metrics. FRAGSTATS is supplied in both
vector and raster image format versions, with the former
needing the commercially available Arc/Info package to
work and the latter amenable to use on generic UNIX
The FRAGSTATS source code, written in ANSI C, is available
(along with an MS-DOS executable file and Arc/Info macro files
for the vector image version) and should compile and install
on generic UNIX systems with standard libraries. The documentation
is contained within 60+ page user's manual and tutorial in
- A portable, distributed, object-oriented database designed to support the
maintenance and sharing of knowledge bases.
FramerD is optimized for the sort of pointer-intensive data structures used
by semantic networks, frame systems, and intelligent agent applications.
The package includes a extensive scripting language called FDScript based
on Scheme with special support for Web-based
FramerD creates, access and manipulates descriptions and systems of
description, with the latter being the set of conventions, expectations,
and procedures used to manipulate descriptions in a particular application
It was developed to support AI research involving the construction of
artifacts which demonstrate something like human understanding and
intelligence, e.g. to encode a text database where relations and meanings
are used in retrieval and matching.
It was designed to simplify:
- incremental development of systems of description;
- sharing descriptions and systems of description;
- distributing data and computation over a network of clients and servers; and
- access to descriptions and databases via the Web.
A source code distribution of FramerD is available under the
GPL. An extensive user's manual and other documentation
are available in the user formats.
Binaries are also available for some platforms as well as a sample
database created with FramerD.
- Frame Relay
- A protocol implementing a simplified form of packet switching similar
to X.25 in which synchronous frames of data
are routed to different destinations depending on the header information.
It it presently the most cost effective way to hook up multiple
stations with high speed digital links, and is used mostly to
route Local Area Network protocols such as IPX or TCP/IP.
The difference between X.25 and Frame Relay is that while the former
guarantees data integrity and network managed flow control at the cost
of some delay, the latter achieves much faster throughput by minimizing
network buffering and having no guarantee of data integrity.
This tradeoff is made possible by the much greater reliability of modern
digital networks whose error rates are very low as compared to the
analog networks over which X.25 usually operated.
Also, an upper layer protocol capable of recovering from errors
(e.g. HDLC or TCP/IP)
is usually run on top of Frame Relay.
- An ongoing research project at OCLC for studying the manipulation
of tagged text. It addresses the problems of tagged
SGML document collections with no
corresponding DTD, and the arbitrary transformation of tagged
text. The Fred software system is an extended
Tcl/Tk front-end to the OCLC SGML
Grammar Builder which can
automatically build DTDs from tagged text. It
addresses arbitrary transformations by including a translation
language which allows direct mappings based on tag names,
attributes, and structure as well as movement of text within the
tree and several other features.
There is also a collection X-based graphical user interfaces to
- Austin, a complete text editor which includes tag extraction,
structural reduction, and tag error handling, and takes a document
as input and extracts the specific document structure by recognizing
- Beca, a stated, structural editor in which edit actions and
rule reductions can be selectively applied and undone and which
which can be used to edit many different document/corpus structures, even
those not discovered by Austin;
- Casey, a database description editor which uses grammars to
automate the description process and allows the direct editing of the
logical definition of a database, including the name, description,
proximity variables, index definitions, file sizes, and stop words;
- Drew, an interface editor which provides the ability to
construct output format descriptions from grammars; and
- Gail, which provides a single window interface to Austin,
Beca, Casey, and Drew and allows the quick
jumping from one tool to another and the loading of a grammar from
one to the other.
The Fred system is available in binary format for Sun Solaris
and SunOS, Linux Intel, IBM AIX, and Windows NT platforms.
It can be obtained after signing a non-commercial license
Fred and each of its components is extensively documented in
a series of online HTML manuals and overviews.
- An Open Source effort to build the best
MP3 digital audio player
available. This is currently (7/98) in the alpha development
stage with developer releases available.
- A Linux competitor as a UNIX-type operating system for
the i386 architecture. The current version of FreeBSD was
developed from the 4.4BSD Lite UNIX variant.
Most of FreeBSD is
governed by a license that permits redistribution if the
code includes a notice acknowledging the copyright owners,
although a few parts are covered by the GNU
- A minimal version of FreeBSD that fits on
a single floppy disk.
- Free Builder
- The Free Builder Project is a project started by a group of
Java-Linux members whose goal is to develop a free Java
Integrated Development Environment (JIDE).
The specifications for FB include:
- portability with FB
developed entirely in Java (starting with JDK 1.1);
- compatibility with JavaBeans components;
- an integrated environment consisting of strongly interconnected
tools including a Java-sensitive source code editor,
a background parser and class analyzer, a multithreaded
debugger, and a visual component builder;
- a base set of JavaBeans components (to be supplied with
the visual builder); and
- an open architecture in which external
JavaBeans components will be easily accepted by the visual
The project is currently (11/98) in the preliminary prototype
stage with version 0.73 available for download.
A mailing list is available and there are numerous openings
for developers on this project.
- A project to build a 3-D CAD application for Linux and other
UNIX systems. This is currently (6/99) in the design stages.
Note: The site seems to be dead and the mailing list (second URL
below) stopped in late July 1998.
- A project to develop a complete, free and 100% MS-DOS compatible
- An implementation of the Gfem language designed to provide
a simple method for solving partial differential equations (PDEs)
in 2-D using the finite element method.
It assumes a basic knowledge of the finite element method.
Gfem is a language for the description of PDEs whose syntax
resembles that of Pascal.
The use of FreeFEM starts with a triangulation of the
area in which the PDE is being solved in order to build
a FE mesh. The program can read in a mesh or automatically
build one, and also has
the capability of displaying, storing, or writing a
triangulation out to a PostScript file.
Then the equations to be solved on the mesh are built using built-in
functions and global operators, and solved using operators for
solving PDEs as well as setting up boundary conditions.
Binary versions of FreeFEM are available for HP-UX,
Linux Intel, and SGI IRIX platforms.
Commercial versions are also available for these and
The use of FreeFEM is documented in a 40 page user's
manual available in PostScript format.
- A collection of 79 freely available ATM fonts for Linux programs such
as X11 and Ghostscript.
- A project to develop an Open Source
simulator for Linux.
The project goals are to develop a VHDL simulator that:
Snapshots of the source code distribution are available.
- has a graphical waveform viewer;
- has a source level debugger;
- is VHDL-93 compliant; and
- is of commercial quality, freely distributable, and works with
- The Free Large Integer Programming
package contains a variety of functions for performing
arithmetic on arbitrary length signed integers. These functions
allow easy prototyping and experimentation with new number
theory-based cryptographic protocols. FreeLIP is a version of
the original LIP (from Bell Labs) that was used on the
The functions available within FreeLIP can be divided into
several categories including:
- auxiliary functions (e.g. comparison,
base conversion, logarithms, etc.);
- basic arithmetic;
- bit manipulation (e.g. and, cat, not, xor, parity, shift, etc.);
- modular arithmetic;
- Montgomery arithmetic;
- Euclidean algorithms
(e.g. Chinese remaindering, Jacobi symbol, etc.);
- random number generation;
- primality testing and factoring (e.g. probabilistic
tests, trial division, pollard rho, etc.);
- prime number generation;
- NIST digital signature algorithm;
- timing functions; and
- allocation functions.
The source code, written in ANSI C, is included with the
distribution as is a 45 page user's manual in PostScript
- An Open Source
HTML templating system for
This provides an easy way to import data from Java servlets
into Web pages. It also helps keep graphic design separate
from application logic.
This works by first encapsulating HTML into templates and then
compiling these into Template objects which generate
HTML dynamically using data provided by the servlets.
This can also generate an XML representation
of a tree of Java objects.
This requires JDK 2 although it can be
compiled under 1.1 if the 1.2 collections classes are imported.
Documentation is contained within an online manual.
- A browser-based office management system for medical practices that
enables physicians and other health care providers to collect and
manage patient demographic and treatment outcome information.
Freemed currently (2/00) has modules for managing:
with more in the planning and development stages.
This open source project
requires PHP and
Apache, and can use most of the freely
available database backends.
- patient billing;
- patient health insurance management; and
- treatment outcome reporting
- Free Phone
- An audio tool for the Internet. The features of
Free Phone include:
- managment of multiple unicast and multicast sessions so only
one instance of the tool needs to be running;
- implementation of the Real Time Protocol (RTP);
- a signaling protocol to contact remote parties;
- support for sampling rates ranging from 8 to 48 kHz;
- a redundancy mechanism for packet reconstruction which provides
increased audio quality even with a high rate of packet loss;
- an assortment of codecs including PCMU, VADPCM, ADPCM, GSM and LPC; and
- compatibility with other MBone tools.
Binary distributions of Free Phone are available for Sun Solaris
and SunOS, Linux Intel, FreeBSD Intel and Windows 95.
The source code is available upon request.
Documentation is available on the Web site.
- A portable and fully-functional
firewall implementation derived
from a commercially available version.
The features of Freestone include:
A source code distribution is available which has been
successfully compiled on Linux Intel platforms.
- support for most popular access control mechanisms on a per
- support for most interactive protocols, e.g. FTP, Telnet, X11, etc.;
- a special SMTP three-phase relay system;
- support for most other protocols with generic IP session relays;
- support for unencumbered access to all protocols from internal
networks using SOCKS;
- direct API support for most popular authenticators;
- asynchronous alerts via email, pages, or programs;
- automatic self-auditing for unauthorized changes;
- detailed logs and flexible reports;
- time synchronization via RFC 1305; and
- censored DNS information provided to public networks.
- FreeS/WAN Project
- A project to secure Internet traffic against passive wiretapping.
The concept is caled S/WAN or S/Wan or Swan for Secure Wide Area
Networks, whence comes the FreeS/WAN name.
The idea behind the project is to deploy Linux boxes to sit between
local area networks (LANs) and the Internet which opportunistically
encrypt outgoing Internet packets, i.e. if you connect to a machine
that supports the same your packets will be encrypted, but if you
don't they won't be encrypted.
This works for almost all Internet traffic and amounts to putting
the packets into a sealed envelope on your end and taking them
out when they reach the other end.
The encryption protocols used for this project are known as
IPSEC or IP Security and will be a standard part of the upcoming
IPv6 Internet protocols. They are currently
an option with IPv4.
- Tabular Data Stream is the wire level protocol used by
Sybase and MS SQL servers to talk to clients.
The Sybase programs DB-Lib, CT-Lib and jConnect (the JDBC driver)
sit on top of this, with DB-Lib being the orginal call level
interface (CLI), CT-Lib a more complex version of that, and
jConnect a level 4 JDBC driver.
FreeTDS is a planned free implementation of DB-Lib that will
implement TDS 4.2 and 5.0 and thus be able to communicate with
any Sybase product or Microshaft SQL server.
After the DB-Lib implementation is stable it is planned to
add support for CT-Lib and ODBC CLIs.
A TDS Gateway program is also planned which will take connections
coming from FreeTDS or Sybase's Openclient and translate them
into other protocols, e.g. those of
Snapshots are currently (9/98) available of this alpha level
- FreeType Project
- A free and portable
TrueType font rendering engine in the form
of a library. This has been developed to provide TrueType support
for a large variety of platforms and environments.
FreeType is a library and not a font server. It is also not
a complete text-rendering library although it can be seen as
a TrueType driver for a higher-level library.
Its purpose is to open and manage font files and efficiently load, hint, and
render individual glyphs.
FreeType was not derived from the original TrueType engine developed by
Apple and Microshaft but was created from the published TrueType
The features of the FreeType library include:
- support for TrueType files (TTF) and collections (TTC) (but not
for GX or OpenType fonts although these can be opened and used as normal
TTF files by the library);
- a modular design wherein memory and I/O operations can be easily
tailored to various platforms and systems (with ANSI libc suport in
the standard release);
- font smoothing (i.e. gray-scaling) wherein only the parts of the
glyph that need it are smoothed;
- support for all character mappings defined in the TrueType
- multiple opened fonts and point sizes and an object management
system to keep track of all data;
- support for composite glyphs;
- a full-featured and efficient TrueType bytecode interpreter which
can produce excellent output at small point sizes;
- written in portable ANSI C and Pascal;
- a suite of test programs to demonstrate the library;
- support for extensions; and
- kerning support.
A source code distribution of the FreeType library is available.
It can be compiled and used on a wide variety of platforms including
Various documentation is available including a user guide, a developer's
FAQ, and an API reference.
- A package of libraries for using the
FreeType library from
The pieces of the package include:
- FreeType.xs, a calling program with the same API as the
- FreeTypeWrapper.pm, a wrapper for FreeType.xs for
use of the latter with a Perl-like API;
- ftinfo.pl, dumps information about FreeType fonts;a and
- mkttfdir.pl, makes fonts.dir by parsing TTF and TTC files.
- A package that uses SWIG to wrap the
FreeType library to create wrappers
for using it from Python.
- A system for keeping track of the day-to-day operations of an
This combines the Qt GUI toolkit and the
MySQL database to offer many features
- searching for a customer via surname, account number, initials,
title, physical or postal address, telephone number or patient name;
- icon warnings for outstanding balance, bad debt, dangerous
animal and deceased animal;
- a tab bar for quickly accessing common functions;
- vaccination history ordered by date with an editor to update or
- dispensing including fast search for items from available categories,
real-time calculation of price before invoicing, etc.;
- fields for modifying details of existing pets and clients;
- three complaint queues;
- tabular displays of invoices and receipts ordered by date;
- viewing and optional reprint of invoices and receipts;
- tools for transferring pets, merging owners or pets, purging
pets or owners, viewing or printing a wide range of information,
printing mail runs for statements or reminders, and creating a
- many administration features including easy management of
system information, tax settings, and invoice, receipt and statement
- A data indexing and searching system that contains clients, servers,
and auxiliary programs to the TCP/IP protocol known as WAIS. This is
an extended version of the
freeWAIS package (later renamed to ZDist and then subsumed within their
Isite package) for which the
main extension is the capability to create a data format file to be
used before indexing (see the site for details). This is written in
C and should install on generic UNIX
platforms using either GCC or
the native C compiler.
- A VRML browser written mostly in
The features of FreeWRL include:
A source code distribution is available. This is currently
(5/98) in beta test stage.
- TrueType font support using FreeType;
- OpenGL rendering via
- an open and pluggable framework in which the browsers, event model,
backend and script engines can all be easily replaced with code to
handle new interfaces; and
- support for most nodes, PROTOs and Inlines.
- A Fortran implementation of approximations
for Fresnel integrals and associated functions.
This is TOMS algorithm 723 and is documented
in van Snyder (1993).
- An object-oriented user interface system for the development
of X Window
based applications. The next evolutionary step
beyond the Interviews package.
- A Fortran package for computing the Fresnel
zone of seismic waves in a
This uses the Tijmen Moser shortest path method to compute the
Fresnel zone, with the base Earth model being PEM-C (although
additional heterogeneities can be added).
See Moser (1991).
- A portable emulator for the Commodore C64.
The features include:
Source and binary distributions are available, the latter for several
platforms including Linux Intel.
- as exact reproduction of special graphical effects as is possible;
- correctly running most games and demos correctly (even those with
FLI, FLD, DYCP, open borders, multiplexed sprites, timing dependent
decoders and fast loaders);
- 6510 emulation, e.g. undocumented opcodes, 100% correct decimal
mode, instruction/cycle exact emulation;
- VIC emulation, e.g. line-/cycle-based emulation, all display modes,
sprites with collisions/priorities, DMA cycles, open borders, etc.;
- SID emulation, e.g. real-time digital emulation including filters;
- 1541 emulation, e.g. drive simulation in directories; and
- other peripherals including keyboard and joystick.
- A project to develop a compiler wrapper allowing the use of multi-methods
and virtual function arguments in C++ programs as
if they were a built-in feature.
Multi-methods are an approach to object-oriented programming
in which functions are allowed to specialize on the class of any
variable passed to them. Functions can't be associated with one class
because different versions of the function may exist for many
different combinations of classes. (See the second URL below for
further details about multi-methods.)
The compiler wrapper modifies input and output files and collects
information about defined classes and functions that is stored
in a separate file for each assembler or object file generated
by the compiler.
The multi-methods are generated during linking.
The features of Frost include:
This is currently (2/00) supported only on the
GNU C++ compiler.
- automatic generation of high performance multi-methods;
- an unlimited number of virtual arguments;
- static checking in which ambiguities are detected at compile time;
- independence between translation units;
- functions with virtual arguments outside class definitions; and
- library support.
- A metacomputing package for intelligently distributing jobs on a
Frugal thinks about the future cost of each decision at all times, and
attempts to ensure that conditions of high processor load or memory
exhaustion never happen.
Frugal consists of two parts:
A program uses the system by looking up the manager on the Jini
lookup service and asking it for a reference to an appropriate compute
engine. The work is then sent to that engine, which performs the
computation and returns the result.
- a compute engine that allows a machine to run jobs created on
other machines; and
- a manager that decides on which compute engine a given job should run.
- A freeware Web BBS system whose features include:
A source code distribution of this CGI-based
package is available.
- a BBS-like layout with all the posts on one page;
- complete logging functions;
- the capability of blocking spammers;
- use of frames with an option to nuke them; and
- several administrative functions.
- A couple of packages of finite state utilities useful for spellchecking,
diacritic restoration, morphological analysis and synthesis, and
The fsa package includes:
- fsa_accent, for restoring diacritics;
- fsa_build, builds various kinds of simple finite state automata;
- fsa_guess, performs morphological analysis of known and unknown
- fsa_hash, implements perfect hashing;
- fsa_morph, performs morphological analysis of words;
- fsa_prefix, prints the entries in a dictionary beginning with
a given prefix; and
- fsa_spell, for spellchecking.
The utr transducer packages contains (where transducers provide
compact representations of morphological data):
Available dictionaries include German, English and Polish word lists
as well as a French dictionary, a morphology, a transducer, and two
A source code distribution of these C++
packages is available.
- tr_accent, for restoring diacritics;
- tr_morph, for performing both morphological analysis and
generation of inflected forms;
- tr_prefix, lists all dictionary entries having surface forms
beginning with a given string;
- tr_spell, for spellchecking; and
- tr_ubuild, builds transducers for the other utr utilities.
- The FMRIB Software Library is a collection of
functional and structural brain image analysis tools for the Functional
Magnetic Resonance Imaging of the Brain (FMRIB).
The tools (some of which are command line, some of which are GUI, and
some of which are both) are:
- BET, a brain extraction tool for automatically segmenting
brain from non-brain;
- FLIRT, a linear image registration tool for automatic accurate
robust linear (affine) inter- and intra-modal registration;
- FEAT, an easy analysis toolfor advanced FMRI analysis via a
GUI, e.g. the FMRIB Improved Linear Model (FILM) and fixed- and
random-effects group statistics;
- SUSAN, nonlinear noise reduction for 3-D images;
- Model-Free ANOVA, for running an FMRI analysis without
specifying a waveform;
- EROS, for robust detection of the mid-sagittal plane; and
- McFLIRT, for FMRI motion detection.
- The parallel incompressible flow solver
package implements a second-order finite difference projection
algorithm for solving the incompressible Navier-Stokes equations in
2-D and 3-D rectangular domains.
The parallel implementation is based on a grid partition strategy
for the code to run on any logical rectangular processor array in
a distributed memory, message passing machine.
The solver uses a parallel multigrid elliptic kernel to compute
velocity and pressure fields at each time step, and can deal with
Direchlet, Neumann, periodic, and mixed boundary conditions.
The source code for fsolver is available.
The package performs interprocessor communications through a
generic message passing interface which currently (5/97) supports the
PVM, MPI, and
Intel NX (see NXlib) message passing
The package and the algorithms used therein are documented in
a technical report included in the distribution in
- The Feasible Sequential Quadratic Programming
package implements a superlinearly convergent algorithm for directly
tackling optimization problems with
multiple competing linear/nonlinear objective functions (minimax),
linear/nonlinear inequality constraints, and
linear/nonlinear equality constraints.
FSQP also contains special provisions for maintaining the
semi-feasibility of each iterate and for efficiently handling
problems with many sequentially related objectives and/or constraints.
Source code versions of FSQP are available in both Fortran
They can be freely obtained by sending a request to the address
given at the site.
An interface between FSQP and ADIFOR
is available. Applications with interfaces to FSQP include
Much documentation is available including a user's guide in
- FSU Pthreads
- A library package of preemptive threads
compliant with POSIX 1003.4a Draft 6.
This was developed as part of the POSIX/Ada Runtime Project (PART).
The available features include:
thread management, synchronization, thread-specific data,
thread priority scheduling, signals, cancellation, timers,
synchronous I/O, perverted scheduling for debugging,
graceful handling of stack overflow, mutex priority inheritance,
priority ceiling emulation protocol, reentrant functions,
process control, asynchronous I/O and timer objects, and
heap memory pools.
- The file system visualizer allows the visualization
of files in 3-D, i.e. geometrically representing the file system
hierarchy to allow visual overview and analysis.
Two different 3-D representation schemes are available:
Directories can be expanded and collapsed at will, allowing as little
or as much of the system to be viewed at any one time.
The source code and binary versions of this program are
available under the LGPL.
This requires and uses Mesa.
- a MapV view wherein files and directories are represented
as rectangular blocks, all of equal height and with areas proportional
to the file size;
- a TreeV view wherein the conventional tree/leaf paradigm is used
to represent directories as interconnected platforms with leaves (files)
sitting on top (and with everything arranged concentrically with
the root directory closest to the center).
- A file manager designed to resemble the
NeXT File Viewer.
Source and binary RPM distributions are available.
- The Linux Floppy Tape Project is developed ftape, a driver
program that controls various low cost tape drives that connect
to the floppy controller.
It is not technically backup software
but a device driver that allows you
to use your floppy tape drive through the device
It supports drives that conform to the QIC-177 and one of the
QIC-40, QIC-80, QIC-3010 and QIC-3020 standards.
It doesn't support QIC-02, IDE (ATAPI) or SCSI tape drives.
- The Folding Text Eeditor is an editor whose features include:
It has syntax highlighting modes for C, C++, Java, Perl,
REXX, Pascal, Ada, UNIX shells, Tcl, HTML, IPF, LaTeX,
email messages, and several others.
The source code is available as are binaries for Linux Intel,
Windows NT/95, DOS, and OS/2 platforms.
- configurable color syntax highlighting,
- smart indentation for several languages,
- multiple files and windows,
- a high degree of configurability,
- binary file editing,
- column/line/stream block operations,
- unlimited undo and redo,
- background compiler execution support,
- compiler error parsing and navigation,
- regular expression search and replace,
- folding, and
- A program that checks Fortran code for common mistakes.
I should mention to the religiously devoted C programmers that
one of the error messages isn't, "You're programing in Fortran."
- A translator that converts standard Fortran 77 code to
standard C code which can be compiled by a standard C compiler.
This is fairly well debugged and produces reasonably fast code
when compiled used GCC. It has also been widely used to successfully
translate some rather large chunks of code (see
DATAPLOT, for instance).
Its chief disadvantage is that it only translates strictly standard
Fortran 77 code and can't handle the various extensions that have
evolved over the years. A program called
been developed to partially remedy this situation. It translates
some F77 extensions into standard F77 that f2c can handle. See
the site for what it can and can't do.
Jeff Templon has an
page with additional information.
- A Fortran to Lisp translator. This package doesn't seem
to like GCL
so you might want
to try some other Lisp flavor to see if your luck is better.
By the way, this package was developed, in the words of the
authors, "to help counter the argument that the value of existing
code is the reason why languages other than Fortran should not be
used", i.e. if all existing numerical Fortran code can be automatically
converted to Lisp, then that excuse won't wash any more.
- A program that converts Fortran
Fortran 77 programs are converted into equivalent Java source files
with each Fortran program unit translated into a Java class.
- The Fortran to Python Interface Generator
generates Python C/API modules for wrapping Fortran 77/90/95 codes
An interface is produced in three general steps:
- the Fortran sources are scanned and a signature file containing
the signatures of Fortran routines is generated (along with a make file
for building a shared module);
- the signature file is manually modified to change how the Fortran
routines should be called or seen from the Python environment; and
- the signature files are read and the Python C/API modules are
generated as well as a LaTeX manual documenting
the wrapped functions.
The additional features of f2py include:
- constructing a flexible call-back mechanism for external
arguments so Python functions can be called from Fortran;
- passing almost arbitrary Python objects to wrapper functions, with
type-casting and non-contiguous arrays automatically handled;
- support for almost all Fortran 77/90/95 standard constructs and
all basic Fortran types, including multidimensional and complex arrays
and character strings; and
- support for wrapping Fortran 90/95 module routines.
- A general software package containing utility programs to
create, examine, or modify the contents of
FITS data files.
Each FTOOLS task is a separate program which can be run in the
IRAF environment or as a standalone tool,
and scripts can be used to combine several FTOOLS to perform
The FTOOLS tasks are collected together in sub-packages which
combine similar tasks. The general packages include:
The four general packages called the core FTOOLS packages are:
- caltools, for performing various calibration tasks;
- examples, which contain sample do-nothing tasks which illustrate
how to write additional FTOOLS;
- heasarc, which performs general tasks
for high energy astrophysics; and
- xronos, a general timing analysis package.
The group of mission specific tasks are
asca, einstein, gro, rosat, vela5b,
and xte, each of which is tailored to the needs of a specific
project or mission.
Xselect is a general task driver which greatly simplifies the
performance of a wide range of common tasks such as extracting images
or spectra from events files.
The package also contains two graphical interface tools:
- fimage, which contains general FITS image manipulation tasks;
- futils, which contains general purpose FITS tasks;
- ptasks, which contains parameter file manipulation tasks; and
- time, which contains timing specific tasks.
- fv, a graphical FITS browser for both tables and images, and
- xdf, an XTE data finder which allows the easy traversal of
an XTE data directory tree.
The FTOOLS distribution is available in source code form.
It is designed to be highly portable and requires only a C compiler,
a Fortran 77 compiler, and a Perl installation
for compilation and use.
The graphical interface tools are written using
Tcl/Tk which must be installed for their use.
Documentation for the system is extensive including installation
and user's guides for FTOOLS as well as a user's guide for
Xselect, all of which are available in PostScript format.
- The File Transfer Protocol.
FTP-related packages include:
- An FTP server program that doesn't require a root
account for installation.
- A package that is a complete replacement for the find command,
a powerful extension to awk,
a scripting language as powerful as Perl, and
an interactive tool for performing calculations, testing program
logic, or exploring UNIX system calls.
Ftwalk is a tool for finding and managing files that can be used
from the shell command line, in a shell script, or to write
Over 300 built-in functions are available for performing
almost any imaginable type of task.
A source code distribution of Ftwalk is available.
It is written in C and has been tested on Linux Intel platforms.
The documentation is contained in an HTML document that prints out
to over 300 pages.
- A double-precision multi-purpose data processing and fitting
program which can manipulate complete columns of numbers using
vector arithmetic. Fudgit is also an expression language interpreter
which understands most of C grammar and supports most of the
functions from the C math library. It is also a front end for
any plotting program supporting commands from stdin, e.g.
The features of Fudgit include:
The fitting routines include straight line linear least
squares (LS), straight line linear least absolute squares,
general LS using QR decomposition, general LS using singular
value decomposition (SVD), and the nonlinear Marquardt-Levenberg
- a command shell with history,
- abbreviations for all of the
fitting mode commands;
- user-definable macros, aliases, and shell flow control statements;
- on-line help and selectable plotting program;
- Fourier transforms and cubic spline interpolation;
- a double-precision built-in calculator,
- user-definable functions and procedures,
- double-precision vector arithmetic;
- built-in fitting series (e.g. power series,
sine and cosine series, Legendre polynomials, series of
Gaussians, Lorentzians, or exponentials);
- user-definable fitting functions;
- totally dynamic allocation of variables
and parameters, and
- the selection of fitting ranges.
The Fudgit distribution includes the source code, written
in C, and a 90 page user's manual in PostScript format.
It should compile and install on most generic UNIX
- The Fairly Usable File System is a complete
parallel I/O system for workstation clusters that attempts to achieve
high performance using Aggregate Function Networks (AFNs). An AFN
is a globally synchronous network where all communication occurs as
a side-effect of a barrier.
FUFS is a kernel-level file system designed to efficiently support
parallel I/O interfaces. It uses an extension of standard UNIX
functionality to provide direct support for many APIs, with library
routines for supported interfaces needing only to fill out a data
structure and pass it to FUFS via standard UNIX I/O calls.
The features include:
FUFS was designed and implemented on a Linux workstation cluster
and uses low-level routines from the AFAPI
A beta release is planned for 1/99.
- a single, unified, hierarchical UNIX namespace using a directory
tree identically to that in a sequential file system;
- a set of maintenance utilities, i.e. parallel versions of several
standard UNIX tools;
- direct support for many standard parallel I/O techniques such as
strided accesses, collective and asynchronous I/O, shared file
pointers, multiopens, etc.; and
- direction support for many APIs including the MPI-IO part of
- A scientific analysis and visualization tool for UNIX/X11 platforms
built using the GTK GUI toolkit.
This project, still (10/98) in the early stages, aims to develop
a useful, fast and full-featured plotting and analysis package
under the GPL.
Developers are welcomed and encouraged.
Source code snapshots are available while also require
Yorick for full functionality.
- functional languages
- A functional language is a side effect-free language in which the
application of a function to its arguments is the main execution
mechanism, i.e. the computation is carried out entirely via the
evaluation of expressions.
The key components of a functional language include a set of
primitive functions, a set of data objects, a set of functional
forms for combining functions into new functions, and an
application operation that applies a function to an argument to
produce a value.
The claimed advantages include easier programming via the
reuse of preexisting components and suitability for use with
The first significant functional language was FP, designed by
the same man who led the development of Fortran,
i.e. John Backus.
The currently most significant functional language is
Haskell, created by a group of researchers
in response to a veritable plethora of widely diverging language
implementations. It consolidates many of the features of the
other languages and is intended to provide a stable base for
communicating ideas, developing applications and enticing new
users to the wonders of functional programming.
A concept related to functional languages is dataflow languages, i.e.
languages developed to develop efficient programs for the dataflow
architectures developed in an attempt to improve upon the
von Neumann architecture by allowing data to flow directly
from instruction to instruction.
For various reasons, most dataflow languages have
turned out to be functional languages, although sometimes not
strictly pure ones. An example of a currently available dataflow
language is Sisal.
Asperti and Guerrini (1998),
Cousineau and Mauny (1997),
Gajski et al. (1982),
Gordon (1995) and
Languages or implementations thereof that are functional or have
some functional aspects include:
- A 3-D diagnostic model for baroclinic, wind-driven and tidal circulation
in shallow seas.
This Fortran 77 package solves the linearized
shallow water equations using linear finite elements.
Solutions are obtained in the frequency domain with the limit of zero
frequency representing the steady state.
A user's manual is available in PostScript format.
- A suite of S (see R) functions for fitting curves
and surfaces to data. The focus is on applications relating to
reponse surface methodology, spatial data and nonlinear times series
and dynamical systems.
The major methods implemented as S functions include:
The package also includes generic functions for supporting these
specific methods. A PostScript manual is available.
- nnreg, neural net regression;
- tps, thin plate spline regression;
- krig, kriging, i.e. spatial process estimation;
- nlar, nonlinear autoregressive time series models;
- splint, 1-D cubic splint interpolation;
- sreg, 1-D cubic spline smoothing;
- qsreg, quantile spline regression;
- nkden, normal kernel density estimation;
- nkreg, normal kernel regression estimation;
- nlar, fitting a nonlinear autoregressive time series;
- lle, computing the local Lyapunov exponent of an
autoregressive time series.
- A literate programming tool
which is essentially a macro
preprocessor that reads an input file containing a list of
macros and generates one or more output files defined in
terms of the macros.
FunnelWeb is programming language independent and creates
TeX output code.
Explanatory text can be included between the macros to enable
the entire document to be typeset as code documentation.
FunnelWeb is independent of the input programming language
and allows complete control over the output text.
It can be used for writing complicated programs, preparing
a related collection of text files, and for generating
A source code distribution of FunnelWeb is available.
It is written in C and can be compiled and used on
many platforms including Mac, MS-DOS, VAX/VMS, and most
It is extensively documented in a 120 page user's manual
available in several formats.
- FunnelWeb AC
- A enhanced version of the FunnelWeb system
for literate programming.
While FunnelWeb only supports TeX output, AC is designed to
be typesetter independent.
It additionally supports HTML, creating hypertext links within
the document among the code sections.
It also supports automatic and manual insertion of line
directives so compiler errors can be flagged back to the
original source file.
- A system that allows collaboration across the Web by providing
documents with read and write access.
A Futplex document consists of pages with text and hypertext links.
The functionality and features of Futplex include:
A source code distribution of this C program is available.
A user's manual is available in HTML format.
- access to all functions with standard WWW clients;
- an easy point-and-click interface for editing;
- several levels of user interface complexity including basic and
complete navigation functions and read-only interfaces;
- system access via personal or guest accounts or limited access
without logging in;
- adding, moving and deleting pages by users;
- adding, editing, moving and deleting text on pages by users;
- navigation via indexes, page trees, and navigational aids within pages;
- extensive editing functionality including basic adding/deleting of
text, adding HTML code, creating links to page positions, putting
bookmarks on a page, importing text via an email gateway, etc;
- private notebook pages on a per user basis; and
- a talk or chat page.
- fuzzy logic
- Related software includes:
- fcluster, a tool for fuzzy cluster analysis;
- FOOL/FOX, fuzzy system development tools;
- NEFCLASS, a program for data analysis via
- NEFCON, for neuro-fuzzy control;
- NFIDENT, for approximating functions using
fuzzy systems based on supervised learning;
- StarFLIP++, a reusable iterative optimization
library for combinatorial problems with fuzzy constraints; and
- Xfuzzy, an environment for the design,
verification and synthesis of fuzzy logic based systems.
- A window manager based on TWM. It provides virtual desktop
support, a built-in pager, windows and icons (including colored
icons), and a module interface that is easy to modify to add
functionality. The given link is to the FVWM Home Page, where the
software and documentation thereof can be found. The
Sept. and Oct. 1995 issues of the
contain several articles about FVWM.
FvwmScript is a module which allows the building of
graphical applications such as desktop accessories, button panels
with popup menus, modal dialogs, etc.
- An fvwm2 module to interactively configure the window manager.
The mouse is used to interactively point and click on fonts,
images, etc. with changes immediately reflected without restarting
A history of each parameter is saved so previous configurations
can be recalled.
A series of completely different configurations can be saved
and switched among by clicking in a list box.
A source code distribution of FvwmConf is available as is
a Debian Linux package.
Both Perl and
perlTk are required to use this.
- A modification of the FVWM window manager
which tries to emulate the better features of Win95 without
bloating the original code.
It has the same look and feel as the Win95 GUI, the same
flexibility and easy configurability of native FVWM,
extensible functionality via loadable modules, and
a taskbar for quickly finding an application window.
- A utility for finding and manipulating .forward files in the
home directories of users that was designed to enforce system
security policies regarding such files. Fwck can be configured to find any
.forward file or those with more than a given number of
entries. It also reports users who pipe incoming mail to an
external program or whose .forward files are links or
directories rather than regular files.
A source code distribution of this C program is available.
- A high-level firewall configuration
This module can be used to configure the Linux kernel packet
filtering firewall using higher-level abstractions rather than
rules for the input, output and forward chains.
It also supports
masquerading and accounting.
- A literate programming
tool that works in conjunction with
The features of FWEB include:
- processing multiple languages within a single run,
- a language independent mode,
- the ability to turn off pretty printing,
- a built-in ratfor translator,
- a built-in macro preprocessor which closely follows ANSI C,
- a style file that allows parameters and behavior patterns to be
- operator overloading features that provide additional pretty printing
A source code distribution of FWEB is available. It is written
in C and can be compiled and used on generic UNIX platforms.
A user's manual is available in
- The Free Widget Foundation is a project to
create a set of GUI modules for the X Window System.
The present (4/97) FWF library release contains around 40
widgets of varying degrees of complexity. Some of the widgets
are simple ones for creating buttons, labels, etc. and other
are sophisticated, high-level widgets for hierarchical file
selection, statistical data representation, image editing, etc.
Many more are under construction.
Some of the widgets in the FWF library are:
- XmAnsiTerm, which displays text with embedded ANSI
- Arrow, which displays a triangle point in one of four directions;
- Animator, which cycles through a set of images at a fixed rate;
- ArticleText, which allows multi-color and multi-font text display;
- CircPerc, which is used to indicate the progress of an application;
- FileChooser, a hierarchical file chooser;
- Frame, used to provide four types of 3-D frames around
- Icon, used to display icons;
- MenuBar, which displays buttons in a horizontal row;
- XfwfPieMenu, a disk-like pop-up menu with items as pie segments;
- PullDown, a button with a pull-down menu;
- Rheostat, a round, dial-like valuator widget;
- RowCol, which aligns its children in rows and columns;
- Scrollbar, which creates a scrollbar;
- Shistogram, a simple histogram widget;
- Toggle, which maintains an on/off state and displays an icon
corresponding to that state;
- UGraf, a simple 2-D and 3-D graphics library;
- XmAnsiTerm, which emulates an ANSI terminal in an X Window; and
- XmPager, which displays one page from a long text; and many
A source code distribution of the FWF widget library is available
as is an ELF binary for Linux boxes.
The source code can be compiled on generic UNIX platforms
via the Imakefile included in the distribution.
The XPM library is required for compilation.
Each of the widgets is documented in a man page.
A tool called wbuilder is also available which makes it easier
to create widgets by reading abbreviated code from a file
and expanding it with required boilerplate ocde.
- A set of user-callable routines with a Fortran
interface that permit the conversion of internal data into
XDR format and vice-versa.
- A library that allows you to make calls to
from Fortran. This means that you can read and write unformatted
binary files between platforms in a portable way.
- A C++ library containing a FFT tutorial, a large
selection of FFT routines (e.g.,
a Hartley transform based FFT, a split radix FFT, a four-step
FFT, an arbitrary length FFT based on the chirp filter,
and several kinds of FFTs), fast Hartley transform
routines, number theoretic transforms, fast Walsh transform
routines, and convolution, correlation and power spectrum
routines of various types.
The package includes the source code, written in C++, as
well as a 40 page document containing notes on all of the
various routines. It is available in PostScript format.
This site also has links to a plethora of other FFT routines
in various languages as well as to introductory and
tutorial literature about the FFT.
[ home /
Up: Linux Software Encyclopedia