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;