Next: Ga-Gm Up: Linux Software Encyclopedia Previous: Fa-Fm Contents

Fn-Fz

Last checked or modified: Dec. 15, 1999

FNC-2: 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 evaluators; and

a choice of implementation languages including C and ML.

FNC-2 contains several companion processors for building complete applications including:

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 composition.

[http://www-rocq.inria.fr/oscar/FNC-2/littlefnc2.html]
f90doc: 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.
[http://daisy.uwaterloo.ca/~eddemain/f90doc/]
f90gl: A Fortran interface for Mesa and GLUT which can also be used with other implementations of OpenGL. It provides interfaces for both Fortran 77 and Fortran 90.
[http://math.nist.gov/f90gl]
f90toC: A Fortran 90 to C compiler in the very early stages of development (6/99).
[http://www.ncsa.uiuc.edu/~mdewing/f90toC/]
F90toC++: A Fortran 90 to C++ converter that's in the early alpha stage of development (6/99).
[http://www.cross.ru/kcc/]
FNLIB: A package of elementary and special functions extracted from the SLATEC library for the CMLIB package. 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 numbers; 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: FAC, factorial; BINOM, binomial; GAMMA, gamma; 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; BETA, beta; 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 SLATEC.
[http://sunsite.doc.ic.ac.uk/public/computing/general/statlib/cmlib/]
Fnorb: An experimental CORBA ORB written in Python. Fnorb gives the Python programmer access to CORBA by supporting all CORBA 2.0 datatypes and providing a full implementation of IIOP. It can be used as a CORBA scripting tool and for building test harnesses for CORBA development projects as well as for prototyping CORBA systems. Fnorb requires a 3rd party interface repository to parse and store IDL definitions. The OmniBroker package is recommended by the developers.
[http://www.dstc.edu.au/Fnorb/]
Fnord: 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 format.
[http://www.cs.cmu.edu/~spot/fnord/fnord.html]
FOAM: 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 vector expressions;

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.
[http://pcae.hep.phy.cam.ac.uk/ben/foam/foam.html]
FOCUS: 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 Ncurses. Documentation is included in the distribution.
[http://www.ology.org/tilt/focus/]
fof: Fred's Own Filemanager is a graphical filemanager that acts as a front-end to several UNIX commands. 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.
[http://www.linux-france.com/pesch/exode/fof.html]
FOF: 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 ASCII files.
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.
[http://www-hpcc.astro.washington.edu/tools/FOF/]
fontinst: 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 as dvips. The features of the package include:

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 LateX2e; and

user-customizable to deal with arbitrary font encodings.

A source code distribution of fontinst is available. It is written in TeX and documented in LaTeX format.
[http://www.cogs.susx.ac.uk/users/alanje/fontinst.html]
fonts: Available programs for working with fonts in various formats as well as the fonts themselves include:

Console Tools

DTM

Font Utilities

fontinst

Font3D

freefonts

FreeType Project

gFONT

gltt

gsftopk/gsftopkk, a program for converting PostScript fonts into a form usable by xdvi

LaTeX

METAFONT

MetaPost

mminstance

PostScript

SVGATextMode

teTeX

t1utils

TrueType

ttftot42

xfont3d

xfsft

Xfstt
Font3D: 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:

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 source code distribution is available.
[http://www.checkpoint.net/font3d/]

xfont3d

A graphical interface to Font3D built using the XForms library.
[http://cspar.uah.edu/~mallozzir/software/xforms/xfont3d.html]
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 supported.
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 degrees clockwise;

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 and resolution.

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 Texinfo format.
[ftp://ftp.digital.com/pub/GNU/fontutils/]
FOOL/FOX: 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 PostScript format.
[ftp://ftp.informatik.uni-oldenburg.de/pub/fool/]
FOP: A print formatter driven by XSL formatting objects, i.e. a Java application that reads a formatting object tree and turns it into a PDF document. The formatting object tree can be in the form of an XML dcoment or can be passed in memory as a DOM document or SAX events.
[http://xml.apache.org/fop/index.html]
FORM: 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 TeX dvi format at the same site.
[ftp://ftp.nikhef.nl/pub/form/linux/]
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:

ACL2

CADP

HOL

Isabelle

MOCHA

Murphi

PEP

PVS

SMV

Spin

VIS

[http://www.comlab.ox.ac.uk/archive/formal-methods.html]
[http://www.cs.nmsu.edu/~mikau/aadebug.html]
[http://www.cs.indiana.edu/formal-methods-education/]
Forte for Java: An IDE for Java built on top of NetBeans for modularity and extensibility. 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 needing source;

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.

[http://www.sun.com/forte/ffj/]
Forth: 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 incremental development, 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:

bigFORTH,

ficl,

gforth,

kForth,

PFE,

pForth,

ThisForth, and

forth2c.

An interesting project for scientists using Forth is the Forth Scientific Library Project. Introductory textbooks are Brodie (1987) Katzen (1981), and Kelly and Spies (1986). More advanced texts include Brodie (1984), Matthews (1989), Noble (1992), and Woehr (1992). A history of the language can be found in Rather et al. (1993).
[http://www.forth.org/fig.html]
[http://www.cera2.com/softd/forth.htm]
FOR3D: 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).
[ftp://oalib.njit.edu/pub/for3d/]
forth2c: A package that translates Forth source code to C source code. This is implemented as an enhancement to the gforth compiler system.
[http://www.complang.tuwien.ac.at/projects/forth.html]
4tH: A compiler and interpreter which runs most Forth programs. A source code distribution is available which can be compiled on most UNIX flavors. Extensive documentation is available in ASCII format.
[http://www.geocities.com/SiliconValley/Bay/2334/foldtree.htm]
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, LINPACK, etc. A reasonably large selection of special functions and integrals, interpolators, transforms, and matrix algorithms are currently (10/97) available.
[http://www.forth.org/fsl/sciforth.html]
forth2c: A Forth-to-C compiler.
[http://www.complang.tuwien.ac.at/forth/]
Fortran: 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:

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 independence;

object-oriented programming features such as derived types and operator overloading;

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.

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.
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 keyword argument;

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:

ADAPTOR, translates HPF into Fortran 77/90 with message passing commands;

g77, a Fortran front-end to the GNU compiler suite;

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 Fortran 90;

OOF, a set of object-oriented extensions to Fortran that require that a Fortran compiler already be present on the system;

SHPF, a public domain HPF 2.0 compilation system; and

vf90, a F90 compiler that works with g77.

There are also several commercially available options, the details of which can be found at the URLs given below.
Useful Fortran resources include:

Fortran Under Linux
[http://studbolt.physast.uga.edu/templon/fortran.html]

Fortran Library
[http://www.fortranlib.com/]

Fortran Market
[http://www.uni-comp.com/fortran/]

Fortran FAQ
[http://www.fortran.com/fortran/FAQ/cont.html]

Fortran 77 Standard
[http://www.fortran.com/fortran/F77_std/rjcnf0001.html]

Fortran 90/95
[http://www.kcl.ac.uk/kis/support/cc/fortran/f90home.html] i

High Performance Fortran User Group
[http://www.vcpc.univie.ac.at/information/HUG/HUG.html]

User Notes on Fortran Programming
[http://sunsite.unc.edu/pub/languages/fortran/unfp.html]

Fortran Performance Tuning Co-Guide
[ftp://members.aol.com/n8tm/ftune.html]

U.S. Fortran Standards Technical Committee (J3)
[http://www.ionet.net/~jwagener/j3/]

International Fortran Standards Organization (WG5)
[http://www.nag.co.uk/sc22wg5/]

Content of Fortran 2000
[http://www.cs.rpi.edu/~szymansk/OOF90/f2000.html]

See Brooks (1997), Ellis (1989), Metcalf and Reid (1996), Ortega (1994b), 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 and vice-versa;

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 computers;

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 algorithms;

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 elliptic integrals;

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 algorithms;

GEOPACK, subroutines for magnetospheric modeling studies;

GPLOT, a plotting library for creating CGM files;

GSLIB, for performing various geostatistical tasks;

HDF, a library for converting data to a standard format;

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 Lanczos tridiagonalization;

LAPACK, for solving almost any problem related to linear algebra;

Lawson-Hanson, for solving least squares problems;

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 L-moments;

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 scattering theory;

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 optimization;

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 for ODEs;

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 subroutine;

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 isotropic meshes;

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 initial conditions;

clusfind, programs for cluster analysis;

CLUSTER, multivariate cluster algorithms;

COLNEW, for solving boundary value problems;

CONTIN, a continuation algorithm for nonlinear systems;

COSMICS, for cosmological modeling;

COUPLE, for underwater acoustics modeling;

CPQR79, for computing zeros of polynomials;

CUTE, routines for linear and nonlinear optimization;

DASSL, for solving differential-algebraic equations;

ddcon2d, for solving the 2-D Navier-Stokes equations for Boussinesq convection;

DDSCAT, for scattering and absorption of electromagnetic waves;

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 finite elements;

FitExp, for least-squares fitting of data;

FLEXTRA, a kinematic trajectory model;

GAM, for solving 1st-order stiff and non-stiff ODEs;

GBIT, for solving large, nonsymmetric linear systems;

GELDA, for solving linear differential-algebraic equations with variable coefficients;

GEO-CGM, for calculating corrected geomagnetic coordinates;

GIANT, for solving large-scale, highly nonlinear systems;

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 generalized eigenproblem;

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 interpolation problem;

Madpack5, a multigrid package for solving PDEs;

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 autonomous ODEs;

MEXX, for integrating constrained mechanical multibody systems;

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 frequencies;

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 model;

POM, an ocean circulation model;

PSTSWM, a shallow water circulation model;

[http://www.fortranlib.com/]
[http://www.fortran.com/fortran/market.html]
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.
[http://www.itl.nist.gov/div897/ctg/fortran_form.htm]
fort77: 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.
[ftp://sunsite.unc.edu/pub/Linux/devel/lang/fortran/]
[ftp://ftp.cc.gatech.edu/pub/linux/devel/lang/fortran/]
ForUtil: A collection of Fortran 77 utilities for performing various bookkeepping, database, and flow tracking tasks. The utilities include:

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.

There are also three tools for the creation (scan_commons), examination (list_commons) and searching (get_commons) 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.
[http://www.xs4all.nl/~ripley/RSD/ForUtil.html]
4Suite: 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 DOM specification;

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.

[http://www.4Suite.com/4Suite/]
FOURPT: 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 equations. 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 channels. All relations that constrain unknown variables, discharge and water surface elevation at boundaries and channel junctions are implemented implicitly.
A source code distribution of FourPt for UNIX platforms is available. The primary documentation is contained within DeLong et al. (1997). This is part of the USGS Water Resources Applications Software collection.
[http://water.usgs.gov/software/FourPt.html]
[http://www.geogr.uni-jena.de/software/FourPt.html]
FOX: 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:

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 source code distribution of FOX is available. It was designed and built on a Linux box.
[http://cyberia.cfdrc.com/FOX/fox.html]

FoxPilot

A visual development environment for the FOX widget set.
[http://ipro.lug.usf.edu/~celer/foxpilot/]

FXPy

A Python interface modules that provides an interface to the FOX GUI library.
[http://home.HiWAAY.net/~johnson2/FXPy/]
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.
[http://foxproject.org/]
FPKPascal: 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.
[http://www.brain.uni-freiburg.de/~klaus/fpc/]
FPL: The Frexx Programming Language is an interpreted scripting 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.
[http://www.contactor.se/~dast/fpl-old/]
FPS: 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.
[ftp://ftp-swiss.ai.mit.edu/pub/scsh/contrib/fps/]
[http://www.mit.edu/people/wandy/fps/fps.html]
Fraclab: 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 Scilab.
[http://www-syntim.inria.fr/fractales/Software/FRACLAB/fraclab.html]
FRAGSTATS: A spatial pattern analysis program for quantifying landscape structure. 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 platforms.
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 PostScript format.
[ftp://ftp.fsl.orst.edu/pub/]
FramerD: 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 interfaces.
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 area. 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.
[http://www.framerd.org/]
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. See Buckwalter (2000).
[http://linas.org/linux/x.25.html]
Fred: 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 Fred including:

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 SGML-like tags;

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 agreement. Fred and each of its components is extensively documented in a series of online HTML manuals and overviews.
[http://www.oclc.org/fred/]
FreeAmp: 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.
[http://www.freeamp.org/]
FreeBSD: 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 GPL.
[http://www.freebsd.org/]

PicoBSD

A minimal version of FreeBSD that fits on a single floppy disk.
[http://www.freebsd.org/~picobsd/picobsd/doc/intro.html]
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 builder.

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.
[http://www.freebuilder.org/]
FreeDesigner: 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.
[http://www.fpa-engineers.com/OD/]
[http://www.jimpick.com/lists/opendesigner-list/]
FreeDOS: A project to develop a complete, free and 100% MS-DOS compatible operating system.
[http://www.freedos.org/]
FreeFEM: 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 other platforms. The use of FreeFEM is documented in a 40 page user's manual available in PostScript format.
[http://www.asci.fr/Christophe.Prudhomme/freefem.php3]
[http://www-rocq.inria.fr/gamma/cdrom/www/freefem/eng.htm]
freefonts: A collection of 79 freely available ATM fonts for Linux programs such as X11 and Ghostscript.
[http://sunsite.unc.edu/pub/Linux/X11/fonts/]
FreeHDL: A project to develop an Open Source VHDL simulator for Linux. The project goals are to develop a VHDL simulator that:

has a graphical waveform viewer;

has a source level debugger;

is VHDL-93 compliant; and

is of commercial quality, freely distributable, and works with Linux.

Snapshots of the source code distribution are available.
[http://www.freehdl.seul.org/]
FreeLIP: 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 RSA-129 project.
The functions available within FreeLIP can be divided into several categories including:

auxiliary functions (e.g. comparison, base conversion, logarithms, etc.);

basic arithmetic;

input/output;

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 format.
[ftp://ftp.ox.ac.uk/pub/math/freelip/]
FreeMarker: An Open Source HTML templating system for Java servlets. 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.
[http://freemarker.sourceforge.net/]
freemed: 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:

patient billing;

patient health insurance management; and

treatment outcome reporting

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.
[http://www.freemed.org/]
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.
[http://www-sop.inria.fr/rodeo/fphone/]
Freestone: A portable and fully-functional firewall implementation derived from a commercially available version. The features of Freestone include:

support for most popular access control mechanisms on a per user basis;

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.

A source code distribution is available which has been successfully compiled on Linux Intel platforms.
[http://www.soscorp.com/products/Freestone.html]
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.
[http://www.xs4all.nl/~freeswan/]
FreeTDS: 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 PostgreSQL. Snapshots are currently (9/98) available of this alpha level project.
[http://www.freetds.org/]
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 specifications.
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 specifications;

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 Linux Intel. Various documentation is available including a user guide, a developer's FAQ, and an API reference.
[http://www.freetype.org/]

perlftlib

A package of libraries for using the FreeType library from Perl. The pieces of the package include:

FreeType.xs, a calling program with the same API as the FreeType library;

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.

[http://www.io.com/~kazushi/xtt/]

PyFT

A package that uses SWIG to wrap the FreeType library to create wrappers for using it from Python.
[http://starship.python.net/crew/kernr/Projects.html]
FreeVet: A system for keeping track of the day-to-day operations of an animal clinic. This combines the Qt GUI toolkit and the MySQL database to offer many features including:

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 correct information;

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 newsletter;

many administration features including easy management of system information, tax settings, and invoice, receipt and statement messages.

[http://home.metroweb.co.za/~ross/FreeVet/]
freeWAIS-sf: 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 CNIDR 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.
[http://www.faqs.org/faqs/wais-faq/freeWAIS-sf/]
[http://src.doc.ic.ac.uk/packages/freeWAIS/freeWAIS-sf/]
FreeWRL: A VRML browser written mostly in Perl. The features of FreeWRL include:

script node support for Java, Javascript and Perl;

TrueType font support using FreeType;

OpenGL rendering via Mesa;

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 source code distribution is available. This is currently (5/98) in beta test stage.
[http://www.crc.ca/FreeWRL/]
FRENL: A Fortran implementation of approximations for Fresnel integrals and associated functions. This is TOMS algorithm 723 and is documented in van Snyder (1993).
[http://www.acm.org/calgo/contents/]
[http://www.netlib.org/toms/index.html]
Fresco: An object-oriented user interface system for the development of X Window based applications. The next evolutionary step beyond the Interviews package.
[http://www.iuk.tu-harburg.de/Fresco/HomePage.html]
[ftp://ftp.esat.kuleuven.ac.be/pub/psi/visics/TargetJr/]
fresnel: A Fortran package for computing the Fresnel zone of seismic waves in a spherical Earth. 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).
[ftp://geoscope.ipgp.jussieu.fr/pub/logiciels/rays]
Frodo: A portable emulator for the Commodore C64. The features include:

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.

Source and binary distributions are available, the latter for several platforms including Linux Intel.
[http://www.uni-mainz.de/~bauec002/FRMain.html]
Frost: 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:

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.

This is currently (2/00) supported only on the GNU C++ compiler.
[http://www.flewid.de/julian/]
[http://www.cyberdyne-object-sys.com/oofaq/oo-faq-S-1.19.html]
Frugal: A metacomputing package for intelligently distributing jobs on a Jini network. 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 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 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.
[http://www.cnds.jhu.edu/research/metacomputing/frugal/]
FruitBBS: A freeware Web BBS system whose features include:

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 source code distribution of this CGI-based package is available.
[http://www.phonelosers.org/FruitWare/scripts.html]
fsa/utr: A couple of packages of finite state utilities useful for spellchecking, diacritic restoration, morphological analysis and synthesis, and perfect hashing. 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 words;

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):

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.

Available dictionaries include German, English and Polish word lists as well as a French dictionary, a morphology, a transducer, and two word lists. A source code distribution of these C++ packages is available.
[http://www.pg.gda.pl/~jandac/fsa.html]
FSL: 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.

[http://www.fmrib.ox.ac.uk/fsl/]
fsolver: 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 libraries. The package and the algorithms used therein are documented in a technical report included in the distribution in PostScript format.
[http://olympic.jpl.nasa.gov/Software/Software_list.html]
FSQP: 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 and C. 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 AMPL, Diffpack, and Scilab. Much documentation is available including a user's guide in PostScript format.
[http://www.isr.umd.edu/Labs/CACSE/FSQP/fsqp.html]
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.
[http://www.cs.fsu.edu/~mueller/pthreads/]
fsv: 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:

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).

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.
[http://fox.mit.edu/skunk/soft/fsv/]
FSViewer: A file manager designed to resemble the NeXT File Viewer. Source and binary RPM distributions are available.
[http://www.csn.ul.ie/~clernong/projects/fsviewer.html]
ftape: 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 files /dev/[n]qft[0-3]. 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.
[http://www.math1.rwth-aachen.de/~heine/ftape/]
FTE: The Folding Text Eeditor is an editor whose features include:

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

abbreviations.

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.
[http://www.kiss.uni-lj.si/~k4fr0235/fte/]
ftnchek: 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."
[http://www.dsm.fordham.edu/~ftnchek/]
[http://sunsite.unc.edu/pub/Linux/devel/lang/fortran/]
f2c: 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 f77reorder has 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 f2c info page with additional information.
[http://www.netlib.org/f2c/index.html]
f2cl: 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.
[http://www.mindspring.com/~rtoy/software/f2cl/]
f2j: A program that converts Fortran into Java. Fortran 77 programs are converted into equivalent Java source files with each Fortran program unit translated into a Java class.
[http://www.cs.utk.edu/f2j/]
f2py/FPIG: The Fortran to Python Interface Generator generates Python C/API modules for wrapping Fortran 77/90/95 codes with Python. 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.

[http://koer.ioc.ee/projects/f2py2e/]
FTOOLS: 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 complex tasks.
The FTOOLS tasks are collected together in sub-packages which combine similar tasks. The general packages include:

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 four general packages called the core FTOOLS packages are:

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.

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:

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.
[http://heasarc.gsfc.nasa.gov/docs/software/ftools/ftools_menu.html]
FTP: The File Transfer Protocol. FTP-related packages include:

BeroFTPD

Darxite

ETFTP

FTP4ALL

gFTP

hftpd

Hoser FTPD

IglooFTP

lftp

LLNL XDIR

LLNL XFTP

lurkftp

mxFtp

NcFTP

NFTP

PFTP

ProFTPD

sFTP

Sprocket

UrlGet

wu-ftpd

WXftp
FTP4ALL: An FTP server program that doesn't require a root account for installation.
[http://www.ftp4all.de/]
Ftwalk: 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 standalone programs. 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.
[http://xcs.contex.com/ftwalk/]
Fudgit: 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. Gnuplot.
The features of Fudgit include:

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 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 method.
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 platforms.
[ftp://ftp.physics.mcgill.ca/pub/Fudgit/]
[http://sunsite.unc.edu/pub/Linux/science/visualization/]
FUFS: 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:

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 MPI2.

FUFS was designed and implemented on a Linux workstation cluster and uses low-level routines from the AFAPI run-time library. A beta release is planned for 1/99.
[http://shay.ecn.purdue.edu/~nwokah/FUFS/FUFS.html]
Fulcrum: 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 plotutils and Yorick for full functionality.
[http://www.srl.caltech.edu/personnel/conrad.html]
[http://www.pit.ktu.lt/pub/linux/X11/gtkbuffet/apps/fulcrum/]
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 parallel computers.
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. See Asperti and Guerrini (1998), Cousineau and Mauny (1997), Davie (1992), Eisenbach (1987), Gajski et al. (1982), Gordon (1995) and Hudak (1989).
Languages or implementations thereof that are functional or have some functional aspects include:

ALF

ASpecT

BABEL

Bla

CLAIRE

Clean

EML Kit

Erlang

Haskell

Leda

Mercury

ML

NESL

OPAL

PLAN

REBOL

Sisal

UFO, for developing parallel programs;

WildLife.

[http://www.cs.nott.ac.uk/Department/Staff/gmh/faq.html]
[http://www.cs.kun.nl/fple/]
[http://www.cs.chalmers.se/~rjmh/tutorials.html]
FUNDY: 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.
[http://www-nml.dartmouth.edu/Software/]
FUNFITS: 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:

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.

The package also includes generic functions for supporting these specific methods. A PostScript manual is available.
[http://www.cgd.ucar.edu/stats/Funfits/]
FunnelWeb: 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 Web pages.
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 UNIX flavors. It is extensively documented in a 120 page user's manual available in several formats.
[http://www.ross.net/funnelweb/]
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.
[http://www.physics.uq.oz.au:8001/people/coates/funnelweb.html]
Futplex: 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:

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.

A source code distribution of this C program is available. A user's manual is available in HTML format.
[http://gewis.win.tue.nl/applications/futplex/index.html]
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 neuro-fuzzy models;

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.

[http://www.isis.ecs.soton.ac.uk/resources/nfinfo/]
FVWM: 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 Linux Gazette 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.
[http://www.fvwm.org/]
FvwmConf: 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 fvwm. 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.
[http://www.physics.arizona.edu/~lapeyre/fvwmconf]
fvwm95: 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.
[ftp://mitac11.uia.ac.be/html-test/fvwm95.html] [ftp://ftp.plig.org/pub/fvwm95/]
fwck: 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.
[http://www.xenos.net/~xenon/software/fwck/index.html]
Fwctl: A high-level firewall configuration program. 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.
[http://indev.insu.com/Fwctl/]
FWEB: A literate programming tool that works in conjunction with LaTeX. 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 adjusted, and

operator overloading features that provide additional pretty printing capabilities.

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 Texinfo format.
[ftp://ftp.pppl.gov/pub/fweb/]
FWF: 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 escape sequences;

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 other widgets;

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 more.

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.
[http://sunsite.unc.edu/pub/Linux/libs/X/fwf/]
fxdr: A set of user-callable routines with a Fortran interface that permit the conversion of internal data into XDR format and vice-versa.
[http://www.kfa-juelich.de:80/zam/PT/PTc/SSoftToolsc/Utilities/libdc/fxdr.html]
[ftp://ftp.zam.kfa-juelich.de/pub/unix/fxdr/]
FXDR: A library that allows you to make calls to XDR routines from Fortran. This means that you can read and write unformatted binary files between platforms in a portable way.
[http://meteora.ucsd.edu/~pierce/fxdr_home_page.html]
FXT: 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.
[http://www.jjj.de/fxt/fxtpage.html]

[ home / linux ]

Next: Ga-Gm Up: Linux Software Encyclopedia Previous: Fa-Fm Contents

Manbreaker Crag 2001-03-08