Next: Fn-Fz Up: Linux Software Encyclopedia Previous: En-Ez Contents

Fa-Fm

Last checked or modified: Dec. 15. 1999

F: A scientific programming language built on the Fortran family of languages (F77, F90, HPF). It is built to be safe and regular while retaining the powerful numerical and data abstraction capabilities of its parent language Fortran 90. The upshot is that a numerical language with an array syntax (rather than loop structures for matrix manipulations) is available for the first time. The documentation is contained within two commercially available (for about $30 apiece) books, the details for obtaining which can be found at the given URL. Compilers are available for several platforms, with the Linux version freely available at present (6/96). The October 1997 issue of the Linux Journal contains an article about F. See Brainerd et al. (1996).
[http://www.uni-comp.com/imagine1/]
FAAC: The Freeware Advanced Audio Coder is an audio codec that supports the LOW and MAIN profiles derived from MPEG2-AAC. It also adds some functionality to further improve the bitrate efficiency. An open source distribution is available as are binaries for several platforms.
[http://faac.sourceforge.net/]
FACT: Functional Additions to C++ through Templates and classes is a C++ library providing some aspects of functional programming to those programming in C++. FACT currently (9/00) provides several methods for getting curried forms of C++ functions, functional composition, lambda expressions and some basic support for lazy evaluation. The package is partly based on PETE, which supports the development of expression template aware classes and, in combination with FACT, lets them be used in a functional programming style. FACT has been successfully tested with the GCC 2.95.2 compiler.
[http://www.fz-juelich.de/zam/FACT/]
FADBAD-TADIFF: A pair of C++ packages for performing automatic differentiation on functions implemented as C++ programs. FADBAD combines the two basic ways of applying the chain rule, i.e. forward and backward automatic differentiation, with both methods using operator overloading to redefine arithmetic operations such that the program can calculate first order derivatives. TADIFF performs Taylor expansions on functions implemented as C++ programs. It calculates several orders of derivatives with respect to one variable by overloading the arithmetic operations used in the function evaluation. This can also be done with FADBAD, although TADIFF is optimized for doing several orders of derivatives rather than one at a time.
Source code distributions of both packages are available. The code is written in C++ and can be compiled using G++. Each is documented in a user's manual available in PostScript format.
[http://www.imm.dtu.dk/fadbad.html]
FailSafe: A package that creates a high-availability clustering environment with resilience from any single point of failure. FailSafe can scale up to 16 nodes in a cluster with the cluster members sharing storage, thus allowing multiple servers to assume control of data in the event of a failure. At the point of failure, applications are resumed on the remaining systems, and filesystems are automatically made available to their applications. The available topologies are basic two-node, ring, star and symmetric pool configurations.
Other FailSafe features include:

selective failover in which individual highly available applications can be failed over to a backup node independent of the other HA applications on that node;

dynamic management allowing the performance of administrative tasks while the system is running, e.g. managing application monitoring, resources and upgrades;

fine-grain failover wherein a specific resource group is failed over from one node to another while other resource groups continue to run on the first node where possible; and

local restarts wherein resources groups are failed over onto the same node.

[http://oss.sgi.com/projects/failsafe/]
fake: A redundant server switch designed to switch to backup servers on an LAN in case of failure. Fake takes over the IP address of another machine in the LAN by bringing up an additional interface and making use of ARP spoofing. The additional interface can be either a physical interface or an IP alias. Fake is configurable and is designed to enable automated invocation via such packages as mon for monitoring system health.
[http://www.us.vergenet.net/linux/fake/]
Falcon: The Free Application-Level CONnection project intends to develop a free, secure and OS-independent firewall system. It consists of three main parts:

proxy applications and configure/logging facilities written in Perl;

third-party applications, e.g. BIND, Squid and Qmail; and

concepts, instructions and tools for hardening specific operating systems.

The concepts and ideas guiding Falcon development include:

high security via communication only taking place through real application level gateways, i.e. there is no routing between firewall interfaces;

use of specially written and third-party proxies securely configured for a chroot environment and that use non-privileged users;

use of modules that are either OS-independent or available on most UNIX platforms;

a module for OS hardening that reduces configuration to a necessary minimum level; and

a lightweight and open architecture that minimizes complexity by maximizing flexibility.

[http://falcon.naw.de/]
FANTOM: The FAst Newton-Raphson TOrsion Angle Minimizer is a Fortran program for calculating low-energy confirmations of polypeptides and proteins compatible with distance and dihedral angle constraints obtained from NMR experiments. FANTOM allows both energy minimizations and Monte Carlo simulations of empirical energy functions. Protein-solvent interaction is included with a fast routine for calculating accessible surface areas of individual atoms and their gradients. This program can also be used for the exploration of low energy conformations of cyclic peptides and of flexible loops in proteins. Newer programs allow for the efficient homology modeling of proteins and for locating low-energy paths in dihedral angle space between conformations of a peptide or protein. A source code distribution is freely available for research purposes after a license agreement is signed.
[http://www.scsb.utmb.edu/fantom/fm_home.html]
FAQ: A Frequently Asked Question is just what is sounds like, and collections of these pertaining to various and sundry topics are generically known as FAQs on the Web.

FAQ Manager

A Perl package that makes it easy to create, update and inspect FAQs. The features of FAQ Manager include:

automatic creation of an outline structure that can be two headings deep;

an interface with separate modes for creating new items, editing items, and moving or deleting items;

commit rollback that allows undoing several stages of editing;

use of HTML codes in documents; and

an online help utility.

A source code distribution is available.
[http://www.eprotect.com/stas/TULARC/works/faq_manager/index.html]

FAQ-O-MATIC

A CGI-based system that automates the process of maintaining a FAQ list. It allows visitors to the FAQ to take part in keeping it up to date. A permission system also makes it useful as a help desk application, bug tracking database, or documentation system. Installation and use of this requires Perl 5.003 or later, RCS, and the gd graphics library.
[ftp://ftp.cs.dartmouth.edu/pub/jonh/]
[http://www.dartmouth.edu/~jonh/ff-serve/cache/1.html]

faq-system

A package for managing a FAQ via the use of a database. The database entries are edited, and the system creates the FAQ files in various formats. The features include:

a Web interface for simultaneously generating and viewing the FAQ;

a choice of various output formats with either one file per topic or one large file;

support for HTML templates;

an unlimited number of FAQs;

easy configurability; and

search capabilities.

A source code distribution is available which requires both Apache and MySQL for installation and use.
[http://www.daemon.de/faq-system.html]

Q-HTML

A tool for converting text into HTML. This was originally created to automatically convert a lengthy FAQ into HTML.
[http://www.scot.demon.co.uk/q-html.html]
FarGo: A development and runtime environment for wide-area distributed applications. The primary design goal is to facilitate a high level of scalability and adaptability using a convenient programming model that extends Java and remains as close as possible to the regular Java programming model. The central concept is that of dynamic layout, i.e. the capability of moving and application's components among hosts while the applications are executing. The layout can be programmed separately from the application's logic either within the application or externally using a scripting language.
The components or elements of FarGo include:

application components called complets that can move between hosts while the application is executing;

the core, i.e. a lightweight server process running on machines among which the complets move;

attributes of complet called relocators that provide an abstraction for defining in design-time a set of (re)location relationships among complets;

a core service called a monitor intended to help programmers implement a judicious component-relocation policy;

a toolkit including everything needed to develop and deploy FarGo applications;

an API that provides the means for interacting with the core and its services;

fargoc, a compiler that replaces regular inter-complet Java references with special constructs for maintaining reference validity during movement and implementing relocation semantics that can be embodied in these references; and

fshell, a shell used to contact remote cores, manage them, and to start applications on them.

A source code distribution of the FarGo Toolkit is available which includes the API libraries, development and deployment tools, examples, and HTML documentation. Various other documentation is available in various formats.
[http://www.dsg.technion.ac.il/fargo/]
FASTA: A set of tools for biological sequence analysis including programs for library search, local homology, statistical significance and global alignment. The FASTA programs include:

align and align0, calculates a global alignment of two sequences;

bestscor, calculates the score of a 100% identical match;

crandseq, shuffles codons in a sequence;

fasta, searches a protein or DNA sequence data bank;

fastx, compares a DNA sequence to a protein data bank;

flalign, lalign and plalign, finds the best local alignments between two sequences;

lfasta and plfasta, compares two sequences with the second version plotting the results;

prdf and prss, compares a test sequence to a shuffled sequence;

randseq, produces a shuffled sequence;

relate, searches a sequence data bank;

ssearch, searches a sequence database using the Smith-Waterman algorithm; and

tfasta and tfastx, translates and searches a DNA sequence data bank.

All are written in C and can be compiled on most programs via the supplied makefile. There are also separate versions of many of the above programs that can use the PVM library to run on multiple platforms. Documentation is supplied in the form of man pages.
[ftp://ftp.virginia.edu/pub/fasta/]
FastCGI: An open extension to CGI which provides faster performance for all Internet applications without any of the limitations of existing Web server APIs (which, while they do increase performance compared to CGI, are vendor-specific, complex, language-dependent, difficult to maintain, prone to security risks, and inherently unstable).
The features of FastCGI include:

language-independence, i.e. the performance of thousands of already written applications can be improved;

applications run (like in CGI) in processes isolated from the core Web server and therefore provide greater security;

free FastCGI application libraries and upgrade modules for popular free servers are available while it catches up to the functionality of CGI; and

it is not tied to the internal architecture of any Web server so is stable even when server technology changes.

FastCGI also adds to the functionality of CGI with: distributed computing, i.e. applications can be run on different machines from the one that runs the Web server; and multiple and extensible roles, i.e. applications can not only compute the response to an HTTP request but also perform modular authentication and authorization checks as well as translate data from one type to another.
FastCGI distributions are available in various forms. A Developer's Kit contains source code for C application libraries, Java classes, Perl and Tcl extensions, and a CGI-to-FastCGI bridge. Also available are FastCGI-integrated Perl 5 and Tcl interpreters for popular platforms and a Python module for FastCGI support. Many examples are also supplied.
[http://www.fastcgi.com/]
FastDB: A highly efficient main memory database system with realtime capabilities and a C++ interface. It is optimized for applications with a dominated read access pattern, with the high speed of query execution provided by the elimination of data transfer overhead and a very effective locking implementation. The database file is mapped to virtual memory space for each application working with it, so the query is executed in the context of the application with no context switching or data transfer. Concurrent database access is implemented by means of atomic instructions. It is assumed that the entire database is present in RAM with the search algorithms and data structures optimized accordingly.
The features of FastDB include:

support for transactions, online backups and automatic recovery after a system crash;

a transaction commit protocol based on a shadow root pages algorithm;

application orientation wherein database tables are constructed using information about application classes;

a flexible and convenient interface for retrieving data from the database;

an SQL-like query language;

various post-relational capabilities such as non-atomic fields, nested arrays, user-defined types and methods, and direct interobject reference.

A source code distribution is available for UNIX platforms. It has been tested with Solaris, Linux and Digital UNIX. A user's manual is available in HTML format. See the related FastDB.
[http://www.ispras.ru/~knizhnik/fastdb.html]
FastGL: This has been renamed OpenGUI.
FastICA: A Matlab program implementing the fast fixed-point algorithm for independent component analysis (ICA) and projection pursuit. ICA is a non-Gaussian version of factor analysis that represents a multidimensional random vector as a linear combination of non-Gaussian random variables that are as independent as possible. Project pursuit is a technique for exploratory data analysis based on finding low-dimensional projections of multivariate data that show highly non-Gaussian distributions. The FastICA algorithm has been found to be 10-100 times faster than conventional gradient descent methods for ICA. See Hyvarinen (1999).
[http://www.cis.hut.fi/projects/ica/fastica/]
fastpictex: A front-end to the PicTeX package which acts a preprocessor, allowing the quick generation of PicTeX charts for TeX documents. A simple macro language is used to enter the data to be graphically depicted. A source code distribution is available which can be compiled on most UNIX platforms via the supplied Imake scripts. A user's manual is included in several formats.
[http://sunsite.unc.edu/pub/Linux/apps/tex/
Fastresolve: A package of programs for processing web log files to get DNS and domain ownership information for log analysis. This is designed to send out many queries in parallel and cache results for speed. The programs in the distribution include:

dns-terror, reads logs files, resolves resolvable IP addresses (and saves the others in a database file), and writes the results;

reresolve, attempts to resolve previously unresolved IP addresses saved in a database file;

convert-ip-db, converts a database file into an ASCII Analog DNS cache file;

getdominfo, queries a whois database for the organizations that own the domains for a list of host names;

convert-dom-db, converts a database file into ASCII Analog config directives;

make-report, runs other programs and Analog to produce a web report;

rebuild-ip-db and rebuild-dom-db, recreates database files from the ASCII files written by the convert-* scripts; and

expire-ip-db, removes old entires from a database file.

[http://www.web.us.uu.net/sw/fastresolve/]
FAX: FAX-related software includes:

GFax, a FAX front-end;

HylaFAX, a FAX system; and

mgetty+sendfax, programs for optimizing the use of a modem in a UNIX environment as well as for sending and receving FAXes.
fbm2fli: A set of conversion programs consisting of:

fbm2fli, which generates FLI/FLC animation files from a series of 8 bit mapped image files;

unfli, which extracts a series of 8 bit mapped image files from a FLI animation; and

fboctree, which converts 24 bit true color images to 8 bit mapped images where a series of images can have a common color table.

A source code distribution is available as is an ELF binary.
[http://sunsite.unc.edu/pub/Linux/apps/graphics/convert/]
FBM: The Fuzzy Pixmap Manipulation library of programs provides a complete package for manipulating and converting color and black and white images, including 24 bit RGB, 8 bit mapped color, 8 bit grayscale, and 1 bit bitmapped images. FBM can read GIF, JPEG JFIF, Sun rasterfile, Utah RLE, Amiga IFF, PCX, PBM, Face and FBM files. It can write all of the above except for PCX files. It has input converters for raw images, Targa, PIC, QRT, Amiga HAM, Tiff, FaceSaver and Microtek PostScript formats, and output converters for PostScript, Diablo, Targa and Tiff formats.
The operations that can be performed with FBM include:

extracting rectangular portions of images as well as resizing and changing the aspect ratio;

changing density and contrast;

rotation by 90 degree increments;

quantization of 24 bit RGB images to 8-256 colors;

halftone grayscale using dithering, averaging or threshholding;

edge sharpening via digital Laplacian;

median of a 3x3 neighborhood filter;

conversion of color to grayscale;

computation of histograms of grayscale images;

smoothing by averaging neighborhoods; and

edge detection.

A source code distribution of FBM is available. It is written in C and requires the Netpbm package for installation and use. The programs that comprise this package are documented in man pages.
[http://sunsite.unc.edu/pub/Linux/apps/graphics/convert/]
[ftp://ftp.cc.gatech.edu/pub/linux/apps/graphics/convert/]
FC: A Fortran 77 library for solving constrained least squares problems. The subroutines in the package include:

BNDACC, which introduces new blocks of data for banded least squares problems;

BNDSOL, which solves a least squares problem for banded matrices;

CV, which evaluates the variance function of a curve obtained by FC;

FC, which fits a piecewise polynomial to discrete data with equality;

EFC, an easier version of FC which also has inequality constraints;

H12, which constructs or applies a single Householder transformation;

HFTI, which solves a linear least squares problem;

LPDP, which solves a least projected distance problem;

LSEI, which solves a linearly constrained problem with equality and inequality constraints; and

WNNLS, which solves linearly constrained non-negative problems.

A source code distribution of FC is available. All the routines are written in Fortran 77 and are documented in comment statements within the source code files. This is part of CMLIB.
[http://sunsite.doc.ic.ac.uk/public/computing/general/statlib/cmlib/]
fcluster: A toolkit for fuzzy cluster analysis. The documentation is in German so I don't have much to describe for now.
[http://fuzzy.cs.Uni-Magdeburg.de/fcluster/]
[ftp://ftp.tu-bs.de/ibr/pub/local/fcluster/]
FCNPACK: A package of Fortran 77 mathematical function subroutines for computing Legendre functions and elliptic integrals. There are routines for computing the associated Legendre (or Ferrers) functions as well as the normalized Legendre polynomial. These routines feature the use extended-range arithmetic, a software extension of ordinary floating point arithmetic which greatly increases the exponent range of the representable numbers. Each subroutine is available in both single and double precision versions as well as in extended-range and normal range versions. Four routines are available for computing elliptic integrals. These handle degenerate elliptic integrals of the 1st kind (for use in computing nondegenerate integrals and certain elementary circular and hyperbolic functions) as well as regular elliptic integrals of the 1st, 2nd, and 2rd kind (both complete and incomplete).
A source code distribution of FCNPACK is available. The routines are written in Fortran 77 and are documented in comment statements included within each source code file. This is part of CMLIB. See Smith et al. (1981) and Carlson and Notis (1981).
[http://sunsite.doc.ic.ac.uk/public/computing/general/statlib/cmlib/]
FC++: A library for functional programming in C++, i.e. functions are treated as regular values. This allows functions to take other functions as parameters, with the former known as higher-order functions. The functions can also be polymorphic, i.e. the same function can be used with arguments of many types. The FC++ library supports rank-2 polymorphism. Other features include:

infinite or lazy lists;

useful higher order functions, e.g. map, compose, etc.;

a reference counting capability that can be used to replace C++ pointers; and

several common logical and arithmetic operators in a form that can be used with higher-order functions.

[http://www.cc.gatech.edu/~yannis/fc++/]
FCT: An in-place algorithm for the fast, direct computation of the forward and inverse discrete cosine transform. The transform length may be an arbitrary power of two. This is TOMS algorithm 749 and is documented in Sherlock and Monro (1995).
[http://www.acm.org/calgo/contents/]
[http://www.netlib.org/toms/index.html]
FCTOOLS: A suite of verification tools for networks of communicating processes. The software tools use a common file exchange format for automata and networks called FC2 and their functionality includes the graphical depiction of objects, global model construction from hierarchical descriptions, various types of model reductions and verification of simple modal properties by observers, counterexample production, and visualization.
The FCTOOLS suite comprises three main software modules:

AUTOGRAPH, for graphical editing and display;

FC2EXPLICIT, for the manipulation of enumerated finite state machines; and

FC2IMPLICIT, for the manipulation of symbolic finite state machines.

These modules contain various programs to perform specific functions including:

atg, the program for invoking the AUTOGRAPH graphical editor and display system for FC2 description files;

fc2link, which links partial FC2 files producted by atg by redirecting references to subcomponnets to their description and matching the label indices;

fc2min, an automata minimizer with respect to strong, weak, and branching bisimulation;

fc2implicit, which performs symbolic manipulation of labeled synchronized automata vectors; and

fc2explicit, which performs explicit manipulation of labeled synchronized automata vectors.

A binary version of the FCTOOLS package is available for Sun Solaris and SunOS, Linux Intel, and DEC OSF/1 platforms. It's use is described in a user's manual available in PostScript format.
[http://www.inria.fr/meije/verification/]
FD: A package for the computation of Fermi-Dirac integrals. Chebyshev polynomial expansions are uses which allow the computation of these functions to double precision IEEE accuracy. This is TOMS algorithm number 779 and is documented in MacLeod (1998).
[http://www.mirror.ac.uk/sites/netlib.bell-labs.com/netlib/toms/]
FDDI: The Fiber Distributed Data Interface is a 100 Mbps local area network (LAN) defined by ANSI and OSI standards. It uses a token right media access control protocol. This is included here because I'm presently interested in the possibility of linking together a network of workstations as a distributed supercomputer running PVM, MPI or some other sort of software for distributed computing applications. The given URL is to the FDDI FAQ. See Albert and Jayasumana (1994), Jain (1994), Mills (1995), Inc. (1993a), and Taylor (1995).
[http://www.nswc.navy.mil/ITT/x3t12/FDDIFAQ.html]
FDLIBM: The Freely Distributable LIBM is a C math library for machines supporting IEEE 754 floating point arithmetic. It was developed by SunSoft to provide a reasonably portable, reference quality math library. Only double precision is supported in the present version. It includes routines for trigonometric functions, hyperbolic functions, exponentials, modular arithmetic, gamma functions, Bessel functions, cube roots, ceilings and floors, the error function, absolute values, logarithms, and remainders.
A source code distribution of FDLIBM is available. It is written in C and is documented in a brief reference manual in ASCII format as well as in comments in the source codes. Compilation requires IEEE 754 style (if not precisely compliant) arithmetic and 32 bit 2's complement integer arithmetic, so this should be reasonably portable to most UNIX flavors.
[http://www.netlib.org/fdlibm/index.html]
fdutils: A package containing utilities for configuring and debugging the Linux floppy driver, for formatting extra capacity disks (up to 1992 K on a high density disk), and for sending raw commands to the floppy controller.
The utilities in fdutils include:

superformat, which formats high capacity disks;

fdmount, which automatically mounts/unmounts disks when they are inserted/removed;

xdfcopy, which formats, reads, and writes OS/2 XDF disks;

makefloppies, which creates the floppy devices in /dev;

getfdprm, which prints the current disk geometry;

setfdprm, which sets the current disk geometry;

fdrawcmd, which sends raw commands to the floppy driver;

floppycontrol, which configures the floppy driver; and

floppymeter, which measures raw capacity and exact rotation speed of a floppy drive.

The source code for fdutils is available. It is written in ANSI C and an autoconfig file eases the task of compilation. The utilities are documented in man pages as well as in a user's manual in Texinfo format.
[http://sunsite.unc.edu/pub/Linux/utils/disk-management/]
[http://fdutils.linux.lu/]
[http://www.tux.org/pub/knaff/fdutils]
fe: The folding editor is a successor to the Origami folding editor. The features include (believe it or not) folding, regions and an Emacs-like kill ring, incremental search, keyboard macros, editing binary files, menus for most important functions, a small binary size, and a reference manual in several formats (e.g. PostScript and HTML). This should compile on any system that supports POSIX, has an ANSI C compiler and the SYSV curses library (or the equivalent ncurses clone), all of which are avaiable for Linux platforms.
[ftp://cantor.informatik.rwth-aachen.de/pub/unix/]
FEAT: A general purpose purpose subroutine system for the numerical solution of partial differential equations (PDEs) by the finite element method (FEM). FEAT provides tools for domain description, mesh generation, finite element shape functions, the generation of matrices and load vectors, boundary conditions, numerical solution, error evaluation, and graphical postprocessing. It can be applied to scalar elliptic boundary value problems (BVPs) of 2nd and 4th order, mixed problems with saddlepoint character, linear and nonlinear systems of equations, time dependent problems, and more. The FEAT system is being developed as a toolbox to allow extensibility by users.
The features include:

nonconformating, rotated, multilinear finite elements and discrete projection schemes;

various Stokes elements and a Morley element;

a fractional-step, $\nu$ -scheme for solving ODEs;

various parallel techniques;

optimized linear multigrid with mesh anisotropies and space and time;

robust nonlinear solvers;

a multilevel pressure Schur complement solver;

adaptive time-step control for 2nd-order schemes;

adaptive upwind/stream-diffusion stabilization; and

a CAD tool for domain description and macro decomposition (currently available only for Windows platforms).

The FEAT system currently (4/97) consists of separate source packages for FEAT2D and FEAT3D, packages for the solution of general 2- and 3-D PDEs, and FEATFLOW, a package for the solution of the incompressible Navier-Stokes equations (which is based on the other two packages). The programs are written in Fortran and have an install script configured for Sun SunOS and Solaris, IBM AIX, SGI IRIX, HP-UX, and Linux Intel platforms. The are separate PostScript user's manuals for each package as well as a report offering an overview of the FEAST project of which FEAT is a part.
[http://www.featflow.de]
FEI: The Finite Element Interface specification is part of a multi-lab interface standards effort intended to serve as an abstraction layer between FEM/FVM codes and solution services modules. It is designed as a client/server architecture in which the interface implementation mediates between the finite element client's abstractions and those of the underlying algebra server. The primary motivation of this effort is to provide an API for implicit finite element computation that will promote portable code development by giving developers the advantages of both explicit and implicit methods.
[http://z.ca.sandia.gov/fei/]
FELIX: A computer algebra system designed for computations in and with algebraic structures and substructures. The structures implemented are commutative polynomial rings and non-commutative algebras as well as modules over them, with the implementation of skewed fields planned. FELIX consists of three layers, the first written completely in assembly language and which is system dependent. The second layer is the FELIX programming language which contains control constructs and a complete procedure concept. The last layer is a collection of built-in algebraic algorithms.
FELIX is available as a binary executable for NetBSD, FreeBSD, Linux Intel, and Windows platforms. It is documented in a user's manual available in TeX DVI and PostScript format.
[ftp://aix550.informatik.uni-leipzig.de/pub/felix/]
[ftp://sunsite.unc.edu/pub/Linux/apps/math/symbolic/]
[ftp://ftp.cc.gatech.edu/pub/linux/apps/math/symbolic/]
FElt: An introductory finite element analysis tool for solving linear problems in statics and dynamics. FElt knows how to solve linear static and dynamic structural and thermal analysis problems, and can also do modal and spectral analysis for dynamic problems. The element library contains 14 different types of elements. Three user interfaces are available:

felt, a basic command-line application for solving problems given a standard FElt input file;

burlap, a powerful interactive scripting environment; and

velvet, a full-featured CAD-like pre- and post-processor which uses the X Window System for a graphical environment.

All three use an ASCII-based syntax for problem definition which allows analytic functions to be used in place of numeric values. It also allows for time dependent forcing and boundary conditions to be specified as analytic functions of time or as a series of discrete time/magnitude pairs.
The velvet interface lets problems be defined graphically. It has powerful post-processing options including the automatic generation of stress contour, displacement contour, and 2- and 3-D wire frame plots. Plots can be saved in PPM, EPS, and PostScript formats. It can also do animations of transient structural analysis problems and plot the mode shapes in a modal analysis problem. Other applications included in the FElt package are:

corduroy, a commmand-line application which gives access to FElt's mesh generation capabilities;

patchwork, an application for input file format conversions; and

yardstick, a simple application for problem scaling and unit conversions.

FElt can be obtained in a source code distribution as well as in binary format for Linux Intel, Sun SunOS and Solaris, SGI IRIX, IBM AIX, HP-UX, and DEC Ultrix platforms. Extensive documentation includes a 230 page user's manual available in PostScript format.
[http://www-cse.ucsd.edu/users/atkinson/FElt/]
FEMLAB-2D: A finite element package for the solution of 2-D PDEs. Its main features include interactive input of the geometry, automatic mesh generation, adaptive algorithms with error control when solving the PDE, and postprocessing capabilities for interactive viewing of the results. It is written in C and Fortran and uses the X Window system, and also requires the library package libsx.
[http://www.math.chalmers.se/Math/Research/Femlab/]
FEM2DLib: Note: The author of this package left the institution in the URL some time ago. I'm attempting to ascertain his whereabouts. A set of data structure definitions, functions and subroutines for solving simple ODE and PDE problems using finite elements. The data structure definitions behave like objects, allowing the use of object-oriented techniques to solve FE problems in Fortran 90.
The available subroutines and functions in FEM2DLib are split into several categories including:

data structure routines;

element-related routines;

shape function-related routines;

mesh-related routines;

boundary condition-related routines;

PDF-related routines; and

graphics routines.

The basic data structures of FEM2DLib can be split into simple and compounded structures. The simple structures include:

Node, used to store the nodes that define a mesh;

NodeProperty, used to define values of material properties at each node;

ElmntEqs, contains matrices used to define the solution equations for an element;

BoundCond, contains information about the boundary conditions that apply to the system;

PolyDef, contains variables for defining polynomials;

FileNameStrs, for passing the names of input/output files.

The compounded structures include:

Element, contains information about the elements in the mesh;

Property, defines a material property;

Mesh, contains collections of nodes, elements and other supporting definitions;

FemSolution, contains the solution at any given time step;

TrsntSolutParmtrs, stores general information about how to solve transient problems; and

WorkSpace, stores all the information about the problem being solved.

Source code distributions of FEM2DLib are freely available for academic or non-commercial use. The three available versions are single precision, double precision, and complex. The documentation includes manuals for the data structures, problem definition files and subroutines, each available in the expected formats.
[http://www.marine.unc.edu/OPNML/personnel/mag/FEM2DLibHomePage/default.htm]
Fenris: A database-linked, website-oriented bugtracking system that allows users to submit software bugs directly to developers and also tracks the status of the work on the bugs. Fenris is based on Bugzilla although it differs from the latter in several ways including:

individual comments aren't appended onto a string blob but rather are stored as a record in a separate table;

email hiding to protect the privacy of users;

additional fields such as ``user_affected'' in case someone enters someone else's bug;

comment editing and deletion; and

more conditional system variables.

A source code distribution is available under an Open Source license.
[http://www.lokigames.com/development/fenris.php3]
FEQ/FEQUTL: The Full EQuations model and the Full EQuations UTiLity are programs for the simulation of stream flow. FEQ simulates flow in a stream system by solving the full, dynamic equations of motion for one-dimensional unsteady flow in open channels and through control structures. It is designed to follow the structure of a stream system while providing maximum generality and flexibility of description. In FEQ a stream system is divided into three classes of flow paths: (1) stream reaches or branches; (2) parts of the system for which complete information is not required, e.g. dummy branches; and (3) level-pool reservoirs. These components are connected by features or hydraulic control structures such as junctions, bridges, culverts, dams, waterfalls, spillways, weirs, side weirs, pumps, etc. The hydraulic characteristics of channel cross-sections and special features are stored in function tables calculated by the companion program FEQUTL. Allowable boundary conditions include water surface stage, discharge, or the stage-discharge relationship at a node.
A source code distribution of FEQ for UNIX platforms is available. The primary documentation is contained within Franz and Melching (1997). This is part of the USGS Water Resources Applications Software collection.
[http://water.usgs.gov/software/feq.html]
[http://www.geogr.uni-jena.de/software/feq.html]
FERMID/FERINC: A set of portable Fortran routines for computing the Fermi-Dirac integral and the incomplete Fermi-Dirac integral. A set of series expansions is implemented that allows these special functions to be efficienctly evaluated within a prescribed accuracy. This is TOMS algorithm 745 and is documented in Goano (1995).
[http://www.acm.org/calgo/contents/]
[http://www.netlib.org/toms/index.html]
Fermitools: A program to provide the software packages developed at Fermilab that are useful and are of general interest to other application domains. The Fermilab packages that have been ported to Linux include:

sjyLX, a CAMAC-related instrumentation package;

NEdit, a GUI-style text editor; and

ROBIN, a CORBA-compliant distributed object and remote procedure call system.

[http://www.fnal.gov/fermitools/]
FESI: The Free EcmaScript Interpreter is a full implementation of the EcmaScript language, which is mostly equivalent to JavaScript version 1.1 or to the core part of JScript without the Navigator-specific extensions. FESIS consists of a library that allows it to be used as a macro language for Java applications and an interactive interpreter.
[http://home.worldcom.ch/jmlugrin/fesi/]
Festival: A general multi-lingual speech synthesis system developed at the Centre for Speech Technology Research at the University of Edinburgh. Festival is a full text to speech system with various APIs as well as an environment for the research and development of speech synthesis techniques. It is written in C++ with a Scheme-based command interpreter (SIOD) for general control. The features of Festival include:

English (British and American), Spanish and Welsh text to speech;

externally configurable language independent modules including phonesets, lexicons, letter-to-sound rules, tokenizing, part of speech tagging, intonation and duration;

waveform synthesizers;

MBROLA database support; and

SSML/STML, Emacs, client/server, and scripting interfaces.

A source code distribution of Festival is available as are binaries for Linux Intel platforms. A large user's and reference guide is available in PostScript format.
[http://www.cstr.ed.ac.uk/projects/festival.html]
[http://www.speech.cs.cmu.edu/festival/]
FESWMS: The Finite Element Surface-Water Modeling System for two-dimensional flow in the horizontal plane is a modular set of programs that simulate 2-D, depth-integrated surface-water flows. The programs were developed to analyze flow at bridge crossings where complicated hydraulic conditions exists, although they can also be applied to many other types of steady or unsteady flow problems in shallow rivers, flood plains, estuaries, and coastal seas.
The programs comprising FESWMS are:

DINMOD, an input data preparation program designed to assist in developing a finite element network that is free from errors, although it can also be used to refine, update, or modify an existing network;

FLOMOD, a flow model program which can simulate either 1- or 2-D flow and includes the effects of bed friction, turbulent stresses, surface wind stresses, and the Coriolis force;

ANOMOD, a simulation output analysis program or postprocessor which can present the results of flow simulations graphically and in report form, with output types including plots of velocity and unit-flow vectors, ground surface and water surface elevation contours, and time-history graphcs of velocity, unit-flow, or stage at a computation point; and

HPPLOT, a general purpose program to plot HPGL graphics files in an X Window.

A source code distribution of FESWMS for UNIX platforms is available. The primary documentation is contained within Froehlich (1989). This is part of the USGS Water Resources Applications Software collection.
[http://water.usgs.gov/software/feswms.html]
[http://www.geogr.uni-jena.de/software/feswms.html]
fetchmail: A solution to the remote mail retrieval problem for UNIX machines, i.e. useful to anyone with an intermittent PPP or SLIP connection to a remote mailserver. It can collect mail using any variant of POP or IMAP and forwards the mail via port 25 to the local SMTP listener. This enables all the normal forwarding/filtering/aliasing mechanisms to be used the same as they would be to local mail or mail arriving via a full-time TCP/IP connection. Fetchmail is capable of transparently handling every retreival demand from those of a single-user ISP connection up to mail retrieval and rerouting for an entire client domain. Is is easy to configure, unobtrusive in operation, powerful, well-documented, and has many features.
The features of fetchmail include:

automatic decoding of armored 7-bit MIME into 8 bits;

configuration of which SMTP error is recognized as a SPAM block;

support for Kerberos V authentication;

support for IMAP-OTP authentication;

support for IPv6 and IPSEC;

support for IMAP with RFC-1731 conformant GSSAPI authentication;

fixed and verified support for the Cyrus IMAP server and a couple of others available on much less elegant operating systems;

support for multiple-folder retrieval in a single session under IMAP;

support for a hunt list of SMTP hosts;

support for ESMTP 8BITMIME and SIZE and options and the ETRN command;

support for secure use with ssh;

optional transaction and error logging;

host is auto-probed for a working server if no protocol is specified for the connection;

configurable timeout to detect if server connection is dropped; and

support for retrieving and forwarding from multi-drop mailboxes guaranteed not to cause mail loops.

The source code for fetchmail is available. It is written in C and can be compiled on most generic UNIX boxes with a C compiler via the use of the included configuration file. It is documented via a FAQ and a man page included in the distribution.
[http://www.tuxedo.org/~esr/fetchmail/]
fetchpop: A POP3 mail client featuring:

capability of running as a daemon process;

capability of running in script files;

interoperability with procmail and .forward files;

mail folder protection with exclusive write-lock on mail folder files;

retrieval of only new unread messages; and

retrieval of specific messages.

A source code distribution is available.
[http://sunsite.unc.edu/pub/Linux/system/mail/pop/]
FFC: The Firewall Foundation Classes are a reusable C++ library designed to aid in the construction of safe Internet clients, servers and firewalls. The features of FFC include:

a generic relay object with transparency support;

an integrated netacl for simple IP-based source/destination access control;

a simple HTTP server object;

encryption support;

a Tcl interface that allows FFC objects to be configured with a Tcl script;

user-defined permission functions; and

a non-forking server object for low system impact.

The FFC package also includes VOOM, a multiplatform proxy/web server built on top of FFC. A source code distribution is available which can be compiled and used on several platforms including Linux Intel on which, by the way, it is being developed. Documentation is currently (6/98) in the embryonic stage.
[http://www.brd.ie/download/index.html]
ffcall: A collection of four libraries which can be used to build foreign function call interface in embedded interpreters. These libraries are:

avcall, for calling C functions with variable arguments;

vacall, C functions accepting variable argument prototypes;

trampoline, closures as first-class C functions; and

callback, closures with variable arguments as first-class C functions.

A source code distribution is available.
[http://clisp.cons.org/~haible/packages-ffcall-README.html]
ffGraph: A C++ class library for creating, manipulating, and displaying directed graphs. Graphs consist of a set of nodes and edges where edges have exactly one target and one source. The ffGraph library was designed to offer both a graph data structure and a powerful means to display it, a combination of features lacking in most similar packages which either have one or the other or are too specialized. The classes in the library provide an interface which is easy-to-use and save; the capability of binding user-specific data to graphs, nodes, and edges; and a powerful and flexible mechanism for displaying graphs. The Tcl/Tk toolkit is used to provide graphics capabilities in ffGraph.
The classes available in ffGraph include:

FFGraphClass, which provides standard methods to manipulate graphs;

FFNodeClass, which provides methods to manipulate nodes;

FFEdgeClass, which provides methods to manipulate edges;

FFLabelClass, a superclass of all labels which defines methods which all labels must provide;

FFGraphLabel, FFNodeLabel, and FFEdgeLabel, classes for labeling graphs, nodes, and labels;

FFSugi, which implements a Sugiyama layout algorithm;

FFSpring, which implements a spring-embedder layout algorithm;

FFWindow, a general class for executing Tcl/Tk scripts;

FFGraphicNode and FFGraphicEdge, which contain the graphic information needed to display nodes and edges;

and several more.
A source code distribution of ffGraph is available. It is written in C++ and has been compiled on several UNIX flavors using g++ 2.6.3 or higher. It also requires Tcl 7.4 or greater, Tk 4.0 or greater, and the XPM library. It is documented in an extensive user's manual available in either HTML or PostScript format.
[http://www.fmi.uni-passau.de/~friedric/ffgraph/main.shtml]
FFT: The Fast Fourier Transform is a bloody handy thing to have around.
Related packages and sites include:

benchFFT, a program for benchmarking FFT implementations;

FFTPACK

FXT

VSIP, a project to develop a standard for vector, signal and image processing primitives for embedded real-time signal processing systems;

[http://www.jjj.de/fxt/fxtpage.html]
[http://theory.lcs.mit.edu/~benchfft/doc/ffts.html]
FFTPACK: A collection of Fortran programs to perform FFTs for both real and complex periodic sequences and certain other symmetric sequences. The routines in FFTPACK include;

RFFTF, for a forward transform of a real periodic sequence;

RFFTB, for a backward transform of a real coefficient array;

EZFFTF, a simplified real periodic forward transform;

EZFFTB, a simplified real periodic backward transform;

SINT, a sine transform of a real odd sequence;

COST, a cosine transform of a real even sequence;

SINQF, a forward sine transform with odd wave numbers;

SINQB, an unnormalized inverse of SINQF;

COSQF, a forward cosine transform with odd wave numbers;

COSQB, an unnormalized inverse of COSQF;

CFFTF, a forward transform of a complex periodic sequence; and

CFFTB, an unnormalized inverse of CFFTF.

There are also routines for initializing each of the above routines.
A source code distribution of FFTPACK is available. The documentation is contained in a README file as well as in the source code itself.
[ftp://ftp.ucar.edu/dsl/lib/fftpack/]
[http://www.netlib.org/fftpack/index.html]
FFTPACK++: A C++ wrapper for FFTPACK complex routines which uses LAPACK++ matrix and vector classes. The source code for FFTPACK++ is available. Compilation and use requires gcc 2.6.3 or later, the LaMatrix++ class library from LAPACK++, and possibly the original FFTPACK and f2c.
[http://www.xraylith.wisc.edu/~khan/software/fftpack/]
FFTW: The Fastest Fourier Transform in the West is a C subroutine library for performing the discrete Fourier transform (DFT) in one or more dimensions. This is usually faster (and sometimes much faster) than all other public domain Fourier transform programs. It can do this because it comes with a code generator that produces C programs for any particular array size you may have. It also doesn't use a fixed strategy but finds an optimal decomposition strategy (e.g. for decomposing a big problem into smaller problems) at runtime for the machine on which it is running. FFTW is also portable since it automatically adapts itself to your machine, your cache, the size of your memory, the number of registers, and all the other factors that usually make it difficult to optimize a program for more than one machine.
The FFTW distribution includes the source code, written in ANSI C, and a manual in Texinfo format. The distribution also contains the program used to generate the code that FFTW uses to compute the transforms. It is written in Caml Light, a dialect of ML which can also be obtained to experiment with the code generator.
[http://www.fftw.org/]
fgen: A makefile and dependencies generator for Fortran 77 or 90 source code. This is a Perl 5 script that produces makefiles for GNU Make and is easy to customize. Included are configuration files for several compilers. Also included is a program called f2html which converts Fortran 77 or 90 source code into HTML. The user can specify a set of colors for keywords, comments, and other structural parts of the code.
[http://sunsite.unc.edu/pub/Linux/devel/lang/fortran/]
FHDL: The Florida Hardware Design Language is an extensible system for specifying and simulating digital circuits at the logic level. The features of FHDL include:

a flexible gate description syntax with each statement consisting of a label field, an operation code, and a list of operands;

a variety of gate types including simple combinational gates, and-or-inverts, or-and-inverts, flip-flops, tristate gates, special functions and functional blocks;

subcircuit capabilities;

algorithmic state machines (ASMs);

circuit simulation;

low- and high-level ROM/PLA specifications via ROM/PLA preprocessors that transform high-level ROM/PLA encodings into low-level FHDL ROM/PLA specifications;

a macro processor providing an convenient method for expanding the FHDL language; and

a test driver language for simplifying the process of creating and running functional tests.

Several research simulators based on the FHDL package are available. A C source code distribution is available for UNIX platforms. System installation requires compiling and installing six separate source packages. A user's manual is available as a PDF document.
[http://www.csee.usf.edu/~maurer/fhdl.html]
fhist: A package containing three source control utilities. These are: fhist, which keeps track of versions of a file; fcomp, which compares to versions of a file; and fmerge, which merges together edits from two descendants of a file.
The fhist distribution contains the source code which is written in ANSI C. Installation on most generic UNIX platforms is straightforward using the configure script included in the package. The utilities are documented in man pages.
[ftp://ftp.agso.gov.au/pub/Aegis/]
FHS: A filesystem hierarchy standard for Linux and other UNIX-like systems. FHS defines a common arrangement of the files and directories in UNIX-like systems upon which many developers have agreed. It is intended mainly for implementors of Linux and UNIX distributions, but is also useful for system administrators and users.
[http://www.pathname.com/fhs/]
fhttpd: The file/hypertext transfer protocols daemon is a general-purpose FTP/HTTP server. The features of fhttpd include:

HTTP 0.9, 1.0 and rudimentary 1.1 support;

FTP (RFC 959 with passive mode) support;

virtual FTP/HTTP servers (both with separate IP addresses and hostname aliases);

processing of CGI scripts;

application modules implemented as constantly running processes on the same machine or across the network;

access to files and CGI scripts on remote hosts running file I/O and support modules;

remapping based on client-supplied information;

different pages or applications for different clients or options without additional executables;

access restrictions defined by password files and configuration scripts;

support for server-side imagemaps without scripts; and

preloaded files sent to users asynchronously.

A source code distribution is available which can be compiled and used on several platforms including Linux Intel, although at present (4/98) there is a problem which libc detailed at the site.
[http://www.fhttpd.org/]
Fiasco: A microkernel running on x86 machines that is intended to be compatible with the L4 microkernel for x86, i.e. it implements the L4 ABI as defined in the reference manual for that package. A microkernel is an OS kernel providing only essential services such as tasks, threads, IPC, and memory management primitives. All servers run in user mode and are treated just like any other application since each runs in its own address space. Fiasco can be used to construct big and complex as well as small, embedded applications. It is the first L4-compatible kernel that supports real-time applications since it is preemptible as virtually any time. This guarantees low activation latencies for threads with high priorities. It is also constructed around non-blocking synchronization strategies, which prevents in-kernel deadlocks and priority inversions while making programming the kernel easier.
A source code distribution of Fiasco (written in C++) is available. Compilation requires some other packages detailed at the site and booting requires the GRUB bootloader.
[http://os.inf.tu-dresden.de/fiasco/]
FIASCO: A collection of tools for processing functional magnetic resonance imaging (fMRI) data. The functionality includes performing a variety of statistical tests for experimental paradigms, echo planar imaging, spiral imaging, and multi-shot imaging. FIASCO can run on parallel platforms using multiple CPUs. The data transformation utilities include:

baseline2, which reads and baseline-corrects right and left images for two-shot catch and hold data and combines them into a single image;

cross, combines two MRI files at different times into a single file;

intsplit, converts a file with information on experimental conditions into an image-by-image condition specification;

partialk, extends the negative phase direction of k-space data collected with all positive but only partial available negative information;

permute, changes the storage order of the dimensions of a chunk of a dataset;

phadj, implements a global phase change across complex images to maximize phase similarity among a sequence;

recon, applies the 2-D inverse FFT to a set of images;

sgrid, regrids spiral scan data to a regular grid in k-space; and

srecon, transforms spiral data on a k-space grid to coordinate space.

The statistical analysis programs include:

mri_anova, takes a pgh MRI dataset of type TXYZ and information about an experimental design and produces a number of datasets of type XYZ containing F-statistics for the various design parameters;

outlier, identifies and pulls in outliers;

stats, calculates the mean and standard deviation for all experimental conditions as well as pairwise, pooled, two sample t-statistics;

summary, calculates summary statistics for the various paramters outputs; and

vmpfx, fits a flexible, hierarchical statistical model voxelwise to a fMRI time series.

The image processing programs include:

clip, for cropping images;

imtops, generates PostScript output; and

overlay, thresholds a map and overlays the thresholded pixels onto an image.

The data reduction programs include:

baseline, corrects for the arbitrary location of k-space data and reverses lines as needed;

deghost, reduces ghosting effects in images;

detrend, removes linear, temporal trends from an image sequence;

displace, takes a estireg output file and calculates hte mean distance a pixel is displaced by such a registration for each set of registration parameters;

estireg, estimates the parameters of within-slice, 2-D, rigid-body motions of an image sequence with respect to a given fixed image;

ireg, performs 2-D motion correction on a set of images;

meanc, coerces all images to have approximately identical means to adjust for global drifts in signal intensity; and

smregpar, smooths registration paramters generated by estireg.

A source code distribution of FIASCO is available. It is written in C and requires PVM, LAPACK and FFTW for full usage. Documentation is scattered about the site.
[http://www.stat.cmu.edu/~fiasco/]
fibre channel: A 1 gigabit per second data transfer interface technology that maps several common transport protocols including IP and SCSI. This allows it to merge high-speed I/O and networking functionality in a single connectivity technology. It is an open standard defined by ANSI and OSI and operates over copper and fiber optic lines for up to 10 kilometers. It is unique in that it supports multiple interoperable topologies including point-to-point, arbitrated-loop and switching as well as several qualities of service for network optimization. A key concept is that of a universal ``fabric'' similar to a telephone switch in that calls are made without having detailed knowledge of the interconnection method between the two points. This supports topology independence in that any node adhering to the generic interface between each node and the physical layer connecting the nodes can communicate with any other node without needing specific knowledge of the interconnection method between nodes.
Linux-related software includes:

GFS, a project to develop a serverless file system to exploit interfaces like fibre channel.

[http://www.fcloop.org/]
[http://www.fcgroup.com/]
ficl: The Forth Inspired Command Language is an ANS Forth interpreter written in C. Ficl is designed to be embedded into other systems as a command or macro or development prototype language. It provides object extensions that can be used to wrap methods and structures of the host system without altering them. It acts as a component of the system, allowing the easy exportation of code written in C or ASM or the invocation of Ficl code from a compiled module. This allows incremental development in a way that combines the best features of threaded languages with the best features of C. The features of Ficl include:

targeting 32- and 64-bit processors;

an interface to functions written in C;

conformance with the Forth DPANS 94 specs;

code written in ANSI C for portability;

thread-safe and re-entranct Ficl coding; and

a type 1 indirect threaded interpreter.

[http://www.taygeta.com/ficl.html]
FIDOGATE: A FidoNet-Internet gateway and a Fido tosser. FIDOGATE converts between Fido NetMail/EchoMail (or Fido Technology Networks, i.e. FTNs, in general) and the UNIX mail and news system. IT will convert Fido mail packets to RFC-822 and RFC-1036 style messages and vice-versa. The package also includes a complete FIDO mail processor (i.e. a NetMail/EchoMail scanner and tosser), an FTN-FTN gateway (for NetMail only), a file processor (TIC file areas), and an AreaFix/Filefix program. It does not include a FIDO mailer, but can cooperate with the ifcico program from the ifmail package.
A source code distribution of FIDOGATE is available which will compile and install on many UNIX flavors. Its use requires a installed news system, a news reader, a mail transport agent (MTA), a mail user agent (MUA), and Perl. A user's guide is available in several formats.
[http://www.fido.de/fidogate/]
FidoNet: A group of around 30,000 computer systems worldwide which form a network which exchanges mail and files via modems using a proprietary protocol, i.e. a conferencing system similar to Usenet newsgroups. FidoNet newsgroups are known as Echoes and the mail in them as EchoMail, and most are smaller than Usenet groups (as well as moderated). It is a ``store and forward'' system similar to UUCP in which users send messages or replies to another system up the line which forwards them ad infinitum. FidoNet also has a private mail system known as NetMail or MatrixMail which is similar to Internet mail and has several gateways which allowing mailing to Internet addresses from FidoNet. FidoNet can also be used to distribute files containing programs, pictures, text, etc. using a system similar to EchoMail that is somewhat more centralized. A system subscribes to a File Distribution and then receives all of the files placed into that distribution.
FidoNet is organized into zones, regions, networks, and individual nodes. The zones are: 1 for North America, 2 for Europe, 3 for Australia, 4 for South America, 5 for Africa, and 6 for Asia. Regions are administrative sub-blocks of zones and networks local areas within the regions. A node is usually a single machine. Addresses are of the form zone:net/node.point, e.g. 2:259/7 would be in Europe at net 259 in Scotland at node 7 in Kooosliam. A point can be a sub-node of a node. Available FidoNet software includes FIDOGATE, ifmail, and ifmail-tx.
[http://www.fidonet.org/]
FIGARO: A Starlink Project general purpose reduction package for a wide range of images and spectra. It is most often used for reducing spectroscopic data but also has powerful image and data cube manipulation facilities. It can be run in command-line run from the UNIX shell and also from the Starlink ICL interface. It supports the NDF data format as well as all formats which which conversion utilities exists, including the DST, FITS, and IRAF formats.
The 230+ commands available in FIGARO are divided into several broad categories. These include commands for data input, data output, data display, wavelength calibration, B-star calibration, arithmetic operations, flat fields, data manipulation, aperture photometry, line analysis, S-distortion and échelle order straightening, fudging data, examining data, slicing through images and cubes, fibre data, flux calibration, extinction, complex data and FFTs, infra-red data, échelle data, and miscellaneous tasks.
A binary distribution of FIGARO is available for DEC OSF/1, Linux Intel, and Sun Solaris platforms. It is documented in a 150 page user's manual available in PostScript format.
[http://star-www.rl.ac.uk/store/storeapps.html]
Figue: An incremental 2-D layout engine written in Java.
[http://www-sop.inria.fr/croap/figue/web/figue.html]
Filaments: A library that can be used to create architecture-independent parallel programs. Filaments creates a virtual machine in terms of the number of processors and the interconnections to simplify programming. This allows programs to be developed focusing on the parallelism of the application rather than the platform. It also allows programs to be written using familiar shared-variable communication techniques. It uses a carefully designed API and machine-specific runtime libraries and preprocessing to allow programs to run unchanged on both shared and distributed memory machines. Among the supported architecture/OS combinations is a cluster of Linux Intel machines.
[http://www.cs.uga.edu/~dkl/filaments/dist.html]
FILE: The Free OnlIne Lexicon and Encyclopedia is a project designed to fill in the gaps that exist in other large freely available dictionary databases. The site has a large list of requested words still not defined in the database and a forms interface that allows you to supply definitions for those as yet undefined terms.
[http://www.dict.org/file.html]
file managers: A program for keeping track of and performing various manipulations on files. This can be either GUI or command-line based. Packages that are either file managers themselves or which contain file managers as part of a suite of tools include:

DFM

FileMan

FileRunner

FSViewer

gentoo

GNOME

KDE

Midnight Commander

Pash

TKAPPS

TkDesk

Unix Cockpit

VFU

XNC

Xplore

X-Plorer

Ytree
FileMan: A file manager for UNIX platforms which is more configurable and powerful than most. The features of FileMan include:

multiple window support;

drag and drop between windows for copying, moving, and deletion;

a managed trashcan;

dropping files on the desktop;

event and error logging;

full configuration of menus, file types, double clock operations, an application toolbox, a button bar, and window view characteristics;

security features;

graphical configuration and installation for all environments;

built-in menus to graphically manage splitting files,

encoding/decoding files, compression and uncompression,

spelling checking, word counting, file viewing and editing, running programs, and archive creation and extraction;

some HTML-based online help;

requester level help;

web-like symbolic links;

customizable pixmaps; and

file partition information available on the main screen.

A binary distribution of FileMan is available which supports Linux, Solaris 2.5x+ and AIX 4.1 systems. A manual is included in PostScript format.
[http://www.bongo.demon.co.uk/]
[http://sunsite.unc.edu/pub/Linux/Incoming/]
FileRunner: A simple and efficient X11 file manager. The features include:

a simple and powerful interface;

history and a hostlist;

recursive directory menus of entire file system trees;

extensive FTP capabilities;

asynchronous file operations;

a built-in command shell window synchronized with file panels;

extensibility and configurability; and

user defined file pattern actions.

This is built using C and Tcl/Tk.
[http://www.cd.chalmers.se/~hch/filerunner.html]
fileutils: The GNU file managment utilities, most of which have significant advantages over their UNIX counterparts, e.g. greater speed, additional options, and fewer arbitrary limits. The fileutils are intended to be POSIX.2 compliant and are mostly so as of 9/97.
The programs in the fileutils collection include:

ls, for listing information about files in one or more directories;

dir, which lists files in columns which are vertically sorted (i.e. equivalent to ls -C);

vdir, which lists files in long format (i.e. equivalent to ls -l);

dircolors, which outputs a sequence of commands to set up the termianl for color output from ls etc.;

cp, which copies files and directories;

dd, which converts and copies files with a changable I/O blocksize;

install, which copies files while setting their permission modes and, if possible, their owner and group;

mv, which moves or renames files;

rm, which removes files or directories;

ln, which makes soft or hard links between files;

mkdir, which creates directories;

mkfifo, which creates FIFOs (i.e. named pipes);

mknod, which creates a FIFO, character special file, or a block special file;

rmdir, which removes empty directories;

chown, which changes owner and group of a file;

chgrp, which changes the group ownership of a file;

chmod, which changes the access permissions of a file;

touch, which changes file timestamps;

df, which reports filesystem disk space usage;

dn, which estimates file space usage; and

sync, which synchronizes data on disk with memory, i.e. writes any data buffered in memory out to disk.

A source code distribution of the fileutils is available. All of the programs are written in C and can be compiled and installed on many platforms via the supplied autoconf scripts. The utilities are documented in a user's guide supplied in Texinfo format.
[http://www.gnu.org/software/fileutils/fileutils.html]
filesystems: Filesystems and filesystem-related utilities available for the Linux platform include:

AMD, which maintains a cache of mounted filesystems;

am-utils, a replacement for AMD;

Arla, a free implementation of AFS;

BFS, a BeOS file system driver for Linux;

Charon, a distributed filesystem under development (9/99);

CIFS, a remote file system access protocol;

Coda, an advanced networked file system descended from AFS;

DiskSim, a disk system simulator;

e2fsprogs, a library and set of utiliites for working with ext2 filesystems;

ext2fs, the most widely used filesystem on Linux platforms;

EXT2-OS2, a package for accessing Linux ext2 partitions from OS/2;

ext2resize, a program for resizing ext2 filesystems;

FHS, a filesystem hierarchy standard for Linux;

FUFS, a parallel filesystem for workstation clusters;

Galley, a parallel filesystem for tightly-coupled multiprocessors and workstation networks;

GFS, a serverless file system;

hfs_fs, a kernel module which implements the Macintosh HFS file system under Linux;

JFS, IBM's journaled file system ported to Linux;

mkhybrid, a package for creating ISO-9660/HFS/JOLIET CD volumes;

MPCFS, a virtual file system for multipoint communications;

mtools, utilities for accessing MS-DOS disks from UNIX;

netatalk, an implementation of the Appletalk Protocol Suite for UNIX which includes a Mac interface to the UNIX filesystem;

ncpfs, programs for accessing a Novell server;

NTFS, a driver for the NT filesystem;

PIOUS, a parallel I/O system for the PVM environment;

ppdd, an advanced encrypted file system;

recover, a utility for automating some of the steps involved in recovering deleted files;

rumba, for mounting drives exported by Windows, LAN Manager and OS/2;

reiserfs, an experimental file system implementing a balanced tree algorithm;

smbfs, a client for mounting drives exported by Windows and various other systems;

Samba, a package for allowing Windows NT/95 clients to access a UNIX filesystem;

StegFS, a steganographic filesystem for Linux;

TCFS, a transparent cryptographic filesystem;

util-linux, a collection of utilities including several for filesystem maintenance;

userfs, a program that allows normal user processes to be Linux filesystems for the creation virtual filesystems;

u2fs, a driver for providing UFS filesystem support;

Vanilla, a configurable mixed-media filesystem;

VFAT, a UNIX filesystem compatible with Windows NT/95 long filenames on the FAT filesystem; and

WVfs, a version control filesystem.

[http://www.penguin.cz/~mhi/fs/Filesystems-HOWTO/Filesystems-HOWTO.html]
FI_LIB: A fast interval arithmetic library written in ANSI C. The features include:

fast table look-up algorithms for the basic functions;

all elementary functions supplied with reliable relative error bounds of high quality;

all error estimates are reliable worst-case estimates derived using interval methods;

faithful computer arithmetic, i.e. the routines do not manipulate the rounding mode of basic operations;

all computations are done using the IEEE double format (64 bit) and not with a higher precision internal data format; and

a C++ interface.

[http://www.math.uni-wuppertal.de/org/WRST/software.html]
FilterDesign: A package consisting of a pair of programs for designed linear phase Finite Impulse Response (FIR) filters. The programs are:

DFiltFIR, which designs minimax approximation FIR filters using an algorithm developed by McLellan and Parks; and

DFiltInt, which designs minimum mean-square error FIR interpolating filters with the design specification in terms of a tabulated power spectrum model for the input signal.

A source code distribution is available. Both programs are written in C and have been compiled on a range of compilers.
[ftp://worldserver.com/pub/malcolm/]
findgrep: A utility that recursively greps in the current directory and its subdirectories. It uses regular expressions to specify the search expression and the filename, and has support for approximate matches. It can also exclude files and/or directories. A source code distribution of this Perl script is available.
[http://members.xoom.com/gregersenweb/findgrep/]
findutils: A set of GNU utilities for finding files and performing actions on them once they're found. The programs in the distribution include:

find, which searches for files in a directory hierarchy and prints information about the files it finds;

locate, which searches special file name databases for file names that match patterns;

xargs, which builds and executes command lines by gathering together arguments it reads on standard input, e.g. lists of file names generated by find; and

updatedb, which creates the databases used by locate.

A source code distribution of findutils is available. It is written in C and can be compiled and installed on many types of platforms via the autoconf scripts supplied with the distribution. The programs are documented in a user's and reference manual supplied in Texinfo format.
[http://www.gnu.org/software/findutils/findutils.html]
Finesse: A tool to generate and evaluate windows in shell scripts. This allows the easy conversion of the dialog portions of existing scripts to a mouse-oriented Motif user interface. No knowledge of programming X Windows is needed since the windows are generated by several easy-to-use commands that are called in the script. A graphical shell script user interface can thus be developed quickly and easily. Binaries of Finesse are available for DEC Alpha, HP9000, SGI Iris, IBM RS6000, SUN4, and Linux platforms, and documentation is available in both German and English.
[ftp://ftp.science-computing.uni-tuebingen.de/pub/finesse/]
finite element methods: A repository for software, documentation, papers and other resources pertaining to finite element methods. This is maintained by Roger Young.
Related packages include:

OFELI, an object-oriented library of C++ classes for developing finite element codes.

[http://www.engr.usask.ca/~macphed/finite/ fe_resources/fe_resources.html]
FINV: A Fortran program for evaluating the incomplete beta function ratio. This is TOMS algorithm 724 and is documented in Abernathy and Smith (1993).
[http://www.acm.org/calgo/contents/]
[http://www.netlib.org/toms/index.html]
FIPS: The First nondestructive Interactive Partition Splitting program is a DOS program for splitting hard disk partitions in a nondestructive way. It is designed to split an existing DOS partition without deleting the data on it, although a defragmentation program must first be used to move all data to the beginning of the hard disk. This was developed under DOS 5.0. FIPS reduces the size of a partition by changing some values in the partition table and boot sector, although it does not change the formatting of the partition (e.g. the cluster size and the size of the file allocation table, i.e. FAT). The reduced partition will have a partially unused FAT, but this causes no problems and a new primary DOS partition is created from the space created via this procedure.
[http://www.igd.fhg.de/~aschaefe/fips/]
FIRE: A C++ class library implementing finite automata and regular expression algorithms. This provides all known algorithms for constructing finite automata, with the implementations developed for efficiency. The toolkit is intended for integration into applications, and as such no shell or GUI is provided. This is documented in a tutorial document as well as in a large reference manual, both of which are available in PostScript format.
[ftp://ftp.win.tue.nl/pub/techreports/pi/automata/toolkit/]
firewall: A firewall is a program that protects a private network from a public network, e.g. the Internet. The computer running the firewall can reach both the protected and public networks, but the protected network can't reach the public one and the public network can't reach the protected one. A simple and popular firewall setup consists of a machine with two network connections. The two main types of firewalls are:

an IP or filtering firewall that blocks all but selected network traffic; and

a proxy server that automatically makes network connections, i.e. you make a connection to the proxy server and it automatically makes a connection to another machine.

The kernel has included packet filtering software since version 1.3.x.
Helpful sites and documentation include:

Linux Firewall and Security Site
[http://rlz.ne.mediaone.net/linux/]

Linux Internet Server Administration Guide
[http://lisa.8304.ch/]

Linux Security Administrator's Guide
[http://www.nic.com/~dave/SecurityAdminGuide/SecurityAdminGuide.html]

Linux Administrator's Security Guide
[http://metalab.unc.edu/lasg/lasg-faq.html]

Firewall and Proxy Server HOWTO
[http://www.linuxdoc.org/HOWTO/Firewall-HOWTO.html]

Firewall Piercing Mini-HOWTO
[http://www.linuxdoc.org/HOWTO/mini/Firewall-Piercing.html]

See also Chapman and Zwicky (1995).
Software packages related to firewalls include:

DNi, a GUI for configuring firewall rules, i.e. a front-end for ipfwadm;

Falcon, a project to develop a free, secure and OS-independent firewall system;

FFC, a C++ library for constructing safe Internet clients, servers and firewalls;

Firewall Configuration Tool, which is fairly self-explanatory;

floppyfw, a single floppy distribution to turn a PC into a static router with firewall capabilities;

Freestone, a portable firewall implementation;

Fwctl, a high-level firewall configuration program;

gfcc, a GUI front-end for controlling firewall policies;

httptunnel, creates a bidirectional virtual data path tunnelled in HTTP requests;

ipchains, a firewalling chains package;

ipchains-firewall, a set of scripts for creating and maintaining an IP masquerade/firewall system;

IP Filter, a TCP/IP packet filter for use in a firewall environment;

IPFT, a security package with firewall checking capabilities;

ipfwadm, for administering IP accounting and firewall services offered by the kernel;

IPfwd, a tool for redirecting arbitrary IP protocol datagrams;

Linuxconf, an administration tool that can be used to configure firewalls and many other things;

LRP, a minimal distribution to for building routers that includes firewall capabilities;

Mason, a tool for interactively building a firewall;

masq, utilities for managing a firewall;

sifi, a TCP/IP packet filter;

SOCKS, a standard and related software for performing network proxies;

TrinityOS, a guide to setting up a Linux server which includes firewall information;

Trinux, a security-related Linux distribution with firewall capabilities.
Firewall Configuration Tool: The FCT is a configuration tool for setting up a firewall on a Linux box with an HTML browser. It uses separate configuration files for setting: network definitions (e.g. domain name); allowed connections to and from the firewall; allowed connections to and from internal networks; definitions of trusted IPs; alias definitions; the necessary IP connections for each service; the source and destination for each service; and rules to set up the services. The FCT is documented in HTML files included in the distribution.
[http://home.nikocity.de/friedrichnet/FCT.htm]
[http://sunsite.unc.edu/pub/Linux/system/network/admin/]
FireWire/iLINK: A serial data transfer protocol and interconnection system for providing the same services as IEEE standard parallel buses at a lower cost. It is rapidly being adopted for the digital video and audio consumer markets since it can support a variety of high-end applications such as cnsumer audio/video device control and signal routing, home networking, nonlinear DV editing, and 32-channel digital audio mixing. The IEEE 1394 standard defines two bus categories - backplane and cable. The backplane bus is designed to supplement parallel bus structures by providing an alternate serial communication path between devices plugged into the backplane, and the cable bus is a non-cyclic network with finite branches consisting of bus bridges and nodes or cable devices. FireWire is the name trademarked by Apple for the protocol, and iLINK the name trademarked by Sony.
[http://www.1394ta.org/]
[http://www.skipstone.com/info.html]
[http://www.zayante.com/p1394b/]
[http://www.adaptec.com/technology/standards/1394bus.html]

GNU/Linux IEEE 1394 Project

The IEEE 1394 specification is for a high speed and low cost serial bus system designed to provide best effort data transport and quality of service. The goals of the GNU/Linux project are:

to create an IEEE 1394 driver stack;

to support popular PCI-to-1394 chipsets and adapter cards;

to provide support for IEEE 1394 devices;

to support IP-over-1394 networking; and

to support IEEE 1394 in real-time environments.

[http://eclipt.uni-klu.ac.at/ieee1394]
FISHPAK: A collection of Fortran programs for solving problems involving separable ellliptic PDEs. The available routines include:

HWSCRT, for solving a five-point finite difference (FD) approximation to the Helmholtz equation in Cartesian coordinates using a centered FD grid;

HWSPLR, for solving the same in polar coordinates;

HWSCYL, for solving the same in cylindrical coordinates;

HWSSSP, for solving the same in spherical coordinates on the surface of the unit sphere;

HWSCSP, for solving a five-point FD approximation to the modified Helmholtz equation in spheric coordinates assuming axisymmetry (i.e. no dependence on longitude);

HSTCRT, the same as HWSCRT but with a staggered FD grid;

HSTPLR, the same as HWSPLR but with a staggered FD grid;

HSTCYL, the same as HWSCYL but with a staggered FD grid;

HSTSSP, the same as HWSSSP but with a staggered FD grid;

HSTCSP, the same as HWSCSP but with a staggered FD grid;

HW3CRT, the same as HWSCRT but with a seven-point approximation;

SEPX4, automatically discretizes and solves second or fourth order FD approximations on a uniform grid to certain separable elliptic PDEs with constant coefficients in one direction;

SEPELI, same as SEPX4 except to a PDE on a rectangle;

GENBUN, solves the linear system of equations that results from a FD approximation on a centered grid to certain 2-D elliptic PDEs with constant coefficients in one direction;

BLKTRI, solves block tridiagonal systems which arise in such problems;

POISTG, solves the same block tridiagonal system for 2-D elliptic PDEs with constant coefficients in one direction;

POIS3D, solves the same sort of equation system in a box;

CMGNBN, solves a complex block tridiagonal linear system arising from FD approximations to separable complex 2-D elliptic PDEs; and

CBLKTR, another method for solving the previous situation.

A source code distribution of FISHPAK is available. All routines are written in Fortran 77 and documented via comment lines in each source code file. This is part of CMLIB. See Swarztrauber and Sweet (1979).
[http://www.scd.ucar.edu/softlib/FISHPAK.html]
[http://www.netlib.org/fishpack/index.html]
[http://sunsite.doc.ic.ac.uk/public/computing/general/statlib/cmlib/
FISMAT: The Fuzzy Inference System for Matlab includes programs implementing different arithmetic operators, fuzzification and defuzzification algorithms, implication relations, and different methods of approximate reasoning such as the Compositional Rule of Inference (CRI) and the Approximate Analogical Reasoning Scheme based on Similarity Measure. A demonstration program is included in the package which includes a fuzzy controller demo which investigates backing up a truck, an inverted pendulum system, and the temperature and humidity control of a bathroom.
The FISMAT package can be used on Matlab or on the freely available Octave package which can run most Matlab m-files.
[ftp://ftp.mathworks.com/pub/contrib/v4/misc/]
FitExp: A Fortran subroutine to fit a given set of data with the best least-squares exponential-sum approximation having positive coefficients. Fitting sums of exponentials is a classical ill-conditioned problem, and this subroutine embodies the only known method which masters the ill-conditioning, finds the optimal number of terms, and is guaranteed to give the best least-squares fit. Read the ASCII documentation for this very carefully before you use it to avoid several seemingly inevitable pitfalls.
A source code distribution of FitExp is available. It is written in Fortran 77 and documented in an ASCII text file available separately in the same directory. A couple of test programs are also available. See Wiscombe and Evans (1977) and Evans et al. (1980).
[ftp://climate.gsfc.nasa.gov/pub/wiscombe/Expon_Fitting/]
FITPACK: A general purpose curve fitting package. This freely available version contains about 20% of the entire larger package and represents about 95% of the usages of the package with its 25 subprograms. The capabilities not included in this subset include automatic tension determination, 3-D curves, surface fitting in special geometries, B-splines in tension, and general surface fitting in 3-D space.
The programs in this FITPACK subset include:

curv1, which determines the parameters needed to compute an interpolatory spline under tension through a sequence of functional values;

curvs, which determines the parameters needed to compute a smoothing spline under tension;

curv2, which interpolates a curve at a given piont using a spline under tension;

curvd, which differentiates a curve at a given point using a spline under tension;

curvi, which integrates a curve specified by a spline under tension between two given limits;

curvp1, curvps, curvp2, and curvpi, which perform tasks similar to the previous programs except using periodic splines under tension;

kurv1, which determines the parameters needed to compute a spline under tension forming a curve in the plane and passing through a sequence of pairs;

kurv2, which performs the mapping of points in the interval [0,1] onto a curve in the plane;

kurvd, which is similar to kurv2 but also returns the first and second derivatives of the component functions;

kurvp1, which determines the parameters needed to compute a spline under tension forming a closed curve in the plane and passing through a sequence of pairs;

kurvp2, which performs the mapping of points in the interval [0,1] onto a closed curve in the plane;

kurvpd, similar to kurvp2 but also returns the first and second derivatives of the component functions;

surf1, which determines the parameters needed to compute an interpolatory surface passing through a rectangular grid of functional values;

surf2, which interpolates a surface at a given coordinate pair using a bi-spline under tension;

ceez, which determines the coefficients used to determine endpoint slopes;

curvpp, which determines the parameters needed to compute a periodic smoothing spline under tension;

curvss, which determines the parameters needed to compute a smoothing spline under tension;

intrvl, which determines the index of the interval in which a given value lies;

intrvp, which determines the index of the interval in which a given value lies after translating the value to within the correct period;

snhcsh, which returns approximations to various trig functions; and

terms, which computes the diagonal and superdiagonal terms of the tridiagonal linear system associated with spline under tension interpolation.

A source code distribution of FITPACK is available. All the programs are written in Fortran and are documented via comment statements contained within the source code files. Details about how to obtain the remainder of the package can be found at the site.
[http://www.netlib.org/fitpack/index.html]
FITS: The Flexible Image Transport System is the format adopted by the astronomical community for data interchange and archival storage. A FITS file consists of a series of Header Data Units (HDUs) which are themselves composed of statements describing the format and organization of the data in the HDU. Additional information about the instrument status or the history of the data may also be included. The data follow each HDU in the specified format. The data may be digital images, tables, or multidimensional matrices which aren't images. FITS is not principally a graphics format designed for the transfer of pictures and doesn't incorporate viewers, although there are a number of viewers which have been developed to view FITS data. A user's manual for the FITS format is available in several formats.
Software which can read, write or view FITS data files includes:

Fitsblink, for analyzing astronomical images;

FITSIO, a machine-independent subroutine interface for reading or writing FITS files;

FTOOLS, a collection of over 200 Fortran, C, Perl and Tcl programs that operate on FITS files;

Netpbm, an image file conversion and manipulation toolkit that can handle the FITS format;

SDB, a data browser that can handle the FITS format;

XFITSview, a viewer of FITS files; and xv, an image file viewer that can handle FITS images.

FITS files can also be handle by the major astronomical image analysis packages such as IRAF, AIPS, AIPS++, ESO-MIDAS, and SAORD. The Usenet group sci.astro.fits contains discussions and information about the FITS format.
[http://fits.gsfc.nasa.gov/]
Fitsblink: A program for analyzing astromical images in the FITS format. The features of Fitsblink include:

on-screen comparison of images;

loading images in uncompressed or compressed formats;

showing the celestial coordinates of the cursor if the file header contains the appropriate WCS keywords;

displaying images in greyscales or color;

creation or importation of star lists; and

output of analysis results into MPC format.

A source code distribution is available which requires both the FITSIO and XForms libraries for compilation and use. A Linux binary is also available.
[http://kastor.ijs.si/~jure/fitsblink/fitsblink.html]
FITSIO: A subroutine interface library for reading and writing data files in FITS format. FITSIO was written to provide a powerful yet simple interface for accessing FITS files which insulates the programmer from having to deal with the gory internal details of the format. It supports all of the common types of FITS files including Primary Arrays, Image extensions, and ASCII and Binary table extensions. Subroutines are provided to perform a wide range of operations on FITS files, e.g. opening and closing, reading, writing, modifying or deleting the values of header keywords, and reading and writing any element of the associated array or table. The package also contains extensive error checking to verify that files have a valid FITS format. FITSIO requires random access I/O capabilities to the file and as such does not directly support reading and writing to sequential I/O devices such as tape drives.
The FITSIO library is available as source code in separate versions for C and Fortran. There are also separate user's guides for each version as well as a cookbook detailing numerous examples of its use, all of which are available in PostScript format.
[http://heasarc.gsfc.nasa.gov/docs/software/fitsio/fitsio.html]
FIXREG/FIXMAHAL: Packages for performing fixed point cluster (FPC) analysis. FIXMAHAL finds spherical-shaped clusters by means of the Mahalanobis distance, and FIXREG finds linear regression clusters. FPC analysis is a tool for finding subsets or clusters of a data set which are:

homogeneous in the sense that they can be adequately described by a homogeneous parametrical distribution called a cluster reference distribution, and that they contain no outlier from this distribution;

separated from the rest of the data in the sense that all other data points are outliers with respect to the FPC.

FPCs can overlap and do not need to be exhaustive. They remain stable under the addition or deletion of outliers, although outliers need not be included in any FPC. A source code distribution is available which includes a user's manual. See also Hennig (1998).
[http://www.math.uni-hamburg.de/home/hennig/fixreg/fixreg.html]
FL: This has evolved into fltk.
FLAP: The Formal Languages and Automata Package is a tool for designing and simulating variations of finite automata, pushdown automata and Turing machines. A transition diagram of a nondeterministic automaton is first created, after which an input string is entered and a step-by-step simulation showing multiple stacks - one for each possible configuration - is guided. The features of FLAP included a fast simulation mode and retracing all or part of a simulation. A source code distribution of this C package is available. A version written using Java called JFLAP is also available.
[http://www.cs.duke.edu/~rodger//tools/flap.html]
[ftp://ftp.cs.duke.edu/pub/rodger/tools/]
flc: A filter language compiler that generates rules from a common language for various packages which perform packet filtering. It supports IP Filter, ipfwadm and ipfirewall. A source code distribution is available.
[http://coombs.anu.edu.au/~avalon/flc.html]
fltk: The Fast Light Tool Kit is a C++ GUI toolkit for X11, OpenGL and Win32 NT/95. It is a library of objects and routines that allow you to biuld a UI with multiple windows containing buttons, sliders, input fields, dials, etc. in a simple manner. It is written on top of Xlib but hides the interface to that cantankerous library. It was designed to be a very small GUI library so it can be statically linked with an application without bloating it too much.
The features of fltk include:

an interactive user interface builder application called Fluid that can produce fltk source code, i.e. human-readable C++ source code;

double buffered windows (using Xdbx if available);

support for overlay hardware or emulation if unavailable;

a fast and small portable 2-D drawing library hiding Xlib;

an OpenGL/Mesa drawing area widget;

capability of using OpenGL or Mesa to draw other widgets;

pop-up and pull-down menus;

compatibility header files for the Glut and XForms libraries;

the ability to label widgets with XBM, XPM or GIF files;

text input fields with Emacs key bindings; and

X11 cut and paste.

A source code distribution of fltk is available. It can be configured and installed on Linux Intel systems via the included scripts. A user's manual is included in HTML format.
[http://fltk.easysw.com]

pyFLTK/plFLTK

A set of Python and Perl wrappers for the FLTK GUI library. This uses SWIG to create the wrapper.
[http://fltk.netpedia.net/]
Flex: Flex is a lexical analyzer, a tool for generating scanners, i.e. programs which recognize lexical patterns in text. Flex reads input files containing descriptions of a scanner to generate in the form of pairs of regular expressions and C code called rules. From this it generates a C source code file which is compiled and linked with a library to produce an executable which analyzes input for occurrences of the regular expressions. It executes the corresponding C code whenever it finds an example of such.
A source code distribution of Flex is available. It is written in C and can be installed and used on many platforms using the autoconfigure script supplied in the distribution. A user's manual is included in Texinfo format.
[http://www.gnu.org/manual/flex-2.5.4/flex.html]
Flexbackup: A backup script written in Perl whose features include:

easy configurability;

choice of dump, afio, tar, cpio or zip;

modes for backup, listing, comparing, extracting and extracting a file list;

compression and buffering options for all backups;

full (0) and incremental (1-9) levels of incremental backup via dump;

filesystem oriented, i.e. won't traverse devices;

backups for remote filesystems via rsh/ssh;

works with IDE/SCSI tapes, Linux ftape, or archives to files rather than a device; and

informative log files.

[http://members.home.com/flexbackup/]
Flexible Bayesian Modeling: A package which supports Bayesian regression and classification models based on neural networks and Gaussian processes. It also contains software for programs which implement both finite and countably infinite mixture models. The regression and classification models are based on multilayer perceptron neural networks or on Gaussian processes. Bayesian inference is performed using Markov chain Monte Carlo methods.
A source code distribution of the FBM software is available. It is written in C and can be compiled on most generic UNIX platforms. Some documentation is available at the site, although the algorithms are most extensively documented in Neal (1996).
[http://www.cs.utoronto.ca/~radford/fbm.software.html]
FlexIO: An API for storing multidimensional scientific data that hides the differences between underlying file formats. It currently supports HDF, IEEEIO, and network socket connection formats. This enables the same subroutine calls to be used to store data regardless of the underlying file format via interfaces written using C, C++, Fortran 77/90, IDL or Java. A higher-level set of APIs sit on top of the programming APIs to permit simplified access to complex data structures. These include:

a Simple Unigrid Writer that stores a sequence of multidimensional arrays including physical grid dimensions;

an Unstructured Cell Data (UCD) writer that stores finite element cell-connectivity data in the format used by several popular FEM simulation packages; and

hierarchical Adaptive Mesh (AMR) readers/writers.

The FlexIO package also contains utilities for working with data including:

xmlview, prints FlexIO file metadata;

convert2native, converts an IEEEIO file to the native byte-ordering format so reading can be performed more efficiently;

ioconvert, a more general version of convert2native that allows IEEEIO or HDF source files to be converted to any allowable destination format (currently only IEEEIO or HDF); and

ioinfo, prints diagnostic information about IEEEIO and HDF datafiles.

[http://zeus.ncsa.uiuc.edu/~jshalf/FlexIO/]

IEEEIO

A library for storing multidimensional data in a binary format that can be transported between different computer systems. This uses the IEEE 754 standard representations for floating point numbers to achieve portability. The programming interface allows interoperability with HDF and NetCDF if those libraries are linked.
[http://zeus.ncsa.uiuc.edu/~jshalf/FlexIO/IEEEIO.html]
FLEXTRA: A kinematic trajectory model that can be used to calculate several types of trajectories, e.g. 3-D, isentropic, isobaric, isoeta and boundary layer. FLEXTRA is written in Fortran 77. A source code distribution is available, with compilation and use requiring GRIB decoding software.
[http://www.forst.uni-muenchen.de/LST/
METEOR/stohl/flextra.html]
FLIB: A Fortran library that provides a large number of routines to perform standard coding tasks that scientists and engineers don't usually deal with, e.g. non-numeric tasks such as string manipulation, input validation, etc. Some subroutines to perform numeric tasks are also included.
FLIB is organized into sets of separte code packages based on functionality. These packages are:

CharPak, a set of routines to manipulate character variables;

ErrPak, routines to perform error trapping and to display error and warning messages;

IoPak, miscellaneous routines to create, modify and view ASCII files;

GeomPak, routines to perform geometrical transformations such as coordinate system rotations;

RanPak, routines to generate random numbers;

TimPak, routines to compute to number of days between two dates; and the

Compiler Abstration Layer, a set of stubs or wrappers for non-portable or non-standard system calls or routines including routines to retrieve environment variables and execute system or shell commands.

The library is available as Fortran source code and is documented via a series of man pages.
[http://www.pnl.gov/berc/flib/]
flib2c: A program that simplifies using Fortran libraries from C. It generates header files that make calling a Fortran function as simple as calling a C function.
[http://www.pci.uni-heidelberg.de/tc/usr/joerg/prg/prg.html]
Flick: An IDL (Interface Definition Language) compiler which is the research and production IDL compiler within the Flux Project. Flick uses techniques from traditional language compilers to produce very fast client/server communication code, and it is significantly faster than traditional IDL compilers with Flick-generated stubs increasing end-to-end throughput typically by factors of 4 or more. It currently (5/97) supports the CORBA and ONC RPC (Sun RPC) IDLs. Interfaces written in any of these languages can be implemented by CORBA-, ONC RPC-, or MIG-style C language stubs communicating via CORBA IIOP, Sun/TCP, Mach 3 ports or the Fluke IPC. Flick can also be extended to support new IDLs, message data formats and transport mechanisms. It is not a complete CORBA ORB and is also not yet a drop-in replacement for rpcgen or MIG.
The source code for Flick is available under the terms of the GPL. It has been compiled and tested on FreeBSD, Linux Intel, Sun SunOS, HP-UX, IBM AIX, and BSD 4.3+ platforms. Flick is extensively documented in manuals included in the distribution.
[http://www.cs.utah.edu/projects/flux/flick/]
FLId: A library designed for the decoding of FLI movies from an application. It consists of three functions:

FLId_open, which initializes the decoder;

FLId_image, which is called each time you want a frame from the movie; and

FLId_close, which is called to close the FLI and free all memory allocations.

A source code version of FLId is available.
[http://www.tardis.ed.ac.uk/~ark/flidlib/]
floppy drives: Software packages for reading from, writing to, and otherwise dealing with floppy drives include:

fdd, an enhanced replacement for dd;

fdformat, a program in the util-linux collection for low-level formatting floppy disks;

fdutils, a large set of utility programs for configuring and working with floppy drivers;

mtools, a collection of tools for accessing MS-DOS disks from UNIX without mounting them; and

setfdprm, a program in the util-linux collection for setting floppy disk parameters.
Floppy/Flow: Fortran source-code processing tools. Floppy checks a given F77 source code file against various coding conventions and outputs a cleaned and tidied file. Flow takes a binary file created by Floppy and produces various reports about the structure of the code. Both tools are written in C and should install on any platform with an ANSI C compiler.
[http://www.netlib.org/floppy/]
[http://sunsite.unc.edu/pub/Linux/devel/lang/fortran/]
FLORID: The F-LOgic Reasoning In Databases package is an implementation of a programming system based on the concepts of F-logic, where F-logic is a logical language designed to account for most of the structural aspects of object-oriented data modeling in a clean, declarative fashion. The objective of FLORID was to provide a prototype environment where practical programming aspects of using such a language for database development could be investigated. This prototype system supports data driven schema definition, multiple and non-monotonic inheritance, and path expressions which can also be used for anonymous object creation. Program evaluation is based on a set-oriented bottom-up computation. The FLORID system can be accessed via a text shell, a Tcl/Tk GUI, or an Emacs interface.
A binary distribution of FLORID is available for Sun Solaris, SGI IRIX, and Linux Intel systems. The distributions include an executable, documentation, a tutorial, and several examples.
[http://www.informatik.uni-freiburg.de/~dbis/florid/]
flow: A particle animation program that allows the interactive construction of sophisticated particle systems, which can then be rendered via either OpenGL or BMRT. The features include:

real-time animation;

off-line rendering via RIB output and calling an external renderer;

scene construction with polygons, quadrics, planes and boxes;

a shader editor;

code generation wherein a particle animation can be rendered to code to create, e.g. a screensaver;

multiple orthographic views of lights, particle actions and geometry;

interactive camera recording via an intuitive mouse-driven camera control; and

multiprocessor rendering.

A source code distribution is available as is an online manual.
[http://www.reptilelabour.com/software/flow/]
flow1: A program that simulations the motion of drifters in a random velocity field. The source code is written in C.
[http://soil.princeton.edu/~rcarmona/researchinterests.html]
FLpr: A Perl script that unifies the usage of several other programs used for printing. It automates the usage of utilities such as dvips, up, psselect, a2ps, etc. in one main program, so only the command line options for one program need to be remembered. It can be used as a replacement for lpr and adds many more features. FLpr automatically detects the type of each file that needs to be printed. It recognizes DVI, PostScript, plain text, images (e.g. GIF, JPG, etc.), and compressed or gzipped versions of any of the above. It does this by converting any of the input files to PostScript format and then spooling this code to the printer. It also provides a unified framework for selecting page ranges, and a Flprlog utility provides a simple printer accounting mechanism.
The source code of FLpr, written in Perl, is available and comes with the documentation for the program in Texinfo format. FLpr requires, in addition to Perl, the a2ps, dvips, GhostScript, psutils, and ImageMagick packages.
[http://www.ci.tuwien.ac.at/~leisch/docs/flpr/flpr.html]
[http://sunsite.unc.edu/pub/Linux/system/printing/]
Flux: A glue library containing code for performing tasks and solving problems encountered repeatedly when programming in C. The goals for Flux include simplifying common tasks and homogenizing interfaces and platforms. This library attempts to span quite a large set of applications without providing extremely deep support for them, i.e. it provides selected, well-known and robust algorithms for each task without providing a wide range of options for any single task. The current (2/00) and planned functionality includes:

block memory programs for handling large amounts of same-size memory blocks;

balanced trees for indexing data to be searched;

token trees for data storage and manipulation;

markup trees for marked-up documents;

a high level event logging interface;

entropy functions for providing strong randomness;

public-key and symmetric ciphers;

FIFO buffers for byte-stream buffering;

sockets for connected byte streams;

programs for stream token trees; and

proxies, i.e. single-process event multiplexors.

[http://projects.simplemente.net/flux/]
FLUX: A Fortran program for comparing a variety of discretization schemes for the 1-D linear advection equation with unit wave speed or the inviscid Burger's equation. The discretization schemes included are forward-time centered-space (FTCS), upwind differencing, MacCormack, backward Euler with central differencing, backward Euler with upwind differencing, Beam and Warming 2nd-order accurate in time, and Lax-Wendroff. The starting profiles are a ramp function for both equations and a smooth bump for the linear advection equation. A user's manual is available in LaTeX format.
[ftp://unix.hensa.ac.uk/pub/misc/cfd/software/flux/]
FMLIB: A package of Fortran routines for real arithmetic and elementary functions. The precision and base for the arithmetic can be set by the user, and routines are available for floating-point arithmetic, conversion and I/O operations, and trigonometric, exponential, logarithmic and hyperbolic functions. There are also routines for integer multiple precision arithmetic and functions, including GCD and modular powers.
Related packages are:

ZMLIB, a package of Fortran routines for complex arithmetic and elementary functions whose options and functionality is similar to FMLIB; and

FMZM90, a Fortran 90 modules defining three derived types, i.e. multiple-precision integer, multiple-precision real, and multiple-precision complex.

[http://www.lmu.edu/acad/personal/faculty/dmsmith2/FMLIB.html]
fMSX: A portable emulator of MSX/MSX2/MSX2+ home computers written in C. MSX is an old Z80-based family of home computers that appeared in 1982 and vanished in 1988. They were an attempt to establish a single standard in home computing analogous to VHS in video, with later extensions to the standard called MSX2, MSX2+ and TurboR. They were popular in Asia, South America, Europe and the former Soviet Union, but mostly unknown in the USA. The standard was designed by a Japanese company called ASCII in cooperation with Microsoft, the latter of which provided a firmware version of BASIC for the machine. The MSX was a good educational platform, with the Russian ministry of education having bought hundreds which were grouped into classroom systems of 10-16 machines connected via a simple network.
The MSX hardware was a hybrd of a video game console and a generic CP/M-80 machine, with a Z80 CPU working at 3.58 MHz the workhorse in the base model (with the clock frequency doubled for the TurboR model). The video subsystem was constructed around the TI9918 or TI9928 VDP chips used in the TI-99/4 computers, ColecoVision and Coleco Adam. Later models used the next generation V9938 and V9958 chips. The audio system was driven by a General Instruments AY-3-8910 chip, the same one used in the Sinclair ZX Spectrum 128.
The fMSX emulator has been ported to UNIX, Windows, MS/DOS, Mac, Amiga, Playstation, OS/2, and other platforms.
[http://www.komkon.org/fms/fMSX/]
fmtools: A set of tools for working with Video4Linux-supported radio cards including:

fm, a tuner that handles basic on/off, tuning and volume changes; and

fmscan, which scans from 87.9 to 107.9 MHz in 0.2 MHz increments looking for stations with an average signal strength of 50% or better.

[http://www.exploits.org/v4l/fmtools.html]

Next: Fn-Fz Up: Linux Software Encyclopedia Previous: En-Ez Contents

Manbreaker Crag 2001-03-08