Next: An-Az Up: Linux Software Encyclopedia Previous: Categories Contents

Aa-Am

Last checked or modified: June 8, 1999

AAFID: Autonomous Agents For Intrusion Detection is a distributed monitoring and intrusion detection system that employs standalone programs called agents to perform monitoring functions in the hosts of a network. AAFID uses a hierarchical structure to collect the information produced by each agent by each host and by each set of hosts to detect suspicious activity. It is not in itself a network-based intrusion detection system but provides the infrastructure for distributing monitoring tasks over many hosts.
The AAFID distribution contains:

base classes for Monitors, Transceivers and Agents;

a number of working Agents that perform different functions and allow the system to be run out of the box;

a code generation tool that makes it easy to develop new agents;

a graphical user interface; and

documentation for the architecture and the implementation.

The system is written entirely in Perl 5.
[http://www.cs.purdue.edu/coast/projects/autonomous-agents.html]
Abacus: A spreadsheet which, while currently (9/98) in alpha test stage, includes such useful functionality as:

multiple spreadsheet capabilities;

a small set of built-in functions including statistical, financial, and math/trig functions with an interface for creating and pasting formulas;

cell editing with the usual functions;

cell formatting with a wide range of formats;

column and row insertion, deletion and resizing;

sorting via a wide variety of methods;

an autosum function for summing data;

graphs that can be deleted, moved and resized;

exportation of data and graphs to PostScript format; and

import/export of CSV, tab, Wk1 and TinySheet formats.

A source code distribution of Abacus is available. It is written in C/C++ and Tcl/Tk 8.0.
[http://www-cad.eecs.berkeley.edu/HomePages/aml/abacus/abacus.html]
ABaCUS: A program developed to investigate the significance of the putative correspondence between exons and units of protein structure. This analysis takes the form of an attempt to eliminate the reference or null hypothesis that there is no correspondence. The null hypothesis consists of a reference model for random gene structures and a scoring rule for quantifying correspondences. ABaCUS creates and reads files containing observed data and uses it to generate reference genes according to one of several models, after which the test is performed and the null hypothesis accepted or rejected. This is written in C and should be portable to most platforms.

[ftp://ftp.bio.indiana.edu/molbio/evolve/abacus/]
ABC: An interactive programming language and environment for personal computing which was originally intended as a replacement for Basic. It was designed after the performance of a task analysis of the general programming task. It was originally intended as a language for beginners but has become a programming tool for beginners and experts alike.
The features of ABC include:

a powerful collection of only 5 data types which can be easily combined;

strong typing without declarations;

no limitations (e.g. on maximumum integer size) other than the physical limits of memory;

refinements to support top-down programming;

nesting via indentation;

programs usually a fourth or fifth of the size of a corresponding Pascal program;

an environment in which procedures and functions and global variables remain after logging out, i.e. no need for files; and

a generalized undo mechanism.

Implementations of ABC are available for UNIX, Mac, MS-DOS, and Atari ST platforms. The UNIX implementation is written in C and can be compiled and installed on most generic platforms. The language is fully documented in a book and a technical article. Assorted additional documentation such as technical reports in PostScript format can be obtained at the site. See Guerts et al. (1990) and Pemberton (1987).
[http://www.cwi.nl/~steven/abc/]
abcde: A Better CD Encoder is a front-end program that grabs an entire CD, converts each track to MP3, and then ID3-tags each file. This is a front-end to cdparanoia, wget, cd-discid, id3 and to a choice of MP3 encoders (although it defaults to lame).
[http://lly.org/~rcw/abcde/page/]
ABCL: An object-oriented concurrent reflective language based on Hybrid Group Architecture. ABCL can dynamically control its own behavior such as scheduling policy from within a user program. There are three versions of ABCL which, ranging from oldest to newest, are: ABCL/1, ABCL/R, and ABCL/R2. The description given applies to the most recent version.
A source code implementation of ABCL/R2 is available. It runs on top of KCL, AKCL, CMUCL, CLISP, and Allegro CL. See Yonezawa (1990).
[ftp://camille.is.s.u-tokyo.ac.jp/pub/]
[http://web.yl.is.s.u-tokyo.ac.jp/pl/abcl.html]
abc2mtex: A package designed to notate tunes stored in an ASCII format called abc notation. It was designed primarily for annotating folk and traditional tunes of Western European origin which can be written on one stave in standard classical notation. It can also be used for multiple staves and is extensible to other types of music. It can also be used as a preprocessor for MusicTeX or MusiXTeX.
A source code distribution of abc2mtex is available. It is written in C and its installation and use require TeX and MusicTeX. The package is documented in a user's guide available in PostScript format.
[http://www.gre.ac.uk/~c.walshaw/abc/]
ABDPACK: A package of Fortran 77 programs for the solution of systems of linear equations having the almost block diagonal structure arising in spline collocation at Gaussian points with monomial spline basis functions, when applied to two-point boundary value problems with separated boundary conditions. Such systems results, for instance, when condensation is applied to the full spline collocation linear system. ABDPACK may also be used to solve the almost block bidiagonal systems that result from multiple shooting techniques and implicit Runge-Kutta methods for solving two-point boundary value problems. The algorithms used are based on an alternate column and row pivoting scheme which avoids most of the fill-in introduced by more commonly used techniques. This is TOMS algorithm 704 and is documented in Majaess et al. (1992b) and Majaess et al. (1992a).
[http://www.acm.org/calgo/contents/]
[http://www.acm.org/toms/V18.html]
[http://www.netlib.org/toms/index.html]
AbiWord: An Open Source, full-featured wordprocessor which is currently (10/98) still in the developer stage, i.e. you can download the source but it may or may not be useful unless you're a developer.
[http://www.abisource.com/]
abs: A spreadsheet that runs under X11. The features of abs include:

a clear and easy to understand GUI;

a macro language with the same syntax as Microshaft Visual Basic;

x-y plots and pie and bar charts;

exportation of files in Xfig format;

editing up to 20 documents simultaneously with copying, cutting and pasting between documents; and

the file format used to save abs worksheets is directly importable to Excel with the Excel macro editor.

Source code and binary distributions are available, with the latter including a Linux Intel version.
[http://www.ping.be/bertin/abs.shtml]
ACADIA: A Fortran 77 finite element formulation of the nonconservative form of the vertically integrated advection-diffusion-reaction (ADR) equation that tracks a given number of transport variables in a given number of fluid layers. The Galerkin weighted residual method is ued to discretize the solution by representing it on linear triangular elements, with the integrations performed with nodal quadrature. A source code distribution is available. The code is documented in a user's manual available in PostScript format.
[http://www-nml.dartmouth.edu/Software/]
ACAP: The Application Configuration Access Protocol is an Internet protocol for remotely accessing client program options, configurations, and preference information. It is intended as a solution for client mobility, i.e. to free users from having to recreate configuration set-ups, subscription lists, address books, bookmark files, folder storage locations, and the like when they change physical locations. ACAP evolved from the process of IMSP going through the IETF standards process. It provides a protocol for arbitrary clients to store and retrieve client-specific configuration from a server, and is supposed to fill a niche between a full directory service, a file system, and specialized single-service protocol support. The protocol is implemented in the ACAPd server daemon.

[http://andrew2.andrew.cmu.edu/cyrus/acap/]
[http://www.faqs.org/rfcs/rfc2244.html]

ACAPd

A server daemon that implements the ACAP Internet protocol for the remote access of configuration and preference information. A source code distribution is available.
[http://andrew2.andrew.cmu.edu/cyrus/]
acct: The GNU set of accounting utilities which provide a sysadmin with useful information about system usage, i.e. connections, programs executed, and system resource utilization. The programs in the package include:

ac, which prints statistics about the connect time of users;

accton, which turns accounting on or off;

last, which lists the logins on the system with the most recent first;

lastcomm, which lists the commands executed on the system with the most recent first;

sa, which summarizes the accounting information and generates reports about commands, giving the number of invocations, CPU time used, average core usage, etc.; and

dump-acct and dump-utmp, which display the main accounting files in human-readable format.

A source code distribution of acct is available. It is written in C and can be compiled and installed on most UNIX flavors via the supplied configure script. It is documented in a user's manual available in Texinfo format.
[http://www.gnu.ai.mit.edu/order/ftp.html]
ACDC: Automatic Continuation with Deferred Corrections is an automatic continuation code for solving stiff boundary value problems (BVPs). ACDC is a modified version of the TWPBVP package which has been adapted to allow an automatic continuation strategy to be used. It also replaces the mono-implicit Runge Kutta formula used in TWPBVP with an implicit Runge Kutta formula based on Lobatto points. See Cash et al. (1995). The program is written in Fortran and is documented in a user's manual available separately in LaTeX format.

[http://www.ma.ic.ac.uk/~jcash/BVP_software/]
aCe: A data-parallel computing environment designed to improve the adaptibility of algorithms to diverse architectures. The primary purpose is to encourage programmers to implement applications on parallel architectures by providing them with the assurance that future architectures will be able to run their applications with a minimum of modification. It is designed on the concept of structured parallel execution where the programmer first designs a virtual architecture that reflects the spatial organization of an algorithm which may consist of many groups, clusters, or virtual processing elements (PE). Then code is written reflecting the temporal organization of the algorithm which defines the threads of execution perfomred on each PE. The architecture and threads of execution together define the algorithm's execution.

The aCe language is both data- and task-parallel; the former because the processing elements of a cluster execute common threads of execution and the latter because processing elements of different clusters execute different threads of execution. It is also architecture adaptive since different virtual architectures may be used for different physical architectures to improve architecture dependent performance.
It currently (3/97) supports only a superset of C based on ANSI C. The supported machines are Linux, SGI Indigo, MasPar MP-1 and MP-2, and Cray T3D. The documentation is available online and is also included in the distribution. This is part of the NASA HPCC ESS Project.

[http://newton.gsfc.nasa.gov/aCe]
ACE: The Adaptive Communication Environment is an object-oriented toolkit which implements fundamental design patterns for concurrent communication software. It provides a rich set of reusable C++ wrappers, class categories, and frameworks that perform common communication software tasks across a range of operating system platforms. The tasks provided by ACE include event demultiplexing and event handler dispatching, signal handling, service initialization, interprocess communication, shared memory management, message routing, dynamic (re)configuration of distributed services, and concurrent execution and synchronization. ACE is targeted for developers of high performance and real time communication services and application.

ACE consists of layers of hierarchical components. The lower level portions are C++ wrappers for OS interfaces which encapsulate various interfaces, e.g. IPC mechanisms, event multiplexing, concurrent execution and synchronization, explicit dynamic linking, memory-mapped files and shared memory management, and System V IPC. This level shields the upper levels of ACE from platform dependencies. A higher-level network programming framework integrates and enhances the lower-level wrappers. This framework contains several class categories including:

Reactor and Proactor, which support both reactive and proactive event demultiplexing patterns;

Service Configurator, which supports dynamic (re)configuration of application service objects;

ADAPTIVE Service Executive, which supports modular integration of hierarchically-related communication services via a user-level implementation of System V STREAMS;

Concurrent Execution and Synchronization, which supports various types of higher-level concurrent execution and synchronization patterns;

Shared Malloc, components for managing dynamic allocation of shared and local memory; and

CORBA integration, which integrates ACE with CORBA implementations.

The highest level of ACE provides a standard library of distributed services packaged as self-contained components. These components provide reusable components for common distributed system tasks such as naming, event routing, logging, time synchronization, and network locking. They also illustrate how to use the lower level services.
The ACE distribution is freely available and contains the source code, tests, example applications, and documentation for C++ wrapper libraries and higher-level network programming components and frameworks. It has been ported to most versions of UNIX (including Linux), Windows NT and 95, VxWorks, and MVS OpenEdition. There is an ACE on Linux page with information on how to install it on Linux. The documentation consists of several technical reports, tutorials, and man pages.
[http://www.cs.wustl.edu/~schmidt/ACE.html]
ACEgr: A general 2-D plotting package for UNIX workstations with a Motif GUI interface. This package, also known as xmgr and xvgr, was created and is maintained by Paul Turner. There is a mailing list to which users can submit questions or suggestions.

The features of ACE/gr include:

a point and click Motif interface,

plotting up to 10 graphics with 30 data sets per graph,

reading reading from files or pipes,

reading 1-D variables from NetCDF files,

several axis combinations (e.g. XY, log-linear, log-log, linear-log, bar, and stacked bar charts),

error bars and a block data feature,

continuous display of the location of the pointer,

user-defined or automatic scaling;

tick marks, labels, symbols, colors, etc.,

graph legends and annotative text,

operations on data sets and region operations,

mouse-powered point editing,

several math operations,

pan, zoom, shrink and expand,

a command line interpreter, and

output support for PostScript, HPGL, and Framemaker.

This used to exist and be supported in two versions, a Motif (xmgr) and an XView (xvgr) version. The author stopped supporting and improving the latter at version 2.10, while the former is now at version 3.01. The source code is available as well as binaries for Linux and Sun platforms. There is no user's manual although it's fairly easy to learn how to use this package. Development has been frozen on this as it has been superseded by Grace.
[http://plasma-gate.weizmann.ac.il/Xmgr/]
[ftp://ftp.cc.gatech.edu/pub/linux/X11/xapps/math/]
ACEDB: A database system in which data are stored in objects that belong in classes. It is a general DB system using caches, session control, and a powerful query language that was originally developed to organize molecular biology data about the genomes of diverse species. As such it was designed to reflect the needs of molecular biologists in such matters, although it should be more generally applicable. It is written in C and uses the X Window System to provide a platform independent GUI. The source code is available as well as binaries for several platforms, including a ACEDB Linux binary.

[http://probe.nalusda.gov:8000/aboutacedbsoft.html]

AcePerl

An object-oriented Perl interface to the ACEDB database system. It provides functionality for connecting to remote ACEDB databases, performing queries, fetching ACE objects, and updating databases.
[http://stein.cshl.org/AcePerl/]

JADE

A Java-based interface to the ACEDB database system. JADE is database independent, portable, multithreaded and multiplatform.
[http://stein.cshl.org/jade/]
ACF: The Analyzer Component Framework is a C++ tookit for writing system analyzers (mainly model checkers) that consists of a number of interfaces, generators, algorithms and containers. Model checking is an automated verification technique that has been successfully applied to the verification of large, industrial-size problems. ACF was built on the assumption that the structure of most model-checking algorithms is independent of the formalism used to describe the system, i.e. interfaces can be constructed to provide generic algorithms that can be instantiated for any suitable formalism.
[http://aiken.cs.abo.fi/acf/]
AcidBlood: An IRC robot for helping to administer chaotic IRC sessions. The features of AcidBlood include:

a user database with authentication;

user-requestable operator status;

runs in more than one channel at once;

WAR and DCC features;

remote administration capabilities;

customizable by users;

undetectable, i.e. only interacts with those in the database; and

dynamic channel changing.

A source code distribution of this C++ package is available.
[http://www.darkice.com/site/acidblood/]
ACL: Access Control Lists are a mechanism to extend traditional UNIX file protection and provide access granularity down to a single user. An ACL can be associated with any file or directory on systems whose filesystem supports property lists. ACL extends traditional protection schemes by:

providing separate access control specifications for each user and group;

limiting the permissions that can be granted to individually specified users and groups; and

allowing all user and group permissions to be automatically specified upon object creation, e.g. defining a default ACL for a directory that is inherited by files and subdirectories when they are created.

POSIX ACLs for Linux

A project to implement POSIX-like ACLs for Linux. The project goals include to:

implement system calls for ACL manipulation;

implement ACL for sf ext2fs;

implement the ACL manipulation utilities getfacl and setfacl; and

patch the standard file utilities to recognize ACLs and act accordingly.

This project is currently (10/99) in the beta stage and is available in the form of a kernel patch.
[http://major.rithus.co.at/acl/]
ACL2: A Computational Logic for Applicative Common Lisp is an automated reasoning system that is both a programming language in which you can model computer systems and a tool for proving properties of those models. It can be used as a programming language, a specification language, a modeling language, a formal mathematical logic, or a semi-automatic theorem prover.
ACL2 is a logic in that it is a formal system with rigorously defined syntax and semantics, i.e. a first-order logic of total recursive functions providing mathematical induction on the ordinals up to epsilon-0 and extension principles for recursive definition and constrained introduction of new function symbols, i.e. encapsulation. It is a specification language in that it supports the modeling of systems of various kinds wherein functions can equally be used to express purely formal relationships among mathematical entities, to describe algorithms, or to capture the intended behavior of digital systems. ACL2 is computational logic in that the theory of recursive functions is often considered the mathematics of computation, in that many ACL2 specifications are executable, and in that calculation is heavily integrated into the reasoning process. It is also a powerful, automated theorem prover or proof checker in that it can be used to discover proofs of theorems state in ACL2 logic or to check previously discovered proofs.
Source code and binary distributions of ACL2 are available, with one of the latter being for Linux Intel systems. It is documented in a series of technical reports and a truly mammoth 800+ page user's manual.
[http://www.cs.utexas.edu/users/moore/acl2/acl2-doc.html]
ACMAINT: An ACcount creation and MAINTenance system for distributed UNIX systems. ACMAINT allows an adminstrator to perform account-related administrative chores for any machine on the network from any attached system. The adminstrator can create new user accounts, add or delete accounts for existing users, change the global or per-account information associated with a user, place a message on a user's account, and enable or disable a user's account. Group information and mail aliases are handled similarly. It uses a central database on a single machine which contains a copy of all needed data. Changes to the database are made via a network server running on the database machine which in turn makes changes around the network via another network server running on each machine.
The tools in the ACMAINT system include:

ah, the account handler, i.e. the primary administrator interface through which user accounts, groups and aliases are handled;

chinfo, an interactive shell for modifying mailbox host, office and home information as well as the login shell associated with a given username;

dbd, a database daemon that runs on a single host and waits for connections from clients;

finger, displays information about logged-in users;

mkdbmpwd, builds password DBM files;

mknightly, builds the alias and/or group files for all of the hostgroups and hostclasses;

packetd, a packet daemon running on the same host as dbd that sends packets written by that program to the transd programs;

passwd, changes login passwords; and

transd, a transaction daemon running on each host responsible for the modification of files and for creating and removing appropriate files and directories.

A source code distribution of ACMAINT is available. It is written in C and Tcl/Tk and is documented in a set of man pages as well as in a set of technical reports.
[ftp://coast.cs.purdue.edu/pub/tools/unix/ACMAINT/]
ACME (ADL): A simple, generic ADL that can be used as a common interchange format for architecture design tools or as a foundation for developing new architectural design and analysis tools. A language and design tool infrastructure provides a stable, baselined language and OO-based API library for representing software architecture descriptions. Versions are available for C++ and Java upon completion of an online license form.
[http://www.cs.cmu.edu/~acme/]
ACME Labs Software: A large collection of free programs/packages written by Jeff Poskanzer of Netpbm fame. Although none of these are as neat as the stuff Wile E. Coyote gets, there's some pretty nice stuff here. The offerings include:

acme_chat, an interface to ACME News chat;

bigcal, a 78-column version of the cal command;

brev, a binary file reversal program;

date_offset, displays date and time with an offset;

date_parse, a date parsing routine with applications;

factor, a prime number factoring program;

find_old_files, finds files older than a specified time;

globe, shows an ASCII graphic of the currently lighted face of the Earth;

hgrep, highlights results of a grep;

http_get, gets the contents of a URL via HTTP;

http_load, a multiprocessing HTTP test client;

image_size, figures out the size of image files;

lam, laminates two or more files;

libpnmrw, a PBM/PGM/PPM read/write library;

libsmpw, a self-maintaining getpwuid/getpwnam replacement;

mapext, maps files from one extension to another;

micro_inetd, a simple network service spawner;

mod_sample, a simple example Apache module;

mudecode, a turbocharged MIME/UU decoder;

overlay, overlays two or more files;

phoon, shows an ASCII graphic of the current phase of the moon;

random, print a random number;

randomize, shuffle lines in a file;

raster-pixrect, a simple raster graphics package;

rcsscripts, shell scripts for using RCS;

revl, reverses lines in a file;

saywha, a front-end for write that records messages;

texttohtml, converts text to HTML;

thttpd, a simple, small, portable, fast and secure HTTP server;

thumbnail_index, creates an HTML index file for a collection of images;

users, lists users with line breaks and highlighting;

weblog_parse, extracts specified fields from a web log file;

xantfarm, an ant farm for X11;

xbouncebits, a bitmap animator for X11; and

xphoon, the phase of the moon for X11.

All are written in C and are documented in man pages.
[http://www.acme.com/software/]
ACME-Lib: An object-oriented framework for writing architectural tools in C++ or Java that read, write and manipulate software architecture designs specified in the ACME Architectural Description Language (ADL). ACME-Lib is designed to support the rapid development of tools that translate between native ADLs and native ACME-based architectural design and analysis tools. Source code distributions of both the C++ and Java versions are available, with the former requiring GCC 2.7.2 or later and the latter JDK 1.0.2 or greater.

[http://www.cs.cmu.edu/afs/cs/project/able/www/acme-web/v3.0/alpha-dist/alpha-dist.html]
acoustics: Acoustics software includes:

Acoustics Toolbox, a collection of several ocean acoustics models;

COUPLE, a coupled mode acoustic propagation program;

HARPA, HARPO and HARPX, 3-D Hamiltonian ray tracing programs;

OASES, an ocean acoustics propagation package;

Ocean Acoustics Library;

RAM, a package for range-dependent ocean acoustics problems;

SUPERSNAP, a normal mode acoustic propagation model;

TRIMAIN, an ocean acoustics ray theory package;

UMPE, for solving the ocean acoustic wave equation using the parabolic approximation.
Acoustics Toolbox: A package which contains models pertaining to ocean acoustic modeling. All are written in Fortran 77 with a common input structure which makes it easy to switch between programs. All of the models also produce shade files which can be processed using a common set of plotting routines to plot transmission loss versus range or versus range and depth. The models contained in the package include:

BELLHOP, a program which computes acoustic fields in oceanic environments via beam tracing, with the environment being an acoustic medium with a sound speed which can depend on range and depth (Porter and Bucker (1987));

KRAKEN, a normal mode code for range-varying environments in either Cartesian (line sources) or cylindrical (point sources) coordinates (Porter and Reiss (1984), Porter and Reiss (1985));

SCOOTER, a finite element code for computing acoustic fields in range-independent environments based on direct computation of the spectral integral with pressure and material properties approximated by piecewise-linear elements; and

SPARC, the SACLANTCEN Pulse Acoustic Research Code, an experimental time-marched FFP which treats problems with broadband or transient sources, i.e. pulses (Porter (1990)).

The plotting routines include:

PLOTFIELD, which produces either rectangular or polar plots of shade files for, respectively, range-depth plots of transmission loss and range-range plots of transmission loss;

PLOTGRN, which uses the modes to produce plots of the amplitude of the Green's function corresponding to a particular source/receiver combination;

PLOTMODE, which produces plots of specified modes using a solid line for the real part and a dashed line for the imaginary part;

PLOTRAY, which produces plots of the rays generated by BELLHOP;

PLOTRTH, which produces plots of the plane wave reflection coefficient as a function of the angle;

PLOTSLICE, which produces plots of coherent transmission loss versus range by extracting a particular slice from a shade file;

PLOTSSP, which produces plots of the sound speed profile;

PLOTTLD, which produces plots of coherent transmission loss versus depth;

PLOTTLR, which sums the modes to produce plots of coherent transmission loss versus range;

PLOTTRI, which produces a plot showing the layout of triangular patches the user has specified; and

PLOTTS, which plots the time series used in or created by a SPARC simulation.

A source code distribution of the Acoustics Toolbox is available. It is written in Fortran 77 and the documentation includes a user's manual for KRAKEN in PostScript format as well as ASCII help files for each of the other programs.
[ftp://oalib.njit.edu/pub/AcousticsToolbox]
ACPLT/KS: A project to develop an open and free communications system for process control and process control engineering. This is a communications protocol and system that provides a convenient and manufacturer-independent link between tools (e.g. process simulators and expert systems) and distributed control systems. This has applications in several areas including model-based process control, online optmization, validation of measured data, advisory tools based on predictive simulations, and statistical process control. ACPLT/KS is designed to work on heterogeneous systems using different computer platforms, with the communication system based on current standards like TCP/IP and ONC/RPC. It offers a degree of abstraction well-suited to process control engineering.
ACPLT/KS is based on the client/server principle, with servers providing information like plant or simulated data to clients through services. An example of a service is reading from or writing to archives. In the client/server model the servers don't have to store state information between requests, which allows the easier implementation of more robust servers. Interaction between clients and servers is carried out using a synchronous message exchange which blocks the client until the server answers. The servers present data which originates from a distributed control system in a tree-like structure comprised of communication objects. The objects can be domains which contain any arbitrary number of child objects, variables which represent plant or process data or additional information like the state of the data, or histories which provide access to state or data archives.
There are a couple of software components of this system currently (11/97) available. KSLIB is is a C++ communications library which allows the easy integration of remote access to process data. It consists of three levels:

libplt, which is a basic level implementing generic objects;

libks, which contains generic objects used in KS servers, clients, and managers; and

libkssvr and libkscln, server- and client-specific libraries.

The KS Shell is an RPC to Tcl interface which allows the rapid and easy building of KS clients, servers, and managers using the Tcl scripting language. Both components can be used on Linux Intel systems. Documentation is available in the form of user's manuals and some technical reports.
[http://www.plt.rwth-aachen.de/ks/english/ks.html]

ACPLTea

An ACPLT/KS client library written in Java. This consists of two packages:

org.acplt.ks, i.e. Java classes for implementing the ACPLT/KS protocol and client-side objects; and

org.acplt.oncrpc, an implementation of Sun's ONC/RPC protocol used by ACPLT/KS as a transport mechanism.

[http://www.plt.rwth-aachen.de/ks/english/acpltea.html]
Acrobat Reader: A package that can be used as either as a stand-alone PDF viewer or a plug-in for Netscape such that PDF files can be viewed from within the browser. It also includes page-on-demand downloading and progressive rendering of page contents of optimized PDF files. I'm using this successfully on both Pentium Pro 200 and Pentium 60 Linux boxes, and my only gripe is that its translations from PDF to PostScript don't seem to print out very well on the printers to which I have access. The xpdf package can also be used to view PDF documents.

[http://www.adobe.com/acrobat/]
ACS (telephony): The Adjunct Communication Server is a project to develop a core class extensible C++ state engine and IVR components for a complete and commercial quality multi-line communications server, allow it to be deployed in a setting as the primary resource for FAX, voice mail and unified messaging. This will provide extensible IVR and messaging functionality as well as interaction with other services such as:

Apache for Web content;

sendmail and POP for email content delivery;

OpenLDAP for directory services; and

host-based TTS.

The initial (5/99) release supports only the Pika line of telephony cards, although support for the NMS line is planned. This is being superseded (5/00) by Bayonne.
[http://www.voxilla.org/projects/projacs.html]
ACS (simulator): A general purpose electrical circuit simulator that performs nonlinear CD and transient analyses, Fourier analysis, and AC analysis linearized at an operating point. ACS is fully interactive and command-driven, and can also be run in batch mode or as a server.
[http://cgi.debian.org/www-master/debian.org/Packages/stable/electronics/acs.html]
[ftp://ftp.ee.rochester.edu/pub/acs/]
[http://www.geda.seul.org/tools/acs/]
AC3D: A 3D object modeller. It can be used to create objects, e.g. ellipses, cuboids, cones, spheres, polygons, lines, etc., and move, resize, rotate and pull the vertices around. There is also an extrude function. It loads and saves its own format files and can output files in Dive, Massive and VRML format. There are currently versions of AC3D available for Linux, SGI, SunOS and Solaris platforms. The documentation is contained in a text file in the distribution.
[http://www.comp.lancs.ac.uk/computing/users/andy/ac3dlinux.html]
ACTS Toolkit: A set of software tools for helping programmers write high performance scientific codes for parallel computers. It differs from other parallel tools projects in that it focuses primarily on software used inside an application rather than software used to develop an application. ACTS tools are mostly libraries (written in C, C++ and Fortran) and are primarily designed to run on distributed memory parallel computers using MPI for interprocessor communication. The tools are divided into four general categories: numerics, frameworks, execution support and developer support. All the tools are freely available to non-commercial users, although some require the signing of a non-redistribution agreement.
The tools providing algorithms are:

Aztec, a portable parallel library for solving large, sparse linear systems on distributed memory computers using a variety of Krylov iterative methods and various preconditioners;

Hypre, a library of linear system preconditioners designed for both standalone use and interoperability with other tools;

Opt++, an object-oriented nonlinear optimization package;

PETSc, a package for scalably solving PDEs using implicit methods on finite elements, differences or volumes;

PVODE, a set of solvers for the solution of large systems of ODEs, differential-algebraic systems, and nonlinear systems on parallel machines;

ScaLAPACK, a package that extends LAPACK's linear algebra capabilities to parallel machines; and

SuperLU, a library for the direct solution of large, sparse, nonsymmetric systems of linear equations and serial and parallel machines.

The tools facilitating algorithm development are:

Global Arrays, a portable, distributed array library providing a shared memory style of programming without hiding the nonuniform access characteristics of the arrays;

Overture, a library of grid functions providing vertex- or cell-centered grids as well as support for complex geometry and visualization; and

POOMA, a collection of C++ classes supporting a data-parallel style of programing (similar to HPF) for finite difference and particle methods.

Tools for runtime and other support include:

CUMULVS, provides a mechanism enabling programmers to incorporate computational steering, interactive visualization, and fault tolerance into existing parallel programs;

Globus, provides a method for creating large-scale computational grids and a toolkit of core services used by applications to access the grid;

PAWS, provides application support and inter-application data transfer capabilities in heterogeneous distributed environments;

SILOON, for helping write the scripts that can be used in runtime systems such as PAWS;

TAU, a set of tools for analyzing the performance of distributed and multithreaded programs; and

Tulip, a library providing C++ applications with threads, global pointers, synchronization primitives and other parallel operations.

Packages for software development include:

ATLAS and PHiPAC, tools for the automatic generation of optimized numerical software for modern computer architectures;

Nexus, a portable library providing the multithreading, communication and resource management capabilities needed to implement advanced languages, libraries and applications in heterogenous environments;

PADRE, provides generic support for distributing and communicating objects for frameworks and applications by abstracting the details of representing and managing distributed data; and

PETE, implements a technique for optimizing some kinds of C++ statements via compile-time transformations.

[http://acts.nersc.gov/]
ACUA: The Access Control and User Administration package is designed to facilitate the administration of user accounts and the enforcement of access restrictions on Linux/*BSD systems. ACUA contains functions for account management, access control, information reporting, and various utility tasks. The account management functionality includes automatic deletion of accounts, subscriptions (i.e. temporarily increased access), user-created accounts with call-back verification, and banning specific users from a system temporarily or indefinitely. The access control functions include:

accounting period time limits,

session time limits,

time of day specific time limits,

time limits when the system is busy,

setting of user priorities,

booting and warning idle users, and

enforcing data transfer limits.

Information reporting functions include account status information, detailed account information, and report generation. Miscellaneous functions are available for kicking a user off the system, removing files, and killing processes.

A source code distribution of ACUA is available. This can be compiled on Linux and BSD systems. Documentation is contained within the distribution.
[http://sunsite.unc.edu/pub/Linux/system/serial/]
[http://acua.gist.net.au/]
Ada: A language, probably more about which later.
[http://www.cl.cam.ac.uk/~mgk25/ada.html]
[http://www.cera2.com/softd/ada.htm]
ADAMEm: A portable emulator for the Coleco ADAM and ColecoVision systems. The program will emulate 4 disk drives, 4 tape drives, 1 ADAM printer, 1 parallel port, 1 RAM expander (with configurable memory), 2 ColecoVision game controllers, and optionally a roller controller, driving module or a super action controller.
[http://www.komkon.org/~dekogel/adamem.html]
ADAPT: An adaptive multidimensional integration subroutine to integrate a user-specified function on a hyper-rectangle of dimension 2 through 20. The user inputs the number of variables, arrays of upper and lower limits, the minimum and maximum number of function evaluations to be allowed, an externally declared function, and a relative accuracy. The routine outputs the estimated value of the integral, the number of function evaluation used, and an estimated relative accuracy, or a flag indicating why it failed. The source code for this subroutine, written in Fortran 77, is available. All documentation is contained within the routine in comment statements. This is part of CMLIB.

[http://sunsite.doc.ic.ac.uk/public/computing/general/statlib/cmlib/]
Adaptive Simulated Annealing (ASA): ASA is a software package originally developed to deal with the necessity of performing adaptive global optimization on multivariate nonlinear stochastic systems. It uses a version of the simulated annealing algorithm to find maxima or minima in complicated multidimensional landscapes. ASA is well-documented in a user's manual and several journal reprints.

[http://alumni.caltech.edu/%7Eingber/]
ADAPTOR: The Automatic DAta Parallelism TranslaTOR is an HPF (High Performance Fortran) compilation system which allows the use of HPF for parallel computing on distributed memory machines including networks of UNIX workstations. ADAPTOR performs a source-to-source transformation wherein a data parallel program is translated into an equivalent SPMD (single node, multiple data) program that will run on all available computing nodes. ADAPTOR supports the PVM and MPI message passing systems as well as several other native versions for parallel machines.

The components that comprise the ADAPTOR system include:

fadapt, which performs the actual source-to-source transformation;

DALIB, a Distributed Array LIBrary containing routines to realize communication and global operations on distributed arrays and the exchange of non-local data (with both depending on the specific message passing system used);

gmdhpf, a compiler driver that calls (in turn) a native cpp to precompile the HPF source code, fadapt to compile the HPF sources into Fortran 77 or 90 source, a native Fortran 77 or 90 compiler to compile the Fortran source into object code, and a native linker to link the object files with DALIB and, if necessary, the target message passing system;

several means of performance analysis including timing statistics, communication statistics, and tracing.

A source code distribution of ADAPTOR is available. The compilers and libraries are written in C and can be compiled on any UNIX box with a recent version of GCC. A native Fortran compiler is also required. The ADAPTOR site doesn't list Linux Intel as a supported platform but I managed to compile the thing with no problems right out of the box. All you need besides the Fortran and C compilers is to install a recent version of either PVM or MPI. Documentation includes a user's, a programmer's, and an installation guide.
[http://www.gmd.de/SCAI/lab/adaptor/adaptor_home.html]
ADATE: Automatic Design of Algorithms Through Evolution is a system for automatic programming, i.e. the inductive inference of algorithms, which is a way to develop artificial and general intelligence. ADATE can automatically generate non-trivial and novel algorithms through a large scale combinatorial search which employs sophisticated program transformations and heuristics. It is particularly good at synthesizing symbolic, functional programs.

The features of ADATE include:

good evolutionary continuity, i.e. desirable algorithms are produced through a series of transformations applied to an empty initial algorithm with the methodology being scalable in the respect that inference times grow polynomially with algorithm complexity for many interesting algorithm domains;

Turing completeness achieved via general recursion, i.e. in theory any algorithm can be produced by ADATE given sufficient CPU time;

exceptional generalizing capability, i.e. it can produce general algorithms from a few sample inputs;

the automatic invention of recursive help functions;

automatic scope changing to keep large programs from having too many CPU-intensive global functions;

optimized heuristics to distinguish between good and bad program properties; and

a sophisticated combinatorial search, i.e. 2-D iterative-deepening search.

Binary versions of ADATE are available for version 0.3 for Windows 95/NT and Linux Intel platforms. A user's manual in PostScript format is included in the distribution. ADATE was developed using the Standard ML language. See Olsson (1995).
[http://www-ia.hiof.no/~rolando/adate_intro.html]
ADIFOR: A tool for the automatic differentiation of Fortran 77 programs. This will, given a Fortran 77 source code and a user's specificiation of dependent and independent variables, generate an augmented derivative code that computes the partial derivatives of all the specified dependent variables with respect to all of the specified dependent variables in addition to the original result. The source code is available for educational and non-profit research after signing a license form. A user's guide and various papers are available in PostScript format. See also the ADOL-C package. See Bischof et al. (1992).

[http://www.mcs.anl.gov/adifor/]
ADL (Assertion): The Assertion Definition Language is a formal grammar for describing the behavior of interfaces. This purposes of ADL are to permit the translation of the formal grammar into natural languages (e.g. English and Japanese) and to permit the automatic translation of the grammar into tests for evaluating the behavior of an implementation of the interface. The targeted user of ADL is anyone faced with the task of defining or testing a C-callable programming interface.
[http://adl.opengroup.org/]

ADLTS

A set of tools for transforming a set of formal ADL specifications into a less formal natural specification, a test specification, and tests for an implementation of the specification. Three specification languages are defined by the ADLTS:

Assertion Definition Language (ADL);

Test Data Description (TDD); and

Natural Language Dictionary (NLD).

The ADLTS software is currently (5/99) in Phase 2 which improves upon Phase 1 by enhancing the target languages and expanding to cover Java, C++ and OMG IDL. While the Phase 1 implementation was developed in C++, Phase 2 uses Java 1.1 to ensure maximum portability of the translation system. This has been designed to work well with the TET package.
Source and binary distributions of ADLTS Phase 1 and 2 are available. The latter can be built on any system with a POSIX-compliant environment. It is written mostly in Java with a few C programs and runtime libraries in C and C++ for testing applications written in those languages. Documentation includes a user's guide, a design specification document and a handful of technical reports, all in the usual expected formats.
[http://adl.opengroup.org/exgr/]
ADL: Architecture Description Languages are languages that describe or represent software architectures. Examples of ADLs include:

ACME

Aesop

Demeter

Rapide

[http://www.sei.cmu.edu/architecture/adl.html]
Adlib: A C++ library implementing a standard distributed array descriptor (DAD) kernel for HPF-style regular distributed arrays. This also contains a comprehensive family of communication schedules for moving and transforming arrays described by the DAD kernel. This is a low-level library that is meant to be used as a building block for user-level libraries An example is the ad++ C++ API included in the distribution, i.e. a set of C++ header files defining type-secure template classes representing distributed arrays, various macros implementing distributed control constructs, and template functions for performing transformations on distributed arrays. A source code distribution is available which contains the usual GNU tools for configuring and compiling. Documentation includes separate manuals for the kernel and the ad++ API.
[http://www.npac.syr.edu/projects/pcrc/adlib.html]
ADLT: The Assertion Definition Language Test generator is a compiler for ADL, a specification language for programming interfaces which can be used to describe the programmer's interface to any C-callable function, library, or system call. ADLT generators header files, test programs, and natural-language documentation from ADL specifications. It can be used as a test generator to create tests for existing software or standards or as a development tool to ensure that documentation, software, and tests are aligned and to enable concurrent work on all three aspects of software production.

A source code version of ADLT is available as are binaries for several platforms including Linux Intel. It is written in C++. The distribution also includes some example specifications and tests as well as extensive documentation in PostScript format.
[http://www.smli.com/research/adl/]
ADMesh: A command-line driven program for processing triangulated solid meshes. The capabilities of ADMesh include:

reading and writing binary and ASCII STL files,

checking STL files for flaws (e.g. unconnected facets, bad normals),

repairing facets by connecting nearby facets within a given tolerance,

filling holes in the mesh by adding facets,

repairing normal directions (if facets aren't CCW),

repairing normal values (if they aren't perpendicular to facets with unit length),

removing degenerate facets (i.e. those with two or more equal vertices),

translating, rotating, mirroring, scaling, merging two STL files,

calculating the volume of a part, and

writing files in OFF, VRML, and DXF formats.

A source code distribution of ADMesh is available. It is written in C and can be compiled and used on many flavors of UNIX including Linux. It is documented in a short ASCII file. Future plans include a display capability, slicing, and splitting a file into smaller files.
[http://www.varlog.com/products/admesh/]
adns: The GNU Asynchronous DNS client library is a DNS resolver library for C/C++ programs. The features include:

usable in an asynchronous, non-blocking manner to simultaneously handle many queries;

responses are automatically decoded into a natural representation for a C program;

automatic sanity checking;

return of time-to-live, CNAME and other information in an easy-to-use form;

the resolver state is an opaque data structure, i.e. there is no global state so a program can have several instances of the resolver; and

error reporting that distinguishes among several causes of failure;

can use and understand the conventional resolv.conf, but also override it via environment variables.

A source code distribution is available under the GPL.
[http://www.chiark.greenend.org.uk/~ian/adns/]
ADOL-C: An automatic differentiation package that uses operator overloading for the evaluation of arbitrary order derivatives of functions that are given as C/C++ source code. Various drivers are available for derivative evaluation by forward and reverse mode. The source code is available as well as extensive documentation in PostScript format. There is also an ADOL-F package for the automatic differentiation of Fortran codes. This is TOMS algorithm 755 and is documented in Griewank et al. (1996).
[http://www.math.tu-dresden.de/~adol-c/]
Adsmith: An object-based distributed shared memory (DSM) system built completely on top of PVM whose primary goal is to provide a low-cost, portable, and efficient DSM for networks of workstations. Adsmith is a user-level C++ library which provides primitives to create and allocate shared objects, accesses to shared objects, and operations to synchronize among processes. It also incorporates many techniques for performance optimization such as a release consistency memory model, different coherence protocols, load/store-style memory accesses, an object-based multiple writer protocol, bulk transfer, prefetch, nonblocking store, and other specialized types of accesses.
The features of Adsmith include:

symmetric shared object allocation wherein shared objects can be dynamically allocated at any time;

flexibly setting properties of each object including using caching, write invalidate or update, allocating the shared object on the local host, and manipulating the object using object-based multiple writer protocol;

specifying the distribution of shared objects;

load/store-style memory accesses;

a release consistency memory model wherein ordinary, non-synchronization and synchronization accesses are all provided;

various synchronization operations including barrier, mutex and semaphore;

non-blocking operations including prefetch and both nonblocking stores and allocation;

pointer control in shared memory;

various specialized accesses including atomic, collective and active;

bulk transfer on allocation, ordinary accesses and prefetch functions;

a tree-like parent-child process relationship;

a simple identification mechanism with host and process numbers and functions to translate between the PVM task ID and the Adsmith process number;

use of both PVM and Adsmith primitives simultaneously; and

starting PVM automatically if the PVM hostfile is specified in an environmental variable.

A source code distribution of Adsmith is available. It is written in C++ and should compile and install on most generic UNIX platforms on which PVM is already installed. The developers have test platforms for Sun SunOS and Linux Intel which indicates that it should work fairly well on these. It is documented in a user's guide and several technical reports, all available in PostScript format.
[http://archi1.ee.ntu.edu.tw/~wyliang/adsmith/]
[http://wotug.ukc.ac.uk/parallel/environments/pvm3/adsmith/]
AE: Abstract Execution is a program profiling system which records a small set of events during the execution of the traced program. These events serve as input to an abstract version of the program which generates a full trace by re-executing selected portions of the original program. AE greatly reduces both the cost of tracing the original program and the size of the trace files, with the cost of regenerating a trace insignificant in comparison to the cost of the applications that use it.

A source code distribution of AE is available. It is written in C and can be compiled and used on most flavors of UNIX. It is documented in a technical report included in the distribution in PostScript format.
[http://www.gnu.ai.mit.edu/order/ftp.html]
Aegis: A transaction-based software configuration management system (i.e. a CASE tool) which provides a framework in which a team of developers may work on program changes independently. Aegis coordinates integrating these changes back into the master source of the program with as little disruption as possible. It does this inthe UNIX spirit by being a small component designed to work with other programs.

The features of Aegis include:

a design based on incremental development which allows any historical version to be reproduced;

the enforcement of a development process which requires that sets of changes work before they are integrated into a project baseline (i.e. that they build successfully and optionally included and pass tests);

support for long transactions (known as branches) which allows appropriately created changes to be treated as if they were projects as thus to have changes made to them;

internationalized error messages;

a script-based reporting facility allowing many custom reports to be generated from the database (along with many report scripts supplied in the basic distribution; and

an intranet Web server interface which allows browsing of much of the meta-data of all publicly accessible projects.

The source code for Aegis is included in the distribution and can be installed on most generic UNIX platforms using the supplied configure script. The system is documented in an 80 page user's manual available in PostScript format.
[http://www.canb.auug.org.au/~millerp/aegis.html]
[ftp://ftp.agso.gov.au/pub/Aegis/]
AERO: An X Window tool for the simulation and visualization of rigid-body systems. It contains a 3D scene editor for designing simple block world scenes. Objects may be placed in space, linked to each other, and forces may be exerted onto them. In animation mode, the simulation of the scene entered is carried out in real time (depending on the machine and scene complexity) and displays 3-D wire frames. A flag can also be set to generate scene description files for a ray tracing program which can produce photorealistic output. Stereo images can be generated in both wire frame and ray tracing scenes. A red-green representation of the wire frame scenes is generated which can be viewed with red-green glasses to achieve the stereo effect. A binocular pair of scene descriptions is generated for each time step for the ray tracing output.

The AERO system is available as source code or as a binary for DEC Ultrix, SGI IRIX, Sun Solaris and SunOS, and Linux Intel platforms. A user's manual is available in PostScript format. Compilation of the source code requires the Xaw and FWF widget libraries as well as a C compiler and X11R5 or newer. See Keller et al. (1993).
[http://www.ee.uwa.edu.au/~braunl/aero/]
Aesop: A software architecture design environment generator and ADL. Aesop provides a generic toolkit and communication infrastructure that users can customize with architectural style descriptions and a set of tools to use for architectural analysis. More later.

[http://www.cs.cmu.edu/afs/cs/project/able/www/aesop/aesop_home.html]
afbackup: A client-server backup system which offers several workstations a centralized backup to a special backup server. The backups on the clients can be started automatically using cron jobs, although the preferred method is to start them remotely from a central administrative host. This latter option is designed to avoid security holes, e.g. client authentication is performed before it can take over control and access is restricted to the streamer device. Other capabilities include client-side per-file compression, writing the data stream to the tape in pieces and logging the tape position for each file for fast file finding, use of full tape capacity, full or incremental backups, and the capability of backing up raw partitions.
A source code distribution of afbackup is available. It is written in C and has been tested on both the server and client sides on Linux Intel, IBM AIX, and SGI IRIX platforms. It is documented in several ASCII text files included in the distribution.
[ftp://www.zn.ruhr-uni-bochum.de/pub/linux/]
AFD: The Automatic File Distributor provides a framework for flexible, non-stop, logable and debuggable delivery of an arbitrary number of files to multiple recipients. The features include:

sending/retrieving any type of file regardless of name or contents;

distribution of only files and no additional information;

a sophisticated and compact X11 interface for monitoring and controlling file distribution;

sending files to places where AFD is not installed;

the use of more than one process to distribute files to a single host;

prioritizing file distribution; and

setting up a network of AFDs that can be monitored and controlled via a single interface.

[http://www.dwd.de/general/GBTI/afd/english/]
AFGL: A software package for natural language processing. Affix grammars are a family of two-level grammars where the first level consists of CF syntax rules extended with meta-variables (i.e. affixes) and the second level defines the domains of these affixes. Affix Grammars over a Finite Lattice are a simple form of affix grammars in which the second level consists of finite domains with the affixes set-valued and the operations intersections. The AFGL formalism consists of rules and metarules, with the latter a collection of restricted context free rules forming the second level of AFGL. The parsers generated by AFGL are top-down recursive backup parsers which implement nondeterministiv LC-parsing using continuations. This method can deal with slightly restricted left-recursive grammars and can produce on demand one or more parsings for ambiguous grammars.

The AFGL system consists of four main parts. GEN is the parser generator which activates the AFGL compiler driver which generates a parser for the input grammar expressed in AGFL. It can also optionally invoke the lexicon system LEXGEN. LEXGEN is a system for combining parsers generated with GEN with large lexical databases. It requires a lexicon (for which it compresses and builds an index) and a description of the interface between the grammar and the lexicon. The parsers generated by GEN perform lexical analysis on input using either word parsing or prefix parsing, with the former considering the input as a sequence of words separated by word separators and the latter used for describing morphology or compound words. A parser can also display a lexical network consisting of a list of words indexed with input positions, with all lexical classifications given for each word along with the next input position. The Grammar Workbench (GWB) is an environment for the development of affix grammars in the AFGL formalism. It allows a user to input, inspect, and modify a grammar as well as perform consistency checks, compute grammar properties, generate example sentences, and assist in performing grammar transformations.
Binary distributions of the AGFL systems are available for MS-DOS, Linux Intel, and Sun SunOS and Solaris platforms. A user's manual as well as several technical reports are available in PostScript format.
[http://www.cs.kun.nl/agfl/Index.html]
afio: An archiver/backup program that produces archives in cpio format.

[ftp://ftp.win.tue.nl/pub/linux/tbackup/]
[http://sunsite.unc.edu/pub/Linux/system/backup/]
AFOF: An astrophysical program which uses an Approximate Friends-Of-Friends method to find approximate groups in the output file produced by an N-body simulation. A particle belongs to a friends-of-friends group if it is within some linking length tau of some other particle in the group. It also takes another parameter epsilon which indicates how much error can be tolerated, i.e. it is an approximate method. AFOF reads input files in the TIPSY format and writes to an ASCII output file.

The source code for AFOF is available. It is written in C and should compile on generic UNIX platforms. It is documented in a man page. AFOF is a part of the HPCCSOFT Tools suite.
[http://www-hpcc.astro.washington.edu/tools/AFOF/]
AFsp: a The Audio File speech processing package is a library of routines for reading and writing audio files with emphasis on providing support for audio files used by the speech processing research community. The formats that can be read with the AFsp package are headerless audio files, Sun audio files, RIFF WAVE files, AIFF/AIFF-C audio files, NIST SPHERE audio files, IRCAM soundfiles, INRS-Telecom audio files, ESPS sampled data feature files, and text audio files in NATO/ESPRIT CD-ROM format. The package can write to headerless audio files, AFsp (Sun) audio files, RIFF WAVE files, and AIFF-C audio files.

The AFsp package also includes several audio file utilities including:

InfoAudio, which displays information about an audio file;

CompAudio, which compares audio files and produces statistics and signal-to-noise ratio figures;

ConcatAudio, which concatenates samples from audio files;

CopyAudio, which combines an arbitrary linear combination of input files into a selected format output file;

FiltAudio, which filters an audio file with an FIR, IIR, or an all-pole filter;

GenNoise, which generates a file containing Gaussian white noise;

LPanal, a demo program to do LPC analysis on a speech file;

LPsyn, a demo program to do LPC synthesis from a residual file; and

ResampAudio, which resamples data from an audio file.

A source code distribution of AFsp is available as is a Linux ELF binary. The library is documented in both man pages and in HTML files. This is a subset of the libtsp package.
[ftp://tsp.ee.mcgill.ca/pub/AFsp/]
[http://www.TSP.EE.McGill.CA/software.html]
[http://sunsite.unc.edu/pub/Linux/apps/sound/libs/]
AFT: The Almost Free Text package is a nearly free format documentation system (i.e. the format is free as well as the system) which can be typed in using any editor or word processor which supports tabs. AFT is designed to parse and recognize patterns rather than formal commands, and as such it will process almost anything you throw at it. A document processed with AFT can be easily converted into other formats like HTML and LaTeX.
[http://www.maplefish.com/todd/aft.html]
AfterStep: A continuation of the BowMan window manager, which was itself based on the fvwm window manager. It was originally designed to emulate some of the look and feel of the NextStep user interface but has advanced, adding more useful and requested features.
AfterStep features include:

Wharf, a free-floating application loader which can swallow running programs as well as contain folders with more applications; gradient filled title bars;

gradient filled root window pop-up menus which can be configured to accomodate different styles of management; and

NextStep style icons to give a consistent look and feel to the desktop.

The source code is available as well as binaries for several platforms including, of course, our beloved Linux. There is an article about AfterStep in the March 1998 issue of the Linux Journal.
[http://www.afterstep.org/]

ascp

The AfterStep Control Panel provides an intuitive graphical front-end for configuring the AfterStep window manager. This is written in C and uses GTK.
[http://hubble.colorado.edu/~nwanua/html/ascp.html]
Agat: Another Graphics Animation Tool is a package that allows the fast and easy production of algorithm animation. It is based on a client-server architecture which makes the description of the animation independent from the program which is to be animated, which eliminates the need to recompile the program to change the animation. Agat provides support for watching a program in action through the use of a stream processor in which values are provided to the server by sending them on named streams which can be combined to make other streams.

The source code is available and has been ported to Sun SPARC and Linux Intel platforms. It is described as being ``a bit buggy'' on DEC Alpha systems. Agat is documented in a paper and a reference manual, both of which are available in PostScript format.
[http://www.inria.fr/safir/SAM/Agat/agat.html]
agents: Packages that implement agents in one form or another include:

AAFID, a monitoring and intrusion detection system employing agents;

AgentD, a modular scheduling daemon;

AgentSpace, a framework for developing agent systems;

April, a language for implementing intelligent applications on a network;

Ara, a platform for the portable execution of mobile agents in heterogeneous networks;

D'Agent, a transportable agent system;

Echo, a simulation tool for systems composed of many interacting adaptive agents;

JAFMAS, a generic system for developing speech-act based multiagent systems;

Jam!, a general purpose agent architecture in Java;

JAM, an agent system for forewarning financial institutions of impending threats;

JAT, a template for constructing software agents;

Java-To-Go, an infrastructure for the development of mobile agents and agent-based applications;

Kafka, a Java-based library for constructing multi-agent based distributed applications;

KAPI, a function library for KQML-speaking agent building;

KIF, a language for the interchange of knowledge among disparate programs, e.g. agents;

kifparse, a parser for the KIF language;

Knowbot, a Python enviroment for developing and using mobile agents;

KQML, a language and protocol for exchanging information and knowledge;

LCWA, an agnet for determining the last changed times of a set of HTML documents;

Magenta, an agent communication language;

Mozart, an interactive distributed language for, among other things, applications organized into multiple agents;

NetSolve, a client-server application for solving computational problems over a net;

SOAR, an AI programming language used to create intelligent agents;

Swarm, a package for multi-agent simulation of complex systems;

UMPRS, a general purpose agent architecture in C++; and

WILMA, for the management of LANs using SNMP and knowledge-based systems.
AgentD: A modular scheduling demon intended to be an improvement on and a replacement for cron. The goal is to create a utility/daemon which schedules system administration procedures as often as necessary rather than at regularly scheduled times. The package consists of: AgentD, a daemon that manages the scheduled execution of Agents; Agents, objects which perform actions based on certain criteria; and agents, any executable file or command, i.e. a raw Agent. The daemon reads a configuration file with lines containing Agent types (and options for them) and Agents. An Agent type or module is a specific type of scheduling paradigm, with the two presently available being a cron-type module which schedules tasks at regular intervals and a AOAN module which adjusts scheduling to run only As Often As Necessary.
A source code distribution of AgentD is available. It is currently (8/97) in the alpha test stage. It is written in Objective-C.
[http://www.subsume.com/employees/droleary/agentd/agentd.html]
AgentSpace: A Java-based framework for the development of mobile agent systems built on top of the ObjectSpace Voyager package. AgentSpace is composed of three integrated components:

AS-Server, a Java multithreaded process in which agents can be executed which provides agent and place creation, agent execution, access control, agent persistence and mobility, generation of unique identities, support for agent communication, and a simple management/monitoring interface;

AS-Client, which supports the management and monitoring of agents and related resources and consists of a set of Java applets stored on an AS-Server's machine; and

AS-API, a package of Java interfaces and classes that define the rules for building agnets.

A source code distribution of AgentSpace is available. It requires Voyager 1.0.1 and JDK 1.1 or greater.
[http://berlin.inesc.pt/agentspace/index.html]
AgentTcl: The name of this has been changed to D'Agents.
AgentX: The Agent eXtensibility protocol specifies a method by which subagents may advertise and export MIB regions via a single SNMP agent. This protocol, defined by RFC 2257, is transparent to the network management station with the master agent MIB unaware and the subagents SNMP unaware. This allows for both a simpler master agent design and subagents that only have to speak AgentX rather than also SNMP. A source code distribution of an AgentX SNMP daemon and the AgentX library is available.

[http://www.scguild.com/agentx/]
[http://www.net.cmu.edu/groups/netdev/agentx.html]
AGL: The ASTRONET Graphics Library is a library of graphics routines designed to be portable across different systems. It has both a C and a Fortran programming interface. The source code is available and has been compiled and tested on HP, Linux, MS-DOS, Solaris, Sun OS, Ultrix and VAX/VMS systems.
[ftp://ftp.arcetri.astro.it/pub/agl/]
[http://www.arcetri.astro.it./ftp.html]
Aglaophone: A system of interconnectable modules for recording, processing and playing real-time audio. The available modules include:

soundcardio, a module for recording and playback via a sound card which supports oversampling and oversampling anti-alias/anti-image filtering;

spectr, for real-time spectrogram and oscilloscope display;

bits, increases the amount of quantization (i.e. decreases the number of bits) of a signal;

rawread and rawwrite, for reading and writing unformatted sample data;

mp3gate, a gateway to an MP3 compressor and/or decompressor;

splitter, generates two outputs from one input;

syncswitch, switches between two inputs;

upsamplefilter, unsample and then filter a signal;

filterdownsample, filter and then downsample a signal; and

adder, adds two signals together.

[http://www.tam.cornell.edu/~sdh4/aglaophone/]
aglets: Aglets are Java objects that can move from one host on the Internet to another, performing arbitrary operations within the security limits established by each host computer. They are an example of what is more widely known as mobile network agents, and can be used to distribute large applications over a series or network of machines. An Aglets Software Development Kit (ASDK) is available for designing, testing and using aglets.
[http://www.aglets.org/]
[http://www.trl.ibm.co.jp/aglets/]
AGNI: AGent at NIST is a middleware infrastructure for building dynamically reconfigurable distributed systems. It is used for such things as distributed protocol testing, monitoring, and conferencing applications, and was designed to enable the scripting of distributed systems where it is desired to instantiate the entire system from a single point of control. It can also be used to dynamically reconfigure and extend systems during execution to deal with changes in the environment, failures, and other contingencies. It presents an event-oriented programming model and supports state and code mobility.
The functionality of AGNI includes:

storing and instantiating tests from a central location, e.g. a Web server;

moving the functionality and any initial state from the server to the communicating peers before the test begins execution;

determining that initialization is complete before starting;

interactions that are peer-to-peer rather than being routed through a Web server;

detecting and handling failures; and

ensuring the integrity of instantiated distributed systems.

AGNI is a Tcl extension that should be usable on any platform supporting that language. A source code distribution is available as is a reference manual, a tutorial, and several example programs.
[http://badger.antd.nist.gov:8099/web-pages/]
[http://w3.antd.nist.gov/Products/products_antd.html]
agrep: An improvement on the grep command that allows for fast text searching with errors. The features of agrep not usually supported by other greps include:

searching for approximate patterns, e.g. agrep -2 word file.txt will find all patterns in a file matching ``word'' or differing from it with at most two substitutions, insertions or deletions;

oriented by record rather than line, with the capability of user-defined records; and

multiple pattern searching with AND or OR logic queries.

[http://glimpse.cs.arizona.edu/software.html]

agrepy

A port of the functionality of agrep to Python.
[http://www.ccsr.cam.ac.uk/~mw263/pyagrep.html]
AGROMET: A set of routines for implementing optimal interpolation procedures for agrometeorological variables, although they can be used with any spatially distributed data. The programs all use the technique of cokriging, in which more than one variable can be taken into account when making optimal estimates. Cokriging involves characterizing the spatial dependence among observations, modeling this dependence using functions known as simple and cross-variograms, and then using these functions to estimate a variable over a given area.

The three modules comprising AGROMET are:

VARIO, which computes values of the characteristic variogram functions;

COREG, which models these functions to define a valid model called a linear model of coregionalization (LMC) which will be used to estimate the values of the variable at different locations; and

COKRIG, which produces optimal estimates are chosen spatial locations by combining known neighboring values with LMC-derived values.

A source code distribution of AGROMET is available for UNIX platforms. It is written in C++ and documented in a user's manual available in HTML format.
[http://www.agro.ucl.ac.be/biom/recherche/projets/agromet/agromet.htm]
AIDE: The Advanced Intrusion Detection Environment is a free replacement for Tripwire that has the features of the latter and more. AIDE creates a database from regular expression rules in a configuration file. After initialization this database can be used to verify the integrity of files. Currently (9/99) four message digest algorithms are used to check the integrity of files.
[http://www.cs.tut.fi/~rammer/aide.html]
AIML: The Astronomical Instrument Markup Language is a domain-specific implementation of IML, itself an instance of XML. AIML is being developed to command and control astronomical instruments. The AIML instrument description encompasses instrument characteristics, control commands, data stream descriptions, message formats, communication mechanisms and pipeline algorithm descriptions. It also supports role-specific documentation and GUI component generation.
[http://pioneer.gsfc.nasa.gov/public/aiml/]
aimLib: The array-independent mathematics Library is a library for performing high-level mathematical computations that is designed to operate with any number of available lower-level array math libraries (e.g. Blitz++ and TNT). The modules into which it is divided include:

ODE, classes for defining and numerically integrating systems of ODEs;

MRA, a multi-resolution analysis module containing filters for wavelet transforms as well as classes for performing discrete forward and inverse wavelet transforms.

Other modules are (3/00) in the planning stages.
[http://aimlib.sourceforge.net/]
AIMS: The Automated Instrumentation and Monitoring System consists of a suite of software tools for measuring and analyzing the performance of Fortran and C message passing programs written using the NX, MPI and PVM communication libraries. It can be used to illustrate algorithm behavior, help analyze program execution, and highlight problem areas that can be modified to improve program execution.
The programs comprising AIMS include:

xinstrument, a source code instrumenter that accepts Fortran 77 and C message passing programs written under MPI and PVM;

monitor, a library of timestamping and trace-collection routines;

pc, a utility for removing monitoring overhead and its effects on the communication patterns as recorded in tracefiles;

a tracefile animation and analysis toolkit.

A source code distribution is available which includes makefiles for several platforms including Linux. An extensive user's manual is available.
[http://science.nas.nasa.gov/Groups/Tools/Projects/AIMS/]
AIPS: The Astronomical Image Processing System is a software package for the interactive or batch calibration and editing of radio interferometric data and for the calibration, construction, display, and analysis of astronomical images made from those data using Fourier synthesis methods. The AIPS package was started in 1978 and currently (5/97) contains over a million lines of code in over 350 distinct application tasks. It was developed by the National Radio Astronomy Observatory (NRAO) and is primarily intended for radio astronomy. AIPS has been the principal tool for the display and analysis of both 2-D and 3-D radio images from the NRAO's Very Large Array (VLA) since 1981.
AIPS contains facilities for displaying and editing data in the aperture (i.e. u-v) plane; for image reconstruction by Fourier inversion; for deconvolution of the point source response by clean and maximum entropy methods; for image combination, filtering, and parameter estimation; and for a wide variety of image and graphical displays. It implements a simple command language which is used to run tasks and to interact with text, graphics, and image displays. It embraces all stages of radio interferometric calibration, both continuum and spectral line, and contains a full suite of calibration and editing functions for both VLA and VLBI data including interactive and batch methods for editing visibility data. It reads data in MkII, MkIII, and VLBA formats, performs global fringe-fitting by two alternative methods, offers special phase-referencing and polarization calibration, and performs geometric corrections in addition to the standard calibrations done for connected-element interferometers.
The source code for AIPS is available as are binaries for Sun Solaris and SunOS, Linux Intel (ELF), DEC OSF/1, IBM AIX, SGI IRIX, and HP-UX platforms. There are over 100,000 lines of online documention and 500,000 lines of printable documentation in PostScript format. Anything and everything that can be documented about this has been documented about this. The Usenet group alt.sci.astro.aips deals with AIPS questions and issues. See also AIPS++.
[http://www.cv.nrao.edu/aips/]
AIPS++: An evolutionary step beyond the AIPS package, AIPS++ is a software package for performing various post-processing tasks such as calibration, editing, image formation and enhancement, and analysis of astronomical data. It is written in C++ rather than the Fortran of AIPS. It is primarily targeted at radio astronomy but can be used in other branches of astronomy as well as in other applications in image processing and data analysis.

The goals of AIPS++ include:

support for single antenna (dish) telescopes, multiple element interferometer arrays, and combinations of observations made with different instruments;

support for post-processing at least as fully as presently exists in AIPS;

provision of a set of routine applications (scripts and programs) whose parameters can be changed interactively and dynamically;

provision of a core of application classes for use with AIPS++ applications with access for non-AIPS++ code via a application programming interface (API);

being written primarily in C++ with interfaces to C and Fortran;

a design for easy maintenance and extensibility;

provision for multiple user interfaces, graphical and otherwise;

portability to as many platforms as is possible;

provision of a standard suite of test programs; and

the capability of reading and writing data in the FITS format.

The core package of AIPS++ is the aips package consisting of core modules common to the entire system and with which most applications and packages will be built. The modules include:

arrays, the basic array class for regularly sampled multi-dimensional data;

containers, a class providing non-mathematical containers, e.g. queues, stacks, lists, associative arrays, etc.;

deconvolution, a class supporting deconvolution on arrays;

exceptions, a class providing the exception handling mechanism used in AIPS++;

functionals, classes which map an input object of some domain type onto an output object of some range type, with the domain and range usually being numeric types;

glish, classes created to make it easy to construct AIPS++ applications which interact with each other via interprocess communications;

graphics, a graphics class which currently (5/97) contains a wrapper for PGPLOT and a test program;

IO, a class providing the basic I/O functionality;

Images, classes for handling images and image formats;

ImgCrdSys,

Inputs, a class facilitating a basic command line user interface;

Lattices, classes for creating lattice-like objects;

Logging, a class for the logging of interactive sessions and the later use of the data thus logged;

Mathematics, a class with various mathematical types and operations;

Measures, a class dealing with units, physical quantities, and a reference frame;

OS, a class providing access to the operating system;

RTTI, a class providing two different RunTime Type Information implementations;

Tables, a class providing a fundamental storage mechanism; and

Utilities, a group of object, logical, pointer, datatype, and other types of utilities.

The AIPS++ package was in beta test release as of 2/97 and can be obtained by contacting an address given at the site.
[http://aips2.nrao.edu/aips++/docs/html/aips++.html]
Aipsview: A tool for 2-D visualization built in cooperation with the AIPS++ project. The features of Aipsview include:

input of FITS and AIPS++ image files;

the display of 2-D images as well as any orthogonal 2-D slice from a 3-D cube;

the interactive display of pixel coordinates, world coordinates, and data values;

interactive vector (line drawing) plots of data value vs. coordinate value for plots of line profile or intensity vs. spatial position;

the interactive specification of rectangular subregions and magnified display of same;

image scaling by either pixel replication or subsampling; multiple simultaneous image display;

animated sweeping through slices along any dimension;

synchronized sweeping for multiple data cubes;

blinking between two or more images;

a complete colormap editor for the creation and editing of look-up tables; and

built-in Glish functions for communicating with external programs.

Binary versions of Aipsview are currently (10/97) available for Sun SunOS and Solaris, SGI IRIX, and Linux Intel platforms. A user's manual is available in PostScript format.
[http://monet.astro.uiuc.edu/AipsView/av.html]
Air-Sea: A collection of Matlab programs (m-files) which can be used to compute surface wind stress and heat flux components from buoy and shipboard atmospheric and near-surface oceanographic time series measurements.
The programs available include:

SWHF, which computes net shortwave (SW) flux into the ocean and the albedo;

LWHF, which computes net longwave (LW) flux into the ocean when the downward LF is measured;

BERLIAND, which estimates the net LW flux into the ocean when the downward LF is not measured;

HFBULKTC, which computes the latent and sensible heat fluxes into the ocean;

SLHFTC, which computes the same fluxes with an included ocean surface current;

STRESSLP and STRESSTC, which compute the neutral wind stress in neutral conditions using different formulations;

HFBULKTC and SLHFTC, which compute the surface wind stress amplitude in non-neutral conditions without and with an included ocean surface current;

WAVEDIST and WAVEDIS1, which estimate the true wind speed at 10 meter and measurement heights;

OMEGALMC, which estimates the wave effect on a wind log profile;

CDNVERA, which computes the neutral drag coefficient;

and several other related programs.
These files can be used either in the commercially available Matlab program or in Octave, a similar matrix manipulation program which can run Matlab m-files. All of the programs are documented in a descriptive header within the program.
[http://crusty.er.usgs.gov/sea-mat/air_sea-html/index.html]
AISearch: A C++ class library for developing problem solving software. It offers a set of search algorithms which may be used to solve many different kinds of problems so the research can focus on the representation of the problem to be solved rather than on the gory details concerning the implementation of search algorithms. This set of search classes may be incorporated into other software via the C++ mechanisms of derivation and inheritance.

The search algorithms implemented in AISearch include depth-first tree and graph search, breadth-first tree and graph search, uniform-cost tree and graph search, best-first search, bidirectional depth-first tree and graph search, bidirectional breadth-first tree and graph search, AND/OR depth tree search, and AND/OR breadth tree search.
A source code distribution of AISearch is available. It is written in C++ and can be compiled and used with most popular C compilers. The distribution also includes a user's manual and several examples on the use of the library. See Tracy and Bouthorn (1996).
[ftp://ftp.icce.rug.nl/pub/peter/]
AKCL: Austin Kyoto Common Lisp is a Common Lisp implementation which is a collection of ports, bug fixes and improvements to the KCL implementation. The last update to this was made in 1994 with the author switching to working on the outgrowth GCL implementation at that time. He highly recommends using GCL instead of AKCL.

[http://www.cs.cmu.edu/afs/cs/user/mkant/Public/Lisp/impl/kcl/akcl/]
AL: The Algorithm Language is a programming language for modeling and animation. It is actually an extension to Scheme, specifically to the Elk implementation. The AL language for 3-D modeling and animation consists of a set of underlying key concepts including:

gprims (geometric primitives), i.e. AL procedures which draw simple geometric shapes such as polygons, spheres, cones, etc.;

graphics state, i.e. the fundamental building block for hierarchical modeling which at any time consists of a transformation matrix and surface rendering attributes;

gops (geometric operations), i.e. operations that change the transformation matrix or attributes of the current graphics state;

models, i.e. AI programs which generate objects;

avars (articulation variables), i.e. a 1-D variable which can vary over time; and

AL data types, i.e. some mathematical data types, array types, and syntactical forms particulary useful for AL procedures.

The AL package consists of a set of tools that work directly with AL including:

ox, an AL interpreter which can read and dynamically execute AL commands and programs;

ogre, an interactive tool uses to display the contents of the current world model;

hview, a tool to display the current hierarchy and to load avars in and out of other tools;

aardvark, an animation track editor used for editing avars; and

cuesheet, which lets you view and manipulate avar key frames as values in a spreadsheet-like arrangement.

Binary distributions of AL are available for several platforms including Linux Intel. The Linux version does not support cuesheet or aardvark. Large amounts of documentation are available online.
[http://www.cgrg.ohio-state.edu/~smay/AL/]
ALADDIN: A computational tookit for interactive engineering matrix and finite element analysis. Finite element computations are viewed by the package as a specialized form of matrix computations, matrices are viewed as rectangular arrays of physical quantities, and numbers are viewed as dimensionless physical quantities. The architecture consists of a kernel, libraries of matrix and finite element functions, and input files, which are used via a command language.

Features of ALADDIN include:

mechanisms for defining physical quantities with units as well as matrices of physical quantities,

facilities for physical quantity and matrix arithmetic,

SI and US units packages,

a matrix solver package;

programming constructs to control the solution procedure,

a finite element mesh generation package with which 2-D and 3-D meshes can be created, and

a library of finite elements including those for plane stress/strain analysis, 2-D beam/column analysis, 3-D truss analysis, DKQ plate analysis, and a variety of shell finite elements.

The source code, written in C, is available and has been tested on Sun SPARC, DEC Ultrix, and IBM RS/6000 platforms. I've successfully compiled it out of the box on my Linux platform using GCC, although I haven't yet tried to use it. The documentation is contained within a 235 page manual available in PostScript format which can be referenced as Austin et al. (1995).
[http://www.isr.umd.edu/~austin/aladdin.html]
AlaDyn3D: A dynamic simulation system for calculating the motions, deformation and interactions between objects. This allows the construction of complex physical scenes involving various interacting objects and robots and the control of these scenes using appropriate force-based operators. The capabilities include constructing dynamic models from a set of geometrical forms, controlling the motions of the objects by applying selected external forces, simulating the dynamic behavior of the objects involved, and creating new or customizing existing models. The features include:

configurability via a Lisp interpreter integrated within the system for interfacing with the program, creating macros, and defining new types of objects;

extensibility via the abstraction of the dynamical model notion; and

generic and reusable objects.

Binary distributions are available for Linux Intel and other platforms.
[http://www.inrialpes.fr/sharp/modelisation/AlaDyn/]
Albert: An interactive research tool to assist the specialist in the study of nonassociative algebra. It is written in ANSI C and is documented in a user's manual available in PostScript format.

[ftp://ftp.cs.clemson.edu/albert/]
ALCON1: A Fortran program to solve ALgebraic systems of equations using the CONtinuation method. ALCON1 solves parameter dependent systems of nonlinear equations using numerical path following with automatic step-length control. It will optionally compute turning and simple bifurcation points. See the ALCON-S entry for more details. The program is documented via source code comment statements. This is part of CodeLib.

[ftp://elib.zib.de/pub/elib/codelib/alcon1/]
ALCON2: A Fortran program to solve ALgebraic systems of equations using the CONtinuation method. ALCON2 solves parameter dependent systems of nonlinear equations using numerical path following with automatic step-length control. It will optionally compute turning and simple bifurcation points, and differs from ALCON1 in that it will optionally construct complete bifurcation diagrams. The program is documented via source code comment statements. See the ALCON-S entry for more details. This is part of CodeLib.

[ftp://elib.zib.de/pub/elib/codelib/alcon2/]
ALCON-S: A package of C programs for solving nonlinear systems of real equations depending on one parameter. ALCON-S computes smooth solution paths using a continuation algorithm called pathfinding (or the predictor-corrector method) with sophisticated step-length control. It applies a tangential predictor and a Gauss-Newton method corrector, with the latter treating the parameter like an ordinary variable and solving the underdetermined linear system via the Moore-Penrose pseudo-inverse algorithm. Turning points can be computed based on an interval halving algorithm where cubic Hermite interpolation between two points gives the next estimate. Simple bifurcations can also be computed via the solution of an augmented system which has the bifurcation point as a local unique solution which is found using an ordinary Newton's method.

A source code distribution of ALCON-S is available. It is written in ANSI C and thus portable to any UNIX flavor with an appropriate compiler. Some Matlab scripts are provided to graph the results. It is documented in a 39 page user's manual in PostScript format. This is a better documented version of ALCON1 and ALCON2 written in C. This is part of CodeLib. See Deuflhard et al. (1987a).
[ftp://elib.zib.de/pub/elib/codelib/alcon_s/]
ALE: The Attribute-Logic Engine is a freeware logic programming and grammar parsing and generation system. It is written in Prolog and integrates phase structure parsing, semantic-head-driven generation and constraint logic programming with typed features structures as terms. It allows type inheritance and appropriateness specifications for features and values. Arbitrary constraints may be attached to types, and types may be declared as having extensional structural identity conditions. Grammars may interleave unification steps with logic program goal calls to allow parsing to be interleaved with other system components. ALE was developed for Head-Driven Structure Grammar (HPSG) but can also execute PATR-II grammars, definite clause grammars, Prolog, Prolog-II, and LOGIN programs.

A source code distribution of ALE is available. There are versions for both SICStus Prolog 3.0 and for SWI Prolog. It is documented in a set of manuals covering all aspects of its use and development. Some course material is also available. The source code is distributed with a number of sample grammars and some third-party interfaces are also available.
[http://www.sfs.nphil.uni-tuebingen.de/~gpenn/ale.html]
[http://www.cs.cmu.edu/afs/cs/project/ai-repository/ai/lang/prolog/code/parsing/ale/]
ALE: The Adaptable Layout Environment is a tool for building interfaces for Java applications. The functionality of ALE includes:

using free-form, grid, or flow layout techniques or any combination thereof in the same interface;

exact alignment of components relative to either the dialog box or each other;

sizing components exactly or relative to each other; and

trying new interface designs without recompiling.

A source code distribution is freely available.
[http://208.223.9.21/jfd/java/ale/ale.html]
ALEC64: An emulator for the Commodore C64 computer for the X Window system or the Linux console. It provides complete emulation of the hardware and a built-in machine language monitor.

[http://sunsite.unc.edu/pub/Linux/system/emulators/commodore/]
Alembic Workbench: A project to create a natural language engineering environment for the development of tagged corpora. The workbench incorporates a suite of tools for the analysis of a corpus along with the Alembic system to enable the automatic acquisition of domain-specific tagging heuristics. The overall goal is to create a system for automated information extraction, i.e. for summarizing events and facts of interest from unformatted text into detailed database entries. Alembic can mix hand-coded heuristic rules with machine-learned rules to extract relevant facts from texts. An environment is thus constructed in which a human can have his or her knowledge of a domain transferred quickly and effectively into the form of training data and extraction heuristics by the cooperative activity of machine learning and evaluative feedback to the user.
The features of AWB include:

a GUI to most of the text processing facilities including tagging of sentences, punctuation, dates, parts of speech, positions, titles, honorifics, named-entity phrases and user-defined phrases;

full interactive display, editing and authoring of tag-preferences files;

specialized support for adding COREF coreference annotations;

an MUC6 official scorer utility;

user-controlled colorization of a raw SGML file;

a display/edit window for Alembic Phrase Rules;

interactively selecting a language from a highly organized listing;

user-defined colorization and editing of arbitrary annotations;

displaying inter-annotator agreement or disagreement graphically in a text window;

a find-text utility;

auto-tags for applying a given tag to any other matching text;

automatic generation of SGML tags to be scored by the Workbench scorer; and

support for interactively tagging n-ary relations.

Binary distributions are available for a selection of platforms including Linux Intel. The documentation is a bit sparse at present (5/99).
[http://www.mitre.org/technology/alembic-workbench/]
ALF: A language combining both functional and logic programming techniques. The basis of ALF is Horn clause logic with equality consisting of predicates and Horn clauses for logic programming and functions and equations for functional programming. The integration of the two paradigms allows any functional expression to be used in a goal literal and arbitrary predicates to occur in conditions of equations. The operational semantics are based on the resolution rule to solve literals and narrowing to evaluate functional expressions.
The ALF system is an efficient implementation of the combination of resolution, narrowing, rewriting and rejection of the language. It is similar to PROLOG in that it uses a backtracking strategy corresponding to a depth-first search in the derivation tree. ALF programs are compiled into instructions for an abstract machine based on the Warren Abstract Machine (WAM) with several extensions for implementing narrowing and rewriting. Programs from this abstract machine are executed by an emulator written in C.
A source code distribution of ALF is available which has been successfully compiled and run on Linux Intel and Sun platforms. The compiler is written in PROLOG and the emulator for WAM programs in C. The SWI-Prolog implementation can be used to compile the ALF programs into WAM bytecode. A user's manual is available in DVI format.
[http://www-i2.informatik.rwth-aachen.de/~hanus/systems/ALF.html]
ALFPACK: A package of thirteen Fortran routines for computing both single and double precision normalized associated Legendre functions of the first kind. See Swarztrauber (1984).

[ftp://ftp.ucar.edu/dsl/lib/alfpack/]
Algae: A high-level interpreted language for numerical analysis that borrows ideas from languages like C, Matlab, and APL. It was developed because of a perceived need for a free, efficient, and versatile language capable of handling large problems.

Significant Algae features include:

speed that is generally (and often significantly) faster than Matlab, RLaB and Octave;

the capability of storing arrays in sparse form wherein only the nonzero elements and their locations are stored;

persistent labels for each dimension of a matrix or vector (i.e. a vector element can have a label such as `mojo rate' to distinguish it from the other 5000 elements);

scalars, vectors and arrays as distinct data types; and

a statistical profiling capability that can show, by file and line number, where the code spends most of its time.

Algae is distributed as source code and also in binary form for Linux ELF platforms. Other packages that aren't required but are quite helpful and will be used by the package if available are Gnuplot, BLAS (although the generic version is supplied with the package), LAPACK (with the generic version of this also supplied with the package), and the GNU Readline library. Algae will also recognize the proprietary Boeing BCSLIB package. The documentation is supplied in both HTML and Texinfo formats.
[http://www.eskimo.com/~ksh/algae/]
ALGOL: The ALGOrithmic Language whose first implementation (ALGOL 58) was created in 1958 after a meeting in Zurich of members of both the GAMM and ACM. The language definition was completely revised in 1960 which led to ALGOL 60, a language which provided easy programming of formulas, loops, conditionals, and excellent storage control. It was the first block structured languaged and also the first language whose syntax was defined using the Backus-Naur Format (BNF). A further revision of the language led to ALGOL 68 which was ``designed to communicate algorithms, to execute them efficiently on a variety of different computers, and to aid in teaching them to students.''

Several innovations were present in ALGOL 68 including:

a new level in language description with the semantics defined with mathematical precision as well as the syntax;

a format method for describing, constructing, and manipulating data types;

an abstract model for computation which could be applied across radically different processor designs;

user-definable operators; and

support for parallel programming with the parallel-clause and Dijkstra semaphores.

An interpreter for ALGOL-60 is available at the given URL, i.e. the Retrocomputing Museum. See Lindsey (1993).
[http://www.tuxedo.org/~esr/retro/]
[http://www.cs.monash.edu.au/~lloyd/tildeProgLang/]
ALGON: A package of C macros for developing genetic algorithms (GA). ALGON includes a variety of classical GA operators and strategies as well as structures and genetic operators to handle non-binary strings, variable length chromosomes, and vectors of chromosomes. It also has a graphic interface for setting parameters and visualizing the evoluation of a GA.

A source code distribution of ALGON is available. It is written in C and documented in a user's guide available in PostScript format.
[http://www-syntim.inria.fr/fractales/Demo/Evelyne/README.html]
Alien: A program that converts between RedHat RPM, Debian dpkg, Stampede SLP, and Slackware TGZ file formats. It is recommended that Alien not be used to replace important system packages like sysvinit or shared libraries. Rather, it is meant for converting add-on software packages whose presence is not critical for system operation. Alien is written in Perl 5.
[http://kitenet.net/programs/alien/]
Alki: This was the name of the Algae package before circa 2/97.
Allegro: A game programming library containing functions for use in creating computer games. It is written for the DJGPP compiler in C and assembly and has cross-platform support for DOS, Windows and Linux. The features include:

support for VGA mode 13h, mode-X and SVGA modes with 8, 15, 16, 24 and 32 bit color depths (taking full advantage of VBE 2.0 linear framebuffers and the VBE/AF hardware accelerator API if available);

a boatload of drawing functions including putpixel, getpixel, lines, rectangles, polygons (flat shaded, gouraud shaded and texture mapped), circles, floodfill, bezier splines, etc.;

hardware scrolling, mode-X split screens and palette manipulation;

an FLI/FLC animation player;

playing background MIDI music and up to 64 simultaneous sound effects as well as recording sample waveforms and MIDI input;

access to the mouse, keyboard, joystick, and high-resolution timer interrupts (including a vertical retrace interrupt simulator);

routines for reading and writing LZSS compressed files;

multi-object data files and a grabber utility;

math functions including fixed-point arithmetic, look-up table trig functions, and 3-D vector/matrix manipulation; and

a GUI dialog manager and file selector.

In addition to the standard library, dozens of add-on packages have been written for Allegro including:

ALEX, image fading and tiled map routines;

DEGUI, C++ wrappers for the GUI objects plus several new 3D-look object types and a GUI builder program;

ACE, a port of Allegro to the Eiffel language;

MikAlleg, a version of MikMod that works with Allegro;

ANIM_RLE, a sprite animation library and an animation editor;

AllegroPak, additional functionality including Z-buffered polygon rendering, masked lit poly drawing mode, 3-D sprite plotting, lighting calculations, 3-D sphere rendering, fog shading and 3-D polygon clipping;

BRFONT, text rendering routines supporting antialiasing, color gradients, TrueType, Unicode, etc.;

GBM, a generalized bitmap module that handles many image file formats;

SALAD, a veritable plethora of add-on functionality;

JAWS, a game windowing system;

SeeR, a multipurpose C-like scripting engine.

[http://sunsite.auc.dk/allegro/]
Allegro CL: An uncrippled and free version of Allegro Common Lisp is available for Linux Intel on CD-ROM from Franz Inc. The free release license stipulates that it cannot be used for commercial purposes, i.e. to build money-making applications, although a commercial license for the Linux distribution is available for a price. The free distribution does not include support or add-on products such as CLIM or Composer, although these are also available for a price. The CD-ROM is available via an interactive forms interface at the Franz site.

[http://www.franz.com/]
ALLIANCE: A CAD package and simulator for teaching digital VLSI design. ALLIANCE was designed to meet the needs of both experienced and novice designers, the former by providing practical answers to state of the art problems (e.g. logic synthesis, procedural generation, layout verification, etc.) and the latter by providing a simple and consistent set of tools. It consists of both advanced CAD tools (for such things as functional abstraction and static timing analysis) and standard design and validation tools.

The ALLIANCE package consists of tools and layout libraries, all of which are designed to smoothly interoperate. The tools include:

asimut, a VHDL logic simulator which allows both structural and behavioral data flow description;

genpat, a language interpreter dedicated to the efficient description of simulation stimuli;

bop, a logic optimizer and logic synthesis tool;

scmap, a logic synthesis tool which outputs a netlist of gates;

c4map, a logic synthesis tool which runs without a predefined standard-cell library (as is required by scmap);

syf, a finite state machine synthesizer;

glop, a gate level netlist optimizer;

genlib, a procedural language for netlist capture and placement description;

genview, a debugging tool for the development of the layout view of parameterized generators;

fpgen, a language with the same functionality as genlib but which is dedicated to datapath description;

scr, a place and route tool for standard--cells;

Dpr, a place and route tool for bit-slice oriented datapaths;

bbr, a gridless channel router that allows the routing together of two blocks having different topologies;

Ring, a specific router dedicated to the final routing of chip core and input/output pads;

S2r, a tool used in design flow to perform process mapping;

druc, a design rule checker;

Lynx, a layout extractor which outputs an extracted netlist with parasitic capacitances;

Lvx, a logical versus extracted net comparison tool;

yagle, a functional abstractor adn disassembler for CMOS circuits;

tas, a static timing analyzer;

proof, which performs a formal comparison between two dataflow VHDL descriptions that share the same register set;

graal, a hierarchical symbolic layout editor; and

L2p, which creates a PostScript file from a symbolic or real layout.

The ALLIANCE libraries can be divided into four categories:

sclib, the standard cell library containing boolean functions, buffers, flip-flops and about 70 other kinds of cells;

two kinds of datapath libraries: dplib, containing cells dedicated to high density datapaths and fplib, containing a set of 30 regular functions usef in the design of a datapath;

custom libraries including a generic ROM generator called grog and a RAM generator called rage; and

a pad library which uses a symbolic layout approach.

A source code distribution of ALLIANCE is available as are binaries for Sun SunOS and Solaris and Linux Intel platforms. Documentation is contained within several PostScript files as well as in a large collection of man pages.
[http://www-asim.lip6.fr/alliance/]
[file://ftp.ibp.fr/ibp/softs/masi/alliance/]
Allpha: Computes various multifractal spectral of 1D and 2D signals. Available in binary form for Sun, DEC (Mips and Alpha), and Linux systems.

[http://www-syntim.inria.fr/fractales/Software/Allpha.html]
Alma: A software engineering package whose functionality includes:

reading several types of sources (e.g. languages, models, etc.);

aiding in the design of object-oriented features such as class definitions, relations, patterns, etc.;

modifying the structure and the code; and

generating new sources, documentation and diagrams.

The languages Alma can currently (10/99) read include Java, Fortran 77, IDL and MDL, with planned support for BDL (Beans Description Language), C, C++ and XMI (XML Metadata Interchange). Alma can generate source code in several formats including Java, C, C++, BDL, Delphi (Object Pascal), Eiffel, IDL, ODMG ODL, SQL, Lisp, HTML documentation, and UML (only inheriting and relation diagrams).
A source code distribution is available under the GPL version 2. A sketchy user's manual is available.
[http://www.memoire.com/guillaume-desnoix/alma/index-en.html]
ALP: A C++ class library for scientific computing with an emphasis on linear and polynomial algebra. The goal of ALP is to provide a framework for symbolic and numeric computations. It contains classes of vectors, matrices, monomials, polynomials and algorithms for solving equations, and includes the capability of using several external, specialized libraries, e.g. UMFPACK, LAPACK, GMP, MPSolve and SuperLU.
[http://www-sop.inria.fr/saga/mourrain/ALP/]
Alpha Shapes: A package which reconstructs surface and volume shapes for a given point cloud based on efficient, discrete mathematics which determine exact relationships between points, shapes, and spaces. An alpha shape is a concrete geometric object which is uniquely defined. It is a generalization of the convex hull concept. The alpha shape of a finite point set S and a real parameter alpha is a polytope which is neither necessarily convex nor necessarily connected. The family of all real numbers alpha leads to a family of shapes ranging from crude to fine shapes of the point set which, for sufficiently large alpha, is identical to the convex hull of S. Decreasing alpha at this point leads the the shape shrinking, developing cavities and tunnels, and eventually vanishing at sufficiently small alpha.

The Alpha Shapes distribution consists of four programs:

Delcx, which computes Delaunay complexes of weighted 3-D point sets employing a variant of the randomized incremental flip algorithm;

Mkalf, which makes the alpha shape file and data structure;

Alvis, a 3-D alpha shape visualizer consisting of a main viewing window, a scene panel, and a signature panel (the latter two allowing several types of manipulations of the displayed object and supplying various information about it); and

Volbl, which measures the union of spherical balls and is aimed at computational biology applications, e.g. modeling molecules.

The Alpha Shapes package is available in binary format for IBM AIX, HP-UX, SGI IRIX, Linux Intel, DEC Alpha, and Sun SunOS platforms. An online HTML format user's guide is available as are several technical papers in PostScript format. See Edelsbrunner and Mucke (1994).
[http://www.alphashapes.org/alpha/]
alphaWorks: Several Java software packages from the folks at IBM Research. These usually alpha and beta releases are freely available for non-commercial uses until they decide to turn them into commercial products or (preferably) make them Open Source packages. The available packages include:

Attachlet, a socksified server that bridges clients or applets from a Web server inside a SOCKS firewall to external servers or hosts;

Bean Markup Language, an XML-based component configuration or wiring language customized for the JavaBean component model;

Beanery, a tool for creating JavaBeans;

BeanExtender, for building and enhancing JavaBeans components;

Bidi, a styled text editor support multiple languages;

Big Decimal, an implementation of decimal floating point arithmetic for Java;

Bojangles, a tool for building Java-based distributed network applications;

CViz, for analyzing high-dimensional data in large, complex data sets;

DataCraft, provides an XML view of databases and enables publishing XML forms to the Web;

Dynamic XML, a processor for seamlessly embedding Java with XML;

eNetwork, an LDAP V3 service provider that plugs into the Sun JNDI directory and naming framework;

International Calendars, Java calendars and data formats for the Buddhist, Hebrew, Islamic and Japanese calendars;

Internet Sales Predictor, an online data mining/reporting tool for shopping basket analysis;

IRC Client, a Java-based IRC client;

JAX, an application packaging tool that reduces the size of a Java application;

Jikes, a faster Java compiler that adheres to Java language and virtual machine specifications;

Jikes Debugger, a multi-paneled graphical debugger for inspecting the current state of a remotely executing Java program;

LotusXSL, an implementation of the construction rules section of the W3C XSL working draft;

MediaBeans, a modular component framework for multimedia applications;

PatML, a rule-based pattern match/replace Java processor for XML;

RDF for XML, an implementation of the RDF specification for creating technologies that search for data and mangle it in various ways;

Remote AWT, an AWT implementation that allows applications to run unchanged in a client/server mode;

Rioja, a record-oriented Java input/output class library;

RuleBasedBreakIterator, a class that analyzes text for boundaries between parts;

RuleBasedNumberFormat, a language for describing how a number is going to be formatted;

ShakingHands, for building online collaboration applications that can be run from any Java client;

Shared Data Objects, a framework for developing networked, interactive applications;

Skij, an interactive scripting language for rapid prototyping in the Java environment;

SNA for Java, for running applets over SNA networks;

StringSearch, a fast, Unicode-aware, locale-sensitive string searching class;

TeXML, provides a path from XML to TeX;

TSpaces, a set of network communication buffers, APIs and classes that allow heterogeneous Java-enabled devices to exchange data;

XML Beanmaker, automatically generates JavaBean classes for an arbitrary schema for an XML instance;

XML Editormaker, takes an XML schema and automatically generates visual editors for building XML documents;

XML Enabler, a servlet for implementing stylesheets such as the LotusXSL technology;

XML Parser, a parser for XML written in pure Java;

XML Productivity Kit, a collection of tools and protocols for enabling simple yet advanced XML applications; and

XML TreeDiff, a package of beans that provide the ability to efficiently differentiate and update DOM trees.

[http://www.alphaWorks.ibm.com/]
ALSA: The Advanced Linux Sound Architecture is a project whose goals are to:

create a fully modularized sound driver which will support kerneld/kmod;

create an ALSA Kernel API to surpass most of the limitations of the current (5/98) OSS API;

ensure compatibility with most binary OSS/Lite applications;

create an ALSA Library (C,C++) which covers the ALSA Kernel API for applications; and

create ALSA Manager, an interactive configuration program for the driver.

The project is currently (5/98) looking for programmers to port low-level drivers and to work on the Kernel and Library. Currently supported are all Gravis UltraSound cards and SoundBlaster (and most clones thereof) cards. A list of supported native and OSS-compatible applications will eventually be made available at the site.
The planned kernel structure for ALSA consists of:

Information Interface (/dev/sndinfo)

Detection Interface (/dev/snddetect)

Mixer (/dev/sndmixerXX)

PCM (Digital Audio) (/dev/sndpcmXX)

Sequenced Programmable Synthesizer (/dev/sndsynthXX)

Instrument Server Interface (/dev/sndserverX)

Raw MIDI (/dev/sndmidiXX)

Sequenced MIDI (/dev/sndmidiX)

Raw FM/OPL3 (/dev/sndfmX)

[http://alsa.jcu.cz/]

AlsaPlayer

A PCM (pulse code modulation) player that is threaded and uses the ALSA sound library. The features include:

full speed (pitch) positive and negative control;

concurrent visual scopes;

a multi-threaded design for efficient and skip-free playback;

a GUI interface based on GTK+;

command line operation for shell scripts;

a plug-in core architecture;

a low latency mode (as low as 5 ms);

queuing and playlists;

an effects stream;

software-based volume and pan controls;

works with concurrent audio tools (without a hardware mixer); and

accurate scope/audio syncing using ALSA.

[http://www.alsa-project.org/~andy/]
Amanda: The Advanced Maryland Automatic Network Disk Archiver is a backup system designed to archive many computers on a network to a single large-capacity tape drive. Amanda requires a tape server host with a large capacity tape drive that is mostly idle when backups are being performed. It works best with one or more large holding disk partitions on the server host where it can buffer dumps before writing to tape, although it doesn't need such partitions.

The features of Amanda include:

it's built on top of standard UNIX software such as dump/restore and tar;

backing up multiple machines in parallel to a holding disk, sending finished dumps one by one to tape as fast as possible;

simple tape management, e.g. it won't overwrite the wrong tape;

support for tape changers via a generic interface that is easily customized for most hardware;

support for Kerberos 4 security including encrypted dumps;

on restoration it tells you what tape(s) you need and finds the correct backup image(s) on them;

graceful recovery from errors;

results reports (including detailed error messages) via email;

dynamical adjustment of backup schedules to keep within constraints;

a pre-run checker program that conducts sanity checks on the tape server host and all client hosts;

compression of dumps before or after sending via the net;

optional synchronization with external backups; and

very high configurability.

A source code distribution of Amanda is available. It is written in C and has been ported to most UNIX platforms including Linux Intel. Documentation is included in the source distribution and includes a FAQ, a technical report, and a user's manual.
[http://www.cs.umd.edu/projects/amanda/]
AMAPI: A 3-D modeler with a wide range of capabilities for constructing, modeling and assembling 3-D scenes. The tools are collected into three palettes. The first is a construction tools palette containing:

primitive shapes, e.g. cones, cyclinders, spheres, etc.;

a tool for drawing 3-D lines of various types;

a text tool;

a curve extractor to create a new curve object through points selected on existing objects;

a surface extractor to create faces from existing curves;

an extrusion tool;

sweeping and double sweeping tools;

a hull surface tool for creating a surface defined by up to N curves, each sharing at least one point with another; and

a ruled surface tool for creating surface meshes from sets of curves.

The modeling tools palette contains:

metanurbs and molding tools for distorting objects;

bending and stretching tools;

tools to delete, filet, smooth and change the thickness of objects; and

boolean and punch tools.

The assembling tools palette includes tools for duplicating, 3-D mirroring, rotating, moving, proportionally scaling, snapping, laying on, welding and unfolding objects.
A control panel allows you to group and ungroup as well as show and hide objects. It also allows zooming in and out, making faces hidden or visible, changing viewpoint and measuring objects. It includes a textures editor and a scene manager for managing the scene hierarchies, e.g. selecting objects by layers, textures or groups.
Binary versions of AMAPI are available in both English and French. Documentation can be found via search engines.
[http://metalab.unc.edu/pub/Linux/apps/graphics/modeling/]
[http://perso.club-internet.fr/odrion/tutorim/eindex3.htm]
[http://staigerland.com/amapi/tutor3.0/onlinetutorial.html]
[http://www.fignations.com/resources/amp.html]
Amaya: The test-bed browser and authoring tool used by W3C to demonstrate and test many of its new developments. Amaya is a complete web browsing and authoring environment with a WYSIWYG interface and many useful features include:

integration of editing and browsing functions in a single seamless tool;

a consistent internal document model that adheres to the DTD;

simultaneously browsing and/or editing several documents;

assistance with creating hypertext links;

several APIs and mechanisms for changing or extending the functionality with minimal source code changes;

use of HTTP 1.1 to access remote sites;

image display via the PNG format;

a GCM plug-in for viewing vector graphics;

support for CSS1;

a prototype implementation of MathML for browsing and editing pages containing mathematical expressions; and

generation of PostScript files for viewing or printing.

Amaya is designed as an application on top of the Thot toolkit, a set of libraries implementing document manipulation functions. This allows it to handle documents in a structured way that clearly separates content, structure and presentation. Internally, Thot represents documents as a tree that assembles typed elements such as headings, paragraphs and lists. Four languages are used to write four types of schemas or sets of rules defining the behavior of the editor regarding the logical structure of the documents, their presentation, their external syntax, or specific treatments. The Thot library provides an API for handling all entities and objects comprising a document and its environment. It includes functions for creating, modifying, deleting, opening, accessing, finding and moving such things as documents, logical structures, elements, attributes, links and views.
Both source and binary distributions of Amaya are available, with the latter available for many platforms including Linux Intel. Compilation requires both the Amaya and Thot source distributions as well as Motif (although version 0.8.0 or greater of Lesstif is reported to work as well). This was formerly known as Tamaya.
[http://www.w3.org/pub/WWW/Amaya/]
[http://sunsite.unc.edu/pub/Linux/apps/www/browsers/amaya/]
AMC: A compiler that adds module and object-oriented functionality to C. This is currently (6/98) in the early alpha stage of development.
[http://www.freeyellow.com/members7/mygfya/amc/]
AMD: The AutoMount Daemon maintains a cache of mounted file systems. It was developed to make up for some shortcomings in the current standard Network File System (NFS). It operates by mimicking an NFS server, i.e. when a file is accessed AMD uses its map to decide where the file resides, mounts that partition, if necessary, using regular NFS, and then mimics a symlink to the actual location. AMD keeps track of which machines are down and/or inaccessible. It also doesn't mount every partition immediately or keep them mounted (as does NFS) and thus saves overhead on a system. It also uses dynamic maps that can change depending on any number of criteria, e.g. if you have replicated servers you can set up a map so that if one server goes down AMD will automatically mount files using one of the others.

The AMD package includes the source code, written in C, and a user's manual in PostScript format. The given URL is that of the AMD home site. A Linux patch for AMD is available which can be applied to the source code to ease compilation. An article describing how to use AMD can be found in the March 1997 issue of the Linux Journal. See Crosby (1997). This has been superseded by am-utils.
[http://www.cs.columbia.edu/~ezk/am-utils/]
AME: A Modelling Environment is a tool for building and running simulation models in ecology, forestry, agriculture and environmental science. AME contains a powerful diagrammatic language for designing models that includes both system dynamics and object-oriented concepts as well as supporting modular model construction. The resulting models are compiled into C programs for efficiency.
AME models are created via a GUI in which models are displayed as a group of compartments (or reservoirs) connected by flows (or fluxes). Flow rates are determined by control valves (or bowties). A special equation language is used to specify the mathematical properties of individual components and their connections. These components are grouped into submodels which can be treated as independent models linked into parent models via influences in either direction. This system dynamics or compartment-flow paradigm allows arbitrarily complex models of real systems to be quickly and easily constructed. The GUI is constructed using Tcl/Tk and allows the various components to be selected, moved and modified via a few mouse clicks.
A source code distribution of the AME package is available. It is written in C and Tcl/Tk, requiring versions 8.0p2 of the latter. Documentation includes several tutorials, a user's guide, several example models, and various technical publications.
[http://helios.bto.ed.ac.uk/ierm/ame/]
Amira: A system for producing visualizations of scalar and vector fields as encountered in various science and engineering disciplines. Objects are modeled as grids suitable for numerical simulations, notably as triangular surfaces and volumetric tetrahedral grids. Methods are provided to generate such grids from voxel data representing an image volume. A general purpose interactive 3-D viewer is also included. Amira is a modular and object-oriented system in which basic system components like data objects, display modules and computational modules are represented by icons in a special network area of the GUI. The icons are connected by lines indicating dependencies between components, allowing networks to be created with a minimal amount of interaction. Over 25 data objects and 100 modules from various application areas are currently (3/99) available.
The capabilities of Amira include:

visualization of 3-D image data from, e.g. CT, MRI or confocal microscopy;

interactive segmentation of such data;

generation of 3-D surface and tetrahedral models;

surface simplification and editing;

computation of isosurfaces and direct volume rendering;

algorithms for advanced vector field visualization;

support for curvilinear and unstructured tetrahedral grids;

a GUI built using X11, Motif and ViewKit;

3-D graphics implemented using Open Inventor and OpenGL; and

scripting capabilities via a Tcl command interface.

Amira versions are available for SGI, HP and Linux systems, with the first two using fast hardware-accelerated OpenGL graphics. The Linux port performs the same operations much more slowly in software. It requires an X server resolution of 1024x768, at least 16-bit color depth, and a glibc-based system. A PII 350 MHz system is also recommended to compensate for the lack of hardware graphics support. An extensive user's manual is available in PostScript and HTML formats.
[http://amira.zib.de]
AmiWM: A window manager which attempts to make your visual interface look and feel like that of the Amiga Workbench screen.

[http://www.lysator.liu.se/~marcus/amiwm.html]
AML: The Astronmical Markup Language is an XML language designed to be a standard exchange format for metadata in astronomy. The DTD is separated into seven parts for describing different types of information:

Metadata, a part included in all AML files while usually consist of this and one or more of the other six parts;

Astronomical object, describes information about astronomical objects;

Article, describes information about an article;

Table, includes metadata for a table and a link to the content of the table;

Set of tables, a list of tables linked together with information about the set (also called a catalog);

Image, information about an image with a link to it; and

Person, information about a person, usually the author of an article.

[http://strule.cs.qub.ac.uk/~damieng/these/]
AMMP: A program for molecular mechanics, dynamics and modeling. AMMP can manipulate both small molecules and macromolecules including proteins, nucleic acids and other polymers. It has a simple yet powerful ability to manipulate molecules and analyze individual energy terms. An advantage over similar programs is the easy introduction of non-standard polymer linkages, unusual ligands, or non-standard residues. For example, adding missing hydrogen atoms and completing partial structures are straightforward in AMMP.
The features and functionality of AMMP include:

fast, long-range electrostatics and bounded terms;

stable and numerically accurate molecular dynamics;

a flexible choice of potential functions with the standard formulations as well as non-point charges, explicit Debye screening, accurate polarization modles, non-harmonic bond and angle formulations, and coupled bond-angle terms;

calculation of partial charges for new molecules;

embedding and homotopy methods for rapid model building;

parallelization available using PVM; and

usable in either self-contained or embeddable modes.

Source and binary distributions are available under the GPL. Binaries are available for Linux, SGI and Win32 platforms. Various documention is available in various forms.
[http://asterix.jci.tju.edu/ammp.html]
Amoeba: A general purpose distributed operating system designed to take a collection of machines and make them act together as a single integrated system. An Amoeba system looks like a single time-sharing system to the casual user. This is an ongong research project and should be thought of as a platform for doing research and development in distributed and parallel systems, languages, protocols and applications. It is intended for both distributed and parallel computing, providing the necessary mechanisms for doing both. As a distributed system it uses the high performance FLIP network protocol for LAN communication, and all the processors can be used in parallel for solve a single problem if desired.

Amoeba was designed with a microkernel architecture wherein every machine in the system runs a small, identical kernel supporting basic processes, communication, object primitives, raw I/O, and memory management. The system thus consists of a collection of independent process, of which some are clients running application programs and others are servers, e.g. a file or directory server. Amoeba kernels also have threads and use the RPC mechanism for interprocess communication. Software outside the kernel includes:

a high performance file server;

a directory server;

compilers for C, Pascal, Modula 2, BASIC, and Fortran 77 (with appropriate libraries for each);

a parallel programming language called Orca;

a large number of utilities modeled after standard UNIX utilities;

a UNIX emulation library called Ajax offering POSIX compatibility;

TCP/IP networking; and

an X11R6 interface.

Amoeba will run on Sun 4c and MicroSPARC SPARCstations, Intel *86 processor machines, 68030 VME-bus boards, and Sun 3/60 and 3/50 workstations. Over 1000 pages of documentation are available including a collection of published papers, a user's guide, a programmer's guide, a sysadmin guide, and release notes. It is freely available via FTP for educational and research work, although you must register to obtain and FTP login name and password. Okay, it's not Linux, but it sounds pretty interesting nonetheless so I bent to rules just a wee bit to include this entry. See Kaashoek et al. (1993) and Tanenbaum (1995).
[http://www.cs.vu.nl/pub/amoeba/]
[http://www.cs.vu.nl/pub/amoeba/amoeba5.3/]
AMoRE: Automata Monoids and Regular Expressions is a library of automata theoretic algorithms. The functionality includes:

conversion of regular expressions into finite automata;

determination and minimization of automata including a heuristic minimization of nondeterministic automata;

language operations, e.g. boolean and regular operations, quotients, and shuffle products;

tests for set inclusion and nonemptiness;

computation of the syntactic monoid and its algebraic decomposition; and

display of small automaton graphs.

A source code distribution of this C package is freely available for non-commercial uses. It is documented in an extensive technical report available in PostScript format.
[http://www.informatik.uni-kiel.de/inf/Thomas/amore.html]
AMOSLIB: A collection of portable Fortran 77 routines for the evaluation of some special functions of mathematical physics. The contents of the library are:

[D]PSIXN, a routine for calculating the derivative of the log gamma function;

[D]PSIFN, a routine which computes derivatives of the psi function.

[D]EXINT, a routine for computing exponential integrals;

BESY, a routine which implements forward recursion on the three-term recursion relation for a sequence of non-negative order Bessel functions; and

DBESJ, a routine which computes an N member sequence of J Bessel functions.

All of the AMOSLIB routines are available as Fortran source code. All documentation is contained within each subroutine in the form of comment statements. This is part of CMLIB. See Amos (1980), Amos (1983), and Amos et al. (1977).
[http://sunsite.doc.ic.ac.uk/public/computing/general/statlib/cmlib/]
[http://www.netlib.org/amos/index.html]
AMPL: A Mathematical Programming Language is a language and system for formulating, solving, and helping understand mathematical programming problems, i.e. minimizing or maximizing a function subject to constraints. AMPL lets you use common notation and familiar concepts to formulate optimization models and examine solutions while the computer manages communication with an appropriate solver. The features of the language include:

broad support for sets and set operators;

use of general and natural syntax for arithmetic, logical, and conditional expressions as well as familiar convections for summations and other iterated operators;

nonlinear programming features such as initial primal and dual values, user-defined functions, fast automatic differentiation, and automatic elimination of defined variables; and

convenient alternative notations including node and arc declarations for network problems, a special syntax for piecewise-linear functions, and columnwise specification of linear coefficients.

The AMPL environment is an interactive command environment with batch processing options and display commands to let the user view any model component or expressions - browsing on-screen or writing to a file - using automatic formatting or user-specified preferences. The environment also maintains a separation between model and data, with models remaining concise even as sets and data tables grow rapidly. Interfaces to several popular and sophisticated solvers are provided.
A student edition of AMPL in the form of a binary is available for several platforms including Linux Intel. It is limited to 300 variables and 300 constraints but full-featured in all other respects. An unlimited commercial versions is available. The system is fully documented in Fourer et al. (1993). The Netlib site also contains a library of routines called ampsolver.a that help solvers work with AMPL. This library provides such services as reading AMPL's generic output files and writing solution files. This library is written in ANSI C and can be compiled and used on most platforms.
[http://www.netlib.org/ampl/]
[http://www.ampl.com/]
AmrPoisson: A C++ package for solving Poisson's equation using multigrid relaxation and adaptive mesh refinement (AMR). Grid refinement can be handled by a predefined grid hierarchy or automatically using a method based on either Richard extrapolation or a user-supplied criterion.
The classes in AmrPoisson include:

AMRPoisson, which manages the grid hierarchy and composite solution procedure;

CLUSTER, a grid generation auxiliary class;

CoordSys, which sets up and manages the coordinate system;

FluxRegister, used to enforce flux-matching and conservation at coarse-fine interfaces;

GridGenerator, which constructs the AMR grid hierarchy;

LevelFlux, which contains edge-centered flux-type variables;

LevelMG, a multigrid solver on a level;

LevelOp, which handles the gory details for a basic elliptic solver;

LevelPoisson, which manages data and operations on a level; and

TAGBOX, a class for maintaining tagged cells for regridding.

A source code distribution of AmrPoisson is available. It is written in C++ and requires the BoxLib library for compilation and use. The Amrvis package can be used to view the results of simulations. A user's guide is included in the distribution. See Bell et al. (1994).
[http://barkley.ME.berkeley.edu/~martin/AMRPoisson.html]
Amrvis: A visualization and data analysis tool for examining data files generated by Adaptive Mesh Refinement (AMR) algorithms. A user can view color planar images of the data, AMR grid regions, data values in chosen format, subregions, animations, volumetric renderings, and output files in several formats including PostScript. Amrvis allows the user to zoom in on subregions of data where the mesh has been refined as well as animate time sequences of AMR data. It works for both 2- and 3-D data and requires no special graphics hardware. Most general visualization tools do not understand AMR data formats, making Amrvis a required tool for such related packages as HAMR, VarDen, and AnrPoisson.
A source code distribution of Amrvis is available. It is written in C++ and requires the BoxLib library for compilation and use. It is documented in a user's guide included in the distribution.
[http://SEESAR.LBL.GOV/ccse/software/software.html]
AMS: The ALICE Memory Snooper is an API designed for writing computational steering, monitoring and debugging tools. It is a client/server, multithreaded API that supports parallel applications via MPI. AMS is useful for developing and maintaining large software systems. The motivation of AMS is to let users connect to running applications and access or modify variables (memory) within. The components of AMS include:

a portable communication library that uses TCP/IP;

a C language API;

general purpose C, Java GUI and Matlab monitoring clients.

[http://www-fp.mcs.anl.gov/ams/]
Amulet: A user interface development environment containing a comprehensive set of tools that make it significantly easier to design and implement highly interactive, graphical, direct manipulation user interfaces. These applications will run without modification on both UNIX and PC platforms. At present Amulet provides a low-level toolkit layer, an object-oriented, constraint-based graphical system that allows properties of graphical objects to be specified in a simple, declarative manner, and then maintained automatically by the system. A higher-level tool is in the works which will allow interfaces to be developed without programming.

The features of Amulet include:

a dynamic, prototype-instance object system that makes prototyping easier,

constraints integrated with the object system,

a machine-independent graphics system,

a high-level object-oriented output graphics model that handles automatic refresh of objects when they change,

a high-level input model that makes it easy to add behaviors to objects and supports undo and help for operations, and

a set of flexible widgets including buttons, check boxes, radio buttons, menus, menu bars, scroll bars, scrolling windows, and text input fields.

The source code for UNIX or PC platforms is available as is a 200+ page user manual and tutorial in PostScript format. Amulet should compile and install on generic UNIX platforms using the gcc 2.7.0 along with libg++, and there is a separate makefile script for Linux platforms. It requires Visual C++ for installation on PC platforms. This is the successor to the Garnet project.
[http://www.cs.cmu.edu/afs/cs/project/amulet/www/amulet-home.html]
am-utils: A package including an automounter and a set of utilities for performing various related tasks. An automounter maintains a cache of mounted filesystems which are mounted on demand when they are first referenced and unmounted after a period of inactivity. The choice of which filesystem is to be mounted can be dynamically controlled via so-called ``selectors.'' These allow decisions of the form ``hostname is this'' or ``architecture is not that'' to be made. Several filesystem types are supported including NFS and UFS.
The am-utils package consists of three major and several utility programs. The major programs are:

amd, the daemon that performs that mounting and unmounting of the various filesystems;

fsinfo, a filesystem management tool designed to help sysadmins keep track of a possibly very large number of filesystem namespaces; and

hlfsd, a daemon that implements a filesystem containing a symbolic link to a subdirectory within a user's home directory for redirecting incoming mail to user's home directories.

The am-utils utility programs include:

am-eject, unmounts a floppy or CD-ROM that is automounted and then attempts to eject the removable device;

amd2ldif, converts amd maps to LDAP input files;

amd2sun, converts amd maps to Sun Automounter maps;

ctl-amd, for starting, stopping and restarting amd;

ctl-hlfsd, for controlling hlfsd;

expn, expands email addresses into their full name;

fix-amd-map, converts older amd maps to new ones;

fixmount, for deleting bogus mount entries in remote mountd deamons;

fixrmtab, for invalidating /etc/rmtab entries for hosts named;

lostaltmail, for resending lost mail;

mk-and-map, converts normal amd map files into an ndbm database;

pawd, for printing the current working directory adjusted to reflect proper paths that can be reused to go through the automounter for the shortest possible path;

wait4amd, for waiting for amd on a particular host before performing an arbitrary command; and

wire-test, tests if the basic networking functions in the am-util library work.

A source code distribution of am-utils is available which is supported on nearly every UNIX OS/architecture combination available. An extensive user's manual is available in HTML and PostScript format. The is a replacement for the older AMD package.
[http://www.cs.columbia.edu/~ezk/am-utils/]

Next: An-Az Up: Linux Software Encyclopedia Previous: Categories Contents

Manbreaker Crag 2001-03-08