Up: Linux Software Encyclopedia
Last checked or modified: June 8, 1999
[ home /
- 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:
The system is written entirely in Perl 5.
- 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.
- A spreadsheet which, while currently
(9/98) in alpha test stage, includes such useful functionality as:
A source code distribution of Abacus is available. It is
written in C/C++ and Tcl/Tk 8.0.
- 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 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.
- An interactive
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
- 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
- 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
- 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
id3 and to a choice of MP3 encoders
(although it defaults to lame).
- 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
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
CMUCL, CLISP, and
See Yonezawa (1990).
- 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
for MusicTeX or
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.
- 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).
- 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.
- A spreadsheet that runs under X11.
The features of abs include:
Source code and binary distributions are available, with the latter
including a Linux Intel version.
- 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.
- 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.
- 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
- A server daemon that implements the ACAP
for the remote access of configuration and preference
A source code distribution is available.
- 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
- 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
- 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.
- 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
- 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.
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
A higher-level network programming
framework integrates and enhances the lower-level wrappers.
This framework contains several class categories including:
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.
- Reactor and Proactor, which support both reactive and proactive event
- 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
The ACE distribution is freely available and contains the source
code, tests, example applications, and documentation for
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.
- 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
- 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,
This used to exist and
be supported in two versions, a
Motif (xmgr) and an
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
- 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.
- 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.
- A Java-based interface to the
ACEDB database system. JADE is database
independent, portable, multithreaded and multiplatform.
- 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
Model checking is an automated verification technique that has
been successfully applied to the verification of large, industrial-size
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
- An IRC robot for helping to administer chaotic
The features of AcidBlood include:
A source code distribution of this C++
package is available.
- 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.
- 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:
This project is currently (10/99) in the beta stage and is available in
the form of a kernel patch.
- 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.
- 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
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.
- 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
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.
- 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.
- 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
The offerings include:
All are written in C and are documented in man pages.
- 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
- 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
- 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.
- 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.
- Acoustics software includes:
- Acoustics Toolbox, a collection of
several ocean acoustics models;
- COUPLE, a coupled mode acoustic propagation
- 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
- SUPERSNAP, a normal mode acoustic propagation
- 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
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
- 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
- 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
- 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
- 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.
- 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
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
The servers present data which originates from a distributed
control system in a tree-like structure comprised of
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:
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.
- 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
- An ACPLT/KS client library written
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.
- Acrobat Reader
- A package that can be used as either as a stand-alone
PDF viewer or a plug-in for
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
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.
- 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:
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
- 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.
- 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.
- 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
- 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
- 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
- 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
- Nexus, a portable library providing the
multithreading, communication and resource management capabilities needed
to implement advanced languages, libraries and applications in
- 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
- 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:
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.
- 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.
A source code distribution of ACUA is available.
This can be compiled on Linux and
Documentation is contained within the distribution.
- A language, probably more about which later.
- 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.
- 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,
All documentation is contained within the routine in comment statements.
This is part of 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
- 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
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
- 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
- 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
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).
- 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
See Bischof et al. (1992).
- 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.
- 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:
The ADLTS software is currently (5/99) in Phase 2 which improves upon
Phase 1 by enhancing the target languages and expanding to cover
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
- Assertion Definition Language (ADL);
- Test Data Description (TDD); and
- Natural Language Dictionary (NLD).
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.
- Architecture Description Languages are languages that
describe or represent software architectures.
Examples of ADLs include:
- 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
- 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
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
- 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
- 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.
- The GNU Asynchronous DNS client library
is a DNS resolver library for
programs. The features include:
A source code distribution is available under the
- 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
- 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.
- 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
format. There is also an
package for the automatic differentiation of
This is TOMS algorithm 755 and is documented
in Griewank et al. (1996).
- 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
- 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.
- 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.
- 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
- 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.
- 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
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
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).
- A software architecture design environment generator and
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.
- 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
- 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
- prioritizing file distribution; and
- setting up a network of AFDs that can be monitored and controlled via
a single interface.
- 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
The AFGL formalism consists of rules and metarules, with the latter
a collection of restricted context free rules forming the second level
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
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.
- An archiver/backup program that produces archives in cpio format.
- 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.
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
This is a subset of the libtsp package.
- 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
- 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
AfterStep features include:
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.
- 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 AfterStep Control Panel provides an intuitive
graphical front-end for configuring the
AfterStep window manager.
This is written in C and uses
- 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
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
- 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
- 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
- JAM, an agent system for forewarning financial
institutions of impending threats;
- JAT, a template for constructing software
- 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
- Knowbot, a Python
enviroment for developing and using mobile agents;
- KQML, a language and
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
and knowledge-based systems.
- 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
A source code distribution of AgentD is available. It is
currently (8/97) in the alpha test stage.
It is written in Objective-C.
- 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:
A source code distribution of AgentSpace is available.
It requires Voyager 1.0.1 and
JDK 1.1 or greater.
- 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
- 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.
- The name of this has been changed to
- The Agent eXtensibility
protocol specifies a method by
which subagents may advertise and export MIB regions via a single
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
A source code distribution of an AgentX SNMP daemon and the AgentX library
- 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
- 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
- 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
- mp3gate, a gateway to an MP3 compressor and/or
- 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.
- 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.
- 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
It presents an event-oriented programming model and supports state and
The functionality of AGNI includes:
- storing and instantiating tests from a central location, e.g. a
- 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.
- 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
- multiple pattern searching with AND or OR logic queries.
- A port of the functionality of agrep
- 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:
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
- VARIO, which computes values of the characteristic
- 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
- 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.
- 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
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
- 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:
Other modules are (3/00) in the planning stages.
- 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.
- 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
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:
A source code distribution is available which includes makefiles
for several platforms including Linux.
An extensive user's manual is available.
- 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
- pc, a utility for removing monitoring overhead and its effects
on the communication patterns as recorded in tracefiles;
- a tracefile animation and analysis toolkit.
- 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
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
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
See also 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
- 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
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
- 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
- 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;
- 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
- 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.
- A tool for 2-D visualization built in cooperation with the
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
- 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
The programs available include:
and several other related programs.
- 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
- 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
- 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;
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.
- 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
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,
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).
- Austin Kyoto Common Lisp is
a Common Lisp implementation which
is a collection of ports, bug fixes and improvements to the
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.
- 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
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
Large amounts of documentation are available online.
- 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
- facilities for physical quantity and
- SI and US units packages,
- a matrix solver package;
- programming constructs to control the solution
- 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).
- 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
The features include:
Binary distributions are available for Linux Intel and other platforms.
- 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.
- 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
- 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
See the ALCON-S entry for more details.
The program is documented via source code comment statements.
This is part of CodeLib.
- 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
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.
- 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
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
This is a better documented version of ALCON1 and
ALCON2 written in C.
This is part of CodeLib.
See Deuflhard et al. (1987a).
- 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
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.
- The Adaptable Layout Environment is a tool for
building interfaces for Java applications.
The functionality of ALE includes:
A source code distribution is freely available.
- 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.
- 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.
- 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
- full interactive display, editing and authoring of
- 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
- 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
- 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).
- A language combining both
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.
- A package of thirteen
for computing both single and double precision
normalized associated Legendre functions of the first kind.
See Swarztrauber (1984).
- A high-level interpreted language for numerical analysis that
borrows ideas from languages like C,
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,
- 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
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
- The ALGOrithmic Language whose first implementation
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
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
Several innovations were present in ALGOL 68 including:
An interpreter for ALGOL-60 is available at the given URL, i.e.
the Retrocomputing Museum.
See Lindsey (1993).
- 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
- 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
- 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.
- A program that converts between RedHat RPM,
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.
- This was the name of the
Algae package before circa 2/97.
- A game programming library containing functions for use in creating
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
- 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,
- GBM, a generalized bitmap module that handles many image file
- SALAD, a veritable plethora of add-on functionality;
- JAWS, a game windowing system;
- SeeR, a multipurpose C-like scripting engine.
- 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.
- 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
- 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
- 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
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.
- Computes various multifractal spectral of 1D and 2D signals.
Available in binary form for Sun, DEC (Mips and Alpha), and
- 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
Alma can generate source code in several formats including
BDL, Delphi (Object Pascal),
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.
- 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.
- 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
- Mkalf, which makes the alpha shape file and data
- 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.
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).
- 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
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
- CViz, for analyzing high-dimensional data in large, complex
- 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
- PatML, a rule-based pattern match/replace Java processor
- 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,
- 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
- 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
- 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.
- The Advanced Linux Sound Architecture is a project
whose goals are to:
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.
- create a fully modularized sound driver which will support
- 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
- create ALSA Manager, an interactive configuration program for the driver.
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)
- 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.
- 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
- 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
- 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.
- 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:
The assembling tools palette includes tools for duplicating, 3-D mirroring,
rotating, moving, proportionally scaling, snapping, laying on, welding
and unfolding objects.
- 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.
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.
- 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
- a consistent internal document model that adheres to the
- 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
This was formerly known as Tamaya.
- A compiler that adds module and object-oriented functionality to
C. This is currently (6/98) in the early alpha stage of development.
- 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
An article describing how to use AMD can be found in the
March 1997 issue of the
See Crosby (1997).
This has been superseded by am-utils.
- 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
Documentation includes several tutorials, a user's guide,
several example models, and various technical publications.
- 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
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
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
- 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
- scripting capabilities via a Tcl
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
An extensive user's manual is available in PostScript and HTML
- A window manager which attempts to make your visual interface look and
feel like that of the Amiga Workbench screen.
- 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
- 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
- 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
Binaries are available for Linux, SGI and Win32 platforms.
Various documention is available in various forms.
- 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,
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
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
- Automata Monoids and Regular Expressions is a library
of automata theoretic algorithms. The functionality includes:
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
- 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
- tests for set inclusion and nonemptiness;
- computation of the syntactic monoid and its algebraic decomposition; and
- display of small automaton graphs.
- 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).
- 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
The environment also maintains a separation between model and data,
with models remaining concise even as sets and data tables grow
Interfaces to several popular and sophisticated solvers are
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.
- 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
- 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).
- 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
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
Most general visualization tools do not understand AMR data
formats, making Amrvis a required tool for such related
packages as HAMR,
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
- 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.
- 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
- 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
- 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
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
- 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
- fixrmtab, for invalidating /etc/rmtab entries for hosts
- lostaltmail, for resending lost mail;
- mk-and-map, converts normal amd map files into an
- 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.
Up: Linux Software Encyclopedia