Up: Linux Software Encyclopedia
Last checked or modified: Jan. 8, 2001
- The Systems Network Architecture is not strictly a protocol
or system but rather an architecture forming the basis for several
hardware and software products.
It was developed by IBM in the 1970s but has become a major
mainframe protocol on which a large number of other vendors have
based their products.
Presently there are two forms of SNA:
The differences between SNA and TCP/IP are so
significant that the two protocols can be said to be complementary.
One huge difference is that while the latter exchanges information
via individual packets the former is a stateful protocol wherein a
session must be established before a client and server can exchange
messages. Another involves TCP/IP being fairly simple while SNA
has been called ``astonishingly complex.''
- classic SNA, the original architecture for mainframes used for
host terminal communication; and
- APPN (Advanced Peer to Peer Networking), a newer version
based on networks of non-mainframe
computers which supports email and has a peer-to-peer architecture.
The programming interface for present-day (late 1990s) SNA networks
is the Common Programming Interface for Communications (CPIC)
which provides a common set of subroutines, services and return codes
for programs written in COBOL,
C or REXX.
IBM currently (12/98) has a Communications Blueprint under which
SNA is one of several interchangeable transport options and a peer
of TCP/IP. This Blueprint is realized in products that carry the
``Anynet'' title which allow CPIC programs to run over TCP/IP and
programs written using the UNIX socket interface to run over SNA
networks. Basically, SNA has characteristics needed by large corporations
whose network needs can't be satisfied by TCP/IP. Conversely, the
Internet couldn't have been built on top of SNA.
Source for information about SNA/APPN include:
- A project to develop a working SNA implementation
- The Sample Neufeld ASN.1 to C Compiler is
an ASN.1 to
C or C++ compiler with
a BER encoding/decoding library.
Given an ASN.1 source file this can produce:
The ASN.1 features supported include:
- C routines for BER encoding, decoding, printing and freeing;
- C++ routines for BER encoding, decoding and printing; and
- a type table that can be used with generic C routines for
BER encoding, decoding, printing and freeing.
A source code distribution is available.
- parsing ASN.1 `90 including subtype notation;
- handling multiple ASN.1 module compiling/linking;
- parsing some X.400 and SNMP macros; and
- support for separated type or value definitions in the ASN.1 source.
- An extension to Tcl/Tk that adds commands for
sound I/O and sound visualization, e.g. waveforms and spectrograms.
It was originally developed to handle digital speech recordings,
although it has wider applications for general audio tasks and
The features include:
- commands for basic sound operations, e.g. playing, recording, reading
- support for in-memory sound objects, file-based and streaming
audio, and background audio processing;
- waveform, spectrogram and spectrum section canvas item types that
are self-updating in real time;
- PostScript output;
- extensibility via the Snack C library; and
- Web-enabled via the Tcl plug-in.
- An enhancement for Linux journaling filesystems
that provides snapshots and versioning.
The main components of SnapFS include:
SnapFS is based on parts of both the Lustre
and InterMezzo projects.
- a filtering filesystem layer that intercepts calls to the disk
filesystem and preserves it;
- extended attributes that provide the space needed to store where
older versions of inodes are kept;
- an API for the filter layer that provides functions generally provided
by filesystems but not exported; and
- journal transactions wherein the filter layer participates in filesystem
- A set of tools designed for the creation of interactive
applications under Unix, X and Motif. It consists of an editor,
an interpreter/compiler, a driver and an object oriented language.
The editor makes it easy to define the visual appearance of an
application, with all the tasks associated with specifying an
interface (e.g. designing input forms and dialog boxes, selecting
fonts, etc.) quick and simple. The driver is supplied with over
20 pre-defined classes including some high-level classes like
menus, and it can also handle user-defined classes. The language
is complete, typed, structured, event driven and object oriented.
Additional features of Snapix include:
A Linux version is freely available and
comes with 110+ page manual in
- the possibility of modular application design;
- manual code generation with a standard editor or automatic
code generation using an interactive editor;
- version management under SCCS;
- code maintainability and rapid modification;
- pre-compilation for fast run times and source protection;
- use of C-like syntax; and
- integration of user defined C functions using standard calls.
- The name of this has been changed to
- A sound editor based loosely on Emacs
and a PDP-10 sound editor named Dpysnd which is currently
an X/Motif application.
It can accomodate any number of sounds at once, each with any
number of channels. Each channel of each sound is displayed in
its own window with its own cursor, edit history, and
marks. Each sound as a control panel to try out various changes
quickly, and an expression parser usedly mainly during searches.
There is an overall stack of regions which can be browsed and
edited, and channels and sounds can be grouped together during
editing. Edits can be undone and redone without limit and snd
can be customized using an Elisp-like syntax. It can also be
extended with user-supplied editing or display functions loaded
at run time.
Snd is available as source code or as a binary for SGI and
Linux Intel platforms. It is written in ANSI C and requires
the Motif widget set for compilation.
It is documented in a user's manual in HTML format which is
included in the distribution.
This is useful by itself but can also be used with the
- A package of signal analysis, graphics, modification, and
synthesis routines for UNIX systems.
One group of programs performs analysis and converts sound
files into analysis files which contain data for the amplitudes
and frequences of components within the file.
Another group contains programs for viewing the data in either
signal or analysis format.
Another group contains programs to modify the analysis data,
and the final group programs to synthesize signal files from
the analysis data.
The programs assume that sound files are in monaural NeXT
sound file format, although the SoX package
can be used to convert other formats to this.
Graphics files are output in EPS format.
The programs available in SNDAN include:
- sp, which graphs sound files;
- sextract, which extracts individual sounds from a sound file
containing a sequence of sounds and puts them in separate files;
- pvan, which performs phase vocoder analysis;
- mqan, which performs spectral tracking analysis; and
- monan, which combines the activities of parameter viewing,
modification, and additive synthesis.
A source code distribution of SNDAN is available.
It is written in C and has been compiled successfully on
several systems including Linux Intel.
- The Semantic Network Processing System
is a system for building, using, and retrieving from propositional
A semantic network can be thought of as a labeled directed graph
in which nodes represent entites, arc labels represent binary
relations, and an arc labeled R going from node n to node m means
that n bears the relation R to m.
SNePS is a propositional semantic network because every proposition
represented in the network is represented by a node and not by an arc.
The core of SNePS is a system for building nodes in the network,
retrieving nodes that have a certain pattern of connectivity to other
nodes, and performing housekeeping tasks like dumping a network
to a file or loading a network from a file.
The major components which comprise SNePS are:
- SNIP (SNePS Inference Package), which interprets certain nodes
as representing reasoning rules called deduction rules and supports
a variety of specially designed propositional connectives and
quantifiers and performs a kind of combined forward/backward
inference called bi-directional inference;
- SNeBR (SNePS Belief Revision System), which recognizes
when a contradiction exists in the network and interacts with the
user when it detects the user operating in a contradictory belief space;
- SNaLPS (SNePS Natural Language Processing System), which consists
of a morphological analyzer, a morphological synthesizer, and
a Generalized Augmented Transition Network (GATN) Grammar interpreter
and compiler, all of which allow natural language interfaces for
SNePS to be built;
- SNePSUL, (SNePS User Language), the standard command language
for SNePS which resembles Lisp;
- XGinseng, an X Window-based graphical
editing and display environment for SNePS networks which can be
used to build and edit networks; and
- SNePSLOG, a logic programming interface to SNePS which provides
direct access in a predicate logic notation to almost all of the
facilities provided by SNePSUL.
A source code distribution of SNePS is available.
It is written entirely in Common Lisp
and has been used successfully with both CLISP
It may also work with AKCL and
The program and its use are documented in a 94 page
user's manual available in PostScript
- An emulator for the
Super Nintendo Entertainment System (SNES) for Linux
SVGA and X. It is currently (5/98) under development but
plans on including features such as SuperFX support,
sound digital FIR filter and echo, sound pitch modulation,
mouse and multi-tap support, 8- and 16-bit color screen
modes, transparency, hi-res and interlaced screen modes,
improved ROM detection routines, and more.
An older version is available at the second URL.
- A graphical front-end for the X11 version of
Snes9X. It offers many of the available options
as checkboxes, sliders, etc. along with tips for each option.
It can also save profiles for loading favorite sets of options on
- The Simulation Network Interface is a set of
tools developed for interacting and exchanging data between different
simulation programs on possibly remote machines through a simple
set of calls.
The package consists of an SNI server and a client library.
- Sniffing is a euphemism given to the practice of intercepting and
analyzing TCP/IP packets.
Sniffing is the practice of scanning the various ports on a UNIX
box to obtain various kinds of information.
This information - just like about everything else on this planet - can
of course be used for both good and bad purposes.
Available packet sniffers include:
- exscan, a port scanner;
- IPFT, a userspace IP
networking stack that includes a port scanner;
- K-Arp-Ski, a sniffer;
- KSniffer, a sniffer;
- NID, a security package for protecting against
various problems including port scanning;
- nmap, a port scanner;
- Protolog, for evading sniffer attacks;
- scanallert, a port scanner detector;
- Sentry, a security program designed to detect
and respond to port scans;
- Sniffit, a sniffer;
- Snort, a sniffer/logger that can be used
as in intrusion detection system; and
- Unix Hacker Tools, includes a sniffer.
- A packet sniffer which supports both Ethernet and PPP.
See the related TOD.
- A Fortran 77 subroutine package which solves nonlinear least
squares problems, i.e. it minimizes a sum of squares of M nonlinear
functions of N variables.
It also contains programs for solving systems of nonlinear equations
which can be used separately.
The package consists of:
- SNLS1, which minimizes the sum of the squares of M functions
in N variables using a modification of the Levenberg-Marquardt
algorithm with the user providing a subroutine to calculate the functions
(and optionally the full Jacobian);
- SNLS1E, an easy-to-use version of SNLS1;
- SNSQ, which finds a zero of a system of N nonlinear equations
in N variables using a modification of the Powell hybrid method with
the user supplying a subroutine to calculate the functions (and
optionally to calculate the full Jacobian);
- SNSQE, an easy-to-use version of SNSQ; and
- SOS, which solves a system of N simultaneous nonlinear
equations in N unknowns based on an iterative method which is
a variation of Newton's method using Gaussian elimination in a manner
similar to the Gauss-Seidel process.
A source code distribution of SNLS1E is available.
All of the routines are written in Fortran 77 and are documented
via comment statements contained within each source code file.
This is part of CMLIB.
- The Simple Network Management Protocol
is a protocol for Internet network management services.
It facilitates communication between a managed device, i.e. a
device with an SNMP agent, e.g. a router, and an SNMP manager
or management application.
Communication is via SNMP protocol data units (PDUs) typically
encapsulated in UDP packets, with various operations permitted
between managers and agents to either handle objects on the
managed device or notify the manager about events occurring on the device.
An SNMP manager obtains information about the available objects
on a managed device via Management Information Base (MIB)
modules. An MIB file contains a description of the object
hierarchy on the managed device as well as the name, syntax,
and access priveleges for each variable in the MIB, i.e. only
the types of objects are specified and not the specific objects.
It is basically an enormous tree which provides a map for
There is only one official SNMP MIB, although other kinds of MIBs
exist which are extensions to the official SNMP MIB.
The standard implementation of SNMP for Linux platforms
is CMU-SNMP, although many also use
More about these can be found in the
User's Guide to SNMP for Linux.
SNMP-related programs include include:
- AgentX, a protocol with which subagents can
advertise and export MIB regions via a single SNMP agent;
- btng, a package of network measurement software;
- CMIP, a protocol once thought to be the
successor to SNMP;
- CMU-SNMP, an SNMP implementation;
- Corba/SNMP Gateway, a gateway
between CORBA and SNMP;
- Erlang, a language environment that includes an
- HNMS, a network management system;
- MON, a network service monitoring daemon;
- MRTG, a network traffic load monitor;
- NeTraMet, a network traffic flow meter;
- NOCOL, a network monitoring package;
- OSI, a protocol suite advanced as an alternative
- OSIMIS, a network management platform based
on the OSI model;
- Scion, a network data collection package;
- Scotty, a network management package;
- SNMPY, a Python
interface to SNMP;
- SNMX, an SNMP manager;
- SYSMAN, an SNMP management library written
using Common Lisp;
- TclHttpd, a Web server with SNMP integration;
- UCD-SNMP, an SNMP implementation;
- VRRP, an MIB extension for used with SNMP-based
- Webbin' CMIP, a package for simplifying
access to network information and resources; and
- WILMA, a network management package.
The available literature on SNMP is vast, e.g.
Comer and Stevens (1991),
Comer and Stevens (1993),
Griffith and Hein (1994),
Leinwand and Fang (1993),
Perkins and McGinnis (1997),
Rose and McCloghrie (1995),
Taylor (1996), and
- An interface to SNMP for
- The Simple Network Management eXecutive
is a self-contained SNMP manager,
extensible SNMP agent, scripting language,
and development environment which allows users to rapidly create
SNMP applications. The program provides a shell-like command
line interface which presents the SNMP MIB as a series of
virtual directories which can be traversed using standard
cd commands and listed with the ls command. The scripting
language can be used to create SNMP interactive and background
applications including SNMP agent processes.
SNMX can be used as:
Scripts can be constructed to poll devices, check network
performance, and issue traps when network anomalies are detected.
Agent scripts can be built to provide SNMP compatibility with existing
systems or processes including such applications as instrumenting queues and
controlling network graphical systems.
- an administrative tool, i.e. it is a full-featured
MIB browser providing numerous functions allowing users to explore
the structured management information on a device;
- an element configurator since it allows an entire MIB to be listed
to a disk file, potentially edited, and then put back on the network
- a network scanner useful for making comparative measurements of
network devices, e.g. a built-in agent table (as part of its private
MIB) allows a variety of scanning and charting operations; and
- a network configurator, i.e. multiple network devices and be updated
with a single commmand.
An evaluation copy of
SNMX is freely available to individuals and organizations with
the base distribution containing an SNMX interpreter, a MIB
compiler, and several examples of management and agent scripts.
Extensive documentation is provided in several large manuals
in ASCII format.
- The Simulator for Neural Networks and
Action Potentials is a tool designed for the
rapid development and simulation of realistic models of
single neurons and small neural networks.
The electrical properties of individual neurons are
described with Hodgkin-Huxley type voltage- and time- dependent ionic
currents. The connections among neurons can be made by either electrical
or chemical synapses. The chemical synaptic connections are capable of
expressing several forms of plasticity, such as homo- and heterosynaptic
depression and facilitation.
SNNAP also includes mathematical descriptions of intracellular second
messengers and ions. The synthesis of second messengers can be driven by
either synaptic inputs or by externally applied transmitters. The
accumulation of an ion can be driven by any specified voltage- and time-
dependent ionic current(s). The intracellular concentrations of ions
and/or second messengers, in turn, can be linked to one or more ionic
conductances and/or mechanisms contributing to chemical synaptic
transmission. Thus, SNNAP can simulate the modulation, either
enhancement or inhibition, of membrane currents and synaptic
transmission. SNNAP also can simulate current flow in multicompartment
models of neurons by using the equations describing electrical coupling.
The features of SNAPP include:
- the specifics of all intrinsic neuron properties, network structures,
and simulation properties can be controlled using editors in a GUI
- the capability of simulating common experimental manipulations, e.g.
the injection of external currents into multiple cells, the
removal of individual conductances to simulate pharmacological
agents, etc; and
- the modular organization of all input files, i.e. the equations
and related parameters are passed to SNNAP via files generated by
the graphical editors which allows for the creation of a library of
modules for describing different aspects of neural networks.
A source code distribution of SNNAP is available.
It is written in ANSI C using Xlib functions
and is thus portable to most UNIX/X11 environments.
A user's manual is available in
- The Stuttgart Neural Net Simulator
is a software simulator for neural nets which runs on UNIX workstations.
The goal of the project is to create an efficient and flexible
simulation environment for research on and the application of
SNNS consists of a simulator kernel and a graphical interface.
The simulator kernel operates on the internal network data
structures of the neural nets and performs all operations of
learning and recall, and it can also be used as an embedded
program in custom applications.
It supports arbitrary network topologies and can be extended by
the user with user-defined activation functions, output functions,
site functions, and learning procedures which are written as
C programs and linked to the kernel.
The graphical interface controls the kernel during the simulation
and gives 2- and 3-D representations of the networks being simulated.
The network architectures and learning procedures included in
A genetic algorithm tool called Enzo is separately available
which allows the evolutionary
optimization of neural networks.
A tool called snns2c automatically generates C code from
nets built interactively.
- backpropagation (BP) for feedforward networks (i.e. vanilla BP, BP
with a momentum term and flat spot elimination, and batch BP),
- counterpropagation, quickprop, backpercolation 1, and RProp,
- generalized radial basis functions (RBF),
- ART1 and ART2 and ARTMAP,
- cascade correlation and recurrent cascade correlation,
- dynamic LVQ,
- backpropagation and quickprop through
time (for recurrent networks),
- self-organizing (Kohonen) maps,
- time-delay networks (TDNN) with backpropagation,
- Jordan, Elman extended hierarchical Elman networks, and
- associative memory.
The source code for SNNS is available. It is written in C
and has been tested on Sun SunOS, DEC Ultrix and Alpha,
IBM AIX, HP-UX, SGI IRIX, and Linux Intel platforms.
The huge user's manual is available in either PostScript
or HTML format.
- A package which uses the Minimum Message Length (MML) principle
to to mixture modeling, which concerns modeling a statistical
distribution by a mixture (or weighted sum) of other
distributions and is also known as unsupervised concept
learning, intrinsic classification, clustering, and
Snob can use several distributions, e.g. normal (i.e. Gaussian),
discrete multi-state (i.e. Bernoulli or categorical),
Poisson, and von Mises distributions, and can also handle
The source code for Snob, written in Fortran
77, is available.
It is documented in a ASCII user's guide as well as in several
papers and technical reports available in PostScript format.
See also AutoClass C.
- The StriNg Oriented symBOLic language is
an unconventional programming language based on logical principles
of pattern matching to solve string manipulation problems.
It features a powerful collection of string processing and
pattern matching functions.
SNOBOL was developed at Bell Labs in 1962 to develop applications
in symbolic formula manipulation. Improved versions called
SNOBOL3 (1966) and SNOBOL4 (1969) were later developed, with
active development on the language stopping with SNOBOL4.
It was initially developed for formula manipulation but
was extended to perform graph processing and text manipulation
tasks, with the primary objective being to provide a general purpose
language for the manipulation of non-numerical scientific data that
can be naturally represented by strings of characters.
Another significant design criteria was to develop a language
suitable for use by non-programmers.
An available compiler is SNOBOL4.
- A port of Macro SNOBOL4 (i.e. the original Bell Labs implementation
written in SIL macros) to machines with 32-bit C compilers.
It supports the full SNOBOL4 language plus extensions from
Catspaw SNOBOL4+, SPITBOL, and SITBOL.
All aspects of the language are implemented except the
trapping of arithmetic exceptions and the dynamic use
of LOAD() platforms not using the a.out executable format.
It has been tested on most UNIX flavors.
See Gimpel (1976),
Griswold et al. (1971),
Griswold (1972), and
- A packet sniffer/logger that can be used as a
network intrusion detection system.
This performs rule-based logging which can perform content searching and/or
matching and can be used to detect a variety of attacks and probes, e.g.
buffer overflows, stealth port scans, CGI attacks, SMB probes, etc.
This has real-time alerting capabilities.
- The SemiNonParametric software is a package
for multivariate nonparametric time series analysis by maximum
likelihood polynomial expansion which permits uneven weighting,
non-normality, and nonlinearity.
An extensive user's manual is available in
- Soar is an AI programming language which implements a theory of
cognition as a set of principles and constraints on cognitive
processing, i.e. it provides a cognitive architectural framework
within which cognitive models can be constructed. It can be
considered as an integrated architecture for knowledge-based
problem solving, learning, and interacting with external environments.
It incorporates problem spaces as a single framework for all tasks
and subtasks to be solved, production rules as the single
representation of permanent knowledge, objects with attributes
and values as the single representation of temporary knowledge,
automatic subgoaling as the single mechanism for generating goals, and
chunking as the single learning mechanism. Soar is used by
AI researchers to construct integrated intelligent
agents and by
cognitive scientists for cognitive modeling.
Soar is written in C and versions are available for both UNIX
and Mac systems. There is quite a bit of documentation available,
including several tutorials and manuals in PostScript format.
Quite a bit of ancillary software has also been developed.
Browse the several Soar sites to see what's available.
- A library of C++ classes that can be used more
effectively to work with sockets than directly calling the underlying low-level
It has the same interface as that of the
iostream library in the G++ library.
- Socket Script
- A simple scripting language for accessing sockets. Socket Script
was designed to provide users with a quick and easy way to make
powerful networking applications without needing to learn C or
complicated socket code. It can be used for such tasks as
retrieving web pages or creating an IRC bot, a web server,
an ICMP water, a network monitor tool, online forms, etc.
It consists of over 80 commands, some simple and some highly
It can be compiled into text only, Xt
graphics, or GTK graphics modes.
The Socket Script distribution consists of an interpreter,
a compiler, and a C library of Socket Script functions for
those who wish to program in C.
Documemtation is a bit sparse but available in various ASCII
text files within the distribution.
- An open Internet standard for performing network proxies
at the transport layer. This is also known as authenticated
firewall traversal (AFT) and is described
SOCKS is a networking proxy protocol which enables hosts on
one side of a SOCKS server to gain full access to hosts on the
other side of the server without having to create a direct
IP connection. The server authenticates and authorizes
the requests, establishes a proxy connection, and relays the
data. It is most commonly used as a network firewall which
enables those behind it to gain full access to the Internet
and prevents unauthorized access from the outside. There
are two major versions: SOCKS V4 and V5, with the latter
supporting authentication methods and UDP proxy and the former not.
Newer features also allow SOCKS to be used as:
- a network enabler which allows an unstructured and unsecured
enterprise network to safely use the Internet;
- a network broker supporting a wide range of security mechanisms;
a network folder which can collect a group of networks and represent
them as a single node;
- a network keeper which provides a centralized network access
point that facilitates administration; and
- a network master which, as a generic internetworking proxy
mechanism becomes the master of a network.
This (i.e. the NEC) reference implementation of SOCKS
supports all the requirements of RFC-1928 and has
additional features including:
These features allow SOCKS users to build virtual private
networks (VPN) over the Internet which offer:
one-time sign on,
encrypted communication channels,
transparent access across the entire VPN,
centralized network access control and audit,
localization of network administration, and the
masking of the VPN computing environment.
- a shared library for UNIX clients,
- a ping and traceroute proxy,
- a SOCKS Server-to-Server proxy,
- an address resolution proxy,
- an Ident name proxy,
- preforking and threading, and
- a Kerberos-based Server-to-Server proxy.
The UNIX SOCKS5 package contains
a socks server, static and
unshared client libraries, and some popular client applications.
It is available in source code format or in binary
format for several UNIX flavors.
Extensive documentation is available at the site and
in the distribution.
This is also covered in Garfinkel and Spafford (1996).
Other SOCKS-related software includes:
- Dante, an implementation of a
SOCKS v4/v5 client and server;
- Freestone, a firewall
implementation with SOCKS support; and
- LinGate, a network gateway package which
includes a SOCKS server and client.
- An implementation of the IEC/IEEE Standard for
Binary Floating-point Arithmetic that is completely faithful
to the IEEE Standard and relatively fast.
If 64-bit operations are supported by the compiler, four types
are defined, i.e. float32 (single precision), float64 (double precision),
floatx80 (extended double precision) and float128 (quadruple precision).
The first two types are defined in terms of 32- and 64-bit integer
types, respectively, while the last is defined as a structure of two
64-bit integers. The floatx80 type is defined as a structure containing
one 16-bit and one 64-bit integer.
If 64-bit integers aren't supported, then only float32 and float64
types are defined.
In both cases the types are defined such that if a system implements
the C float and double types according to the IEC/IEEE standard, then
the float32 and float64 types should be indistinguishable in memory
from th enative float and double types.
The arithmetic operations implemented by SoftFloat include:
The only required IEC/IEEE functions not supplied are conversions
to and from decimal.
- conversions among all the floating-point formats as well as
between integers (32- and 64-bit) and any floating-point format;
- the usual add, subtract, multiply, divide and square root operations
for all floating point formats;
- the floating point remainder operation defined by the IEC/IEEE
Standard for each format;
- a ``round to integer'' operation for each floating-point format
that rounds to the nearest integer value in the same format; and
- comparisons between two values in the same floating-point format.
SoftFloat is written in ISO/ANSI C and should compile on any
machine with an ISO-conformant C compiler, e.g. gcc. The package
has been tested using gcc on Intel 386, SPARC, MIPS and
HP Precision Architecture processors.
The SoftFloat distribution includes the source code and documentation.
A test program called FloatTest is also supplied.
- A UNIX-based software management system developed for the high energy
physics codes used at Fermilab.
The system provides software version control with
CVS configured in a client-server mode and
using a CVSH shell.
SoftRelTools uses CPP for preprocessing and the creation of dependency
files, and GNU Make for building object libraries and executables.
The system handles the version control, management, building and
distribution of code written in
A distinguishing features is the capability of allowing rapid
asynchronous development of package versions, which can be easily
integrated into complete consistent releases of the entire
SoftRelTools includes a set of shell scripts for working with
packages and releases. They are intended for use by developers,
librarians and code managers and include:
- addpkg, adds a new package to a release;
- depend, lists the packages that uses includes from a given
- lnkpkg, creates soft links to a production package;
- newrel, create a new test or production release;
- rmrel, remove a release completely; and
- statusrel, lists the contents of a release.
- Software ChipSet
- A collection of reusable software components written in C.
The goal is to provide small, general, production quality off-the-shelf
solutions to common problems faced by programmers.
The name comes from an analogy to components used in the development
of integrated circuits.
The components of the ChipSet are intended to be general enough to
use in a wide variety of applications.
This goal is reached by providing generalized interfaces and
programmability, with the former permitting the components to be used
with arbitrary data types and the latter permitting the application to
tune the components to its data types and performance requirements at
The components are also programmable in that they can be composed into
The components of the ChipSet are:
A source code distribution is available. All components are written
in C for maximum portability.
- btree, a in-memory B-tree implementation;
- dupkey, which generalizes in-memory unique key index structures
(i.e. btree and list) to allow redundant keys;
- list, an in-memory doubly-linked list; and
- readln, a component for safe text line input which supports
lines of arbitrary length.
- software engineering
- Related packages include:
- ACL2, an automated reasoning system;
- Aslan, a low-level implementation of the
ASM approach for building higher-level ASMs;
- ASM Workbench, a toolkit for supporting
the design and validation of ASMs;
- Balboa, a server-based process event data
analysis system to help in the construction of event data analysis tools;
- CADP, a software engineering toolbox for
protocols and distributed systems;
- CSML/MCB, produces a finite state machine
from a description of it in a high level language;
- DGL, a tool for generating test data for software
- EVES, a formal methods tool;
- Expect, a tool for automating and testing
- Floppy/Flow, for processing Fortran code;
- ftnchek, a Fortran code checking tool;
- GCT, a coverage tool that measures how thoroughly
tests exercise C programs;
- GemMex, a graphical editor and program
generator for the Montages language;
- HOL, an automatic theorem prover;
- Isabelle, a generic theorem prover;
- Larch, a format specification language;
- LOTOS, a language implementing a formal
description technique for the unambiguous definition of standards;
- Murphi, a description language and verifier;
- Rapide, a package for building large-scale,
distributed, multi-language systems;
- SMV, a symbolic model checking software collection;
- SRLT, a toolbox for developing code that
closely meets system specifications;
- unravel, a program slicing tool;
- Verus, for the formal specification and
verification of real-time and other time critical systems;
- WinWin, a distributed groupware negotiation
- software configuration management
- Related packages include:
- A library for collision detection of 3-D objects undergoing rigid
motion and deformation. SOLID is designed to be used in interactive
3-D graphics applications and is especially suited for the collision
detection of objects and worlds described in
The features include:
- object shapes represented by both primitive shapes and
complexes of polytopes;
- motion specified by translations, rotations and nonuniform
scalings of the local coordinate system of each object;
- specification of complex shape deformations using client-defined
- collision reponse defined by the client via call-back functions;
- response call-backs that can use collision data describing
the configuration of a pair of colliding objects; and
- frame coherence achieved by maintaining a set of pairs of proximate
objects and caches separate axes for the pairs.
A source code distribution is available under the terms of the
LGPL. It is written in C++
and relies heavily on STL. It is known to
compile under g++ 2.8.1.
A user's guide is available in the usual popular formats.
- A standalone shell and boot loader for protected mode 32-bit
x86 microkernels, operating systems, and standalone programs.
The SOLO features include:
Source code and demo binary disk images are available.
- loading 32-bit protected mode executables (ELF or a.out format);
- allowing BIOS calls form 32-bit mode;
- provision of file access and console I/O from 32-bit mode;
- a statically mapped file system providing up to 32 Mb of startup
- a built-in shell;
- booting from any partition;
- can be used to boot any partition (primary or extended);
- passing arguments to 32-bit programs;
- loading Linux directly;
- booting other operating systems;
- scanning and listing all available text and graphics video
- redirection of console I/O over a serial port;
- a built-in monitor for examining and changing memory and I/O;
- a built-in panic with a full register dump;
- protected mode and virtual memory initialization to allow kernels
to actually start executing in the memory region in which they are
expected to run;
- a circular message buffer that survives panics to save information
- an extensible built-in help command; and
- several 32-bit test programs.
- A program for constructing atomic solvent environment models for
given atomic macromodule models (solutes) used in
The capabilities of SOLVATE include:
- generation of irregularly shaped solve volumes adapted to a given
- efficient computation of boundary forces as required in molecular
- a guaranteed minimal solute boundary distance;
- specification of a minimum solvent surface curvature to avoid flat
- generation of disordered (i.e. fluid) water rather than a grid of
water molecules, i.e. ice;
- local minimization of the positions of all water molecules;
- optional placement of salt ions obeying a Debye-Hückel distribution;
- optional placing and marking of buried water molecules; and
- compatibility with X-PLOR and CHARMm with
output in PDB/PSF format.
A source code distribution of SOLVATE is available. It is written
in Fortran and can be compiled on most generic UNIX platforms.
A user's manual is included in PostScript format.
- Stefan's Own Mail Application
is a mail reader (i.e. a
mail user agent) for Linux
under X11 based on the XView library
which provides an OpenLook user interface.
- The Self-Organizing Map package implements the
SOM algorithm for the visualization of complex experimental data.
The SOM represents the result of a vector quantization algorithm
that places a number of refererence or codebook vectors into
a high-dimensional input data space to approximate to its data
sets in an ordered fashion.
Local-order relations are defined between the reference vectors,
with the relative values of the vectors made to depend on each other
as if their neighboring values lie along an elastic surface.
The SOM algorithm defines this surface as a kind of nonlinear
regression of the reference vectors through the data points, a procedure
that also serves to define a mapping from a high-dimensional data space onto
a 2-D lattice of points.
This mapping can be used to visualize the metric ordering relations
of the data.
A C source code distribution of
SOM_PAK is freely available for scientific purposes.
A technical report that serves as a user's guide and reference
manual is available in PostScript format.
See Kohonen (1995).
- SOM Toolbox
- A Matlab toolbox implementing the
self-organizing map (SOM) algorithm.
The features include:
- a GUI for the initialization and training procedures;
- the capability of giving the components different weights and names;
- batch or sequential training; and
- support for but not visualization of N-dimensional maps for N higher
- The Sequential Object-oriented simPLEX class
library is a C++ library of primal and dual simplex algorithms
for solving linear programming problems.
It consists of
elementary classes for general purposes,
linear algebra classes providing basic data types for regular
and sparse linear algebra computations, and
algorithmic classes implementing a wide variety of algorithms
for solving numerical problems and subproblems.
The elementary classes include Array, CmdLine,
DataArray, DataHashTable, DataSet,
IdElement, IdList, IsElement,
IsList, NameSet, Random, and Timer classes
as well as classes for data objects and sorting functions.
The linear algebra classes include those for dynamic index sets,
dynamic sparse vectors, dynamic vectors, index sets, LP columns,
sets of LP columns, sets of LP rows, semi-sparse vectors, parts
of semi-sparse vectors, sparse vectors, sparse vector sets,
sparse unit vectors, vectors with updates, and dense vectors.
The algorithmic classes are divided into several categories including
general, pricer, ratio test, simplifier, start basis, and
linear system solver classes.
The general classes include:
The pricer classes include:
- LPSOlver, an interface class for LP solvers;
- CacheLPSolver, an LP solver with result caching;
- SoPlex, a sequential object-oriented simplex solver;
- SPxBasis, a simplex basis;
- SPxSolver, a preconfigured SoPlex LP solver;
- SPxLP_SPxColId, IDs for LP columns;
- SPxLP_SPxRowId, IDs for LP rows;
- SPxLP_Id, generic IDs for LP rows or columns;
- SPxLP, for saving LPs in a form suitable for SoPlex; and
- SPxTCL, a TCL interpreter for SoPlex.
The ratio test classes are:
- SPxPricer, a SoPlex pricer base class;
- SPxWeightPR, for weighted pricing;
- SPxSteepPR, a steepest edge pricer;
- SPxDefaultPR, a default pricer;
- SPxParMultPR, for partial multiple pricing; and
- SPxHybridPR, a hybrid pricer for SoPlex.
The simplifier classes are:
- SPxRatioTester, a SoPlex ratio test base class;
- SPxDefaultRT, a textbook ratio test for SoPlex;
- SPxHarrisRT, for Harris pricing with shifting; and
- SPxFastRT, a fast shifting ratio test.
The start basis classes include:
- SPxSimplifier, an LP simplification base class;
- SPxScale, for LP scaling;
- SPxRedundantSM, to remove redundant rows and columns;
- SPxRem1SM, an LP simplifier for removing singletons;
- SPxAggregateSM, to remove redundant rows and columns; and
- SPxGeneralSM, for general LP preprocessing.
The linear system solver classes are
- SPxStarter, a SoPlex start basis generation base class;
- SPxSumST, a simple heuristic SPxStarter;
- SPxWeightST, a weighted start basis; and
- SPxVectorST, a solution vector based start basis.
- SLinSolver, a sparse linear solver virtual class base; and
- SLUFactor, a sparse LU factorization class.
A source code distribution of SoPlex is available.
It is written in C++ and includes a user's guide
in PostScript format.
It is available by filling in an interactive form at
- Useful metasites for such things include:
There are many packages for synthesizing, editing, annotating,
and doing various other things with sound.
Sound synthesis packages include
- Cecilia, an environment for digital sound
processing and Csound programming;
- CLM, a music synthesis and signal processing
- CM, an object-oriented music composition
- CMIX, a library of C
functions designed to create and manipulate sound files;
- Csound, a sound synthesis package;
- Nyquist, a language for sound synthesis and
- PD, a programming language for computer
- saolc, an MPEG-4 feature
allowing sound to be described with a high-level, sophisticated
- Sapphire, an acoustic compiler that
transforms text files into sound files; and
- STK, a set of audio signal processing classes
and instruments for music synthesis;
Sound editors include:
- Broadcast 2000, a nonlinear audio and
video editor for Linux;
- DAP, a comprehensive audio sample editing and
- GOM, a generic audio mixer program;
- MiXViews, a tool for editing, processing
and analyzing digital sounds and other binary data;
- SLab, a suite of applications for
direct-to-disk digital audio recording, mixing and signal
- smix, a sound mixing tool;
- snd, a sound editor;
- SoundTracker, a music tracker allowing
the arrangement of sound samples on tracks; and
- Studio, a sound editing tool.
Music notation editors and/or typesetting systems include:
- CMN, a music notation package;
- LilyPond, the GNU
- MusicTeX, a music typesetting system;
- MusiXTeX, a music typesetting system;
- Rosegarden, a music notation editing
and sequencing system; and
- Vivace, an editor for creating, editing,
typesetting and generating music.
MIDI-related software includes:
- JAZZ, an audio capable MIDI
- KeyKit, a programming langauge and GUI
for experimentation with MIDI;
- kooBase, a music application for
KDE that includes score, drum and event editors as
well as MIDI import and export;
- midikb, reads standard computer keyboard
input like a synthesizer keyboard and outputs MIDI
events to other devices;
- Midi2Cs, converts MIDI
files to Csound format;
- Tclmidi, a language for creating and
editing standard MIDI files; and
- TiMidity, a MIDI to
- sound modules
- Sound modules (or modules or mods) are digital music files composed of
a set of samples (i.e. instruments) along with sequencing information
that tells a module player when to play which sample on which track.
They differ from other sound file types such as pure sample files (e.g.
WAV or AU files) which don't contain sequencing information and
MIDI files which don't include custom samples
or instruments, i.e. they are a sort of hybrid of the two latter
file types. The sequencing information is based on patterns and
tracks, with a pattern being a group of tracks with a specific length.
There are at least a couple of dozen types of MODs that are or have
been been used. Details about various formats can be found at:
Available sound and module players include:
Libraries and programs for accessing various audio formats include:
- AFsp, a library for reading and writing audio
files with emphasis on speech processing;
- Audio File Library, an implementation
of the SGI Audio File Library for accessing several audio formats;
- CMT, a toolkit for multimedia applications that
supports several audio encoding formats;
- libsndfile, for reading and writing
various sound sample files;
- MIDAS, a multichannel digital sound and
music system for use with games, demos and multimedia applications;
- RawSoundStudio, a sound package
for playing, recording and analyzing sound files;
- SEAL, a library for playing digital audio
waveforms and multichannel music module sequences concurrently;
- SkySOUND, a project to build a
stream-oriented audio library;
- Snack, a Tcl/Tk
extension adding commands for sound I/O and sound visualization;
- SNDAN, a package of signal analysis, graphics,
modification and synthesis routines;
- SoX, a sound file conversion package;
- SPKit, an object-oriented class library
for audio signal processing.
Miscellaneous other available music-related software includes:
See also the CD-ROM,
MBone sections for related
- sf ALSA, a project to create a fully modularized
sound driver for Linux systems;
- BashFest, a virtual drum machine front-end
- Drumachine, translates a drum pattern
description into a Csound score;
- GramoFile, for transferring audio signals
from vinyl records onto CDs;
- OSS, sound drivers for Linux;
- Rivl, a Tcl/Tk extension
for multimedia processing;
- SMIL, a standard for choreographing interactive
multimedia content for the Web; and
- Space, a program for spatializing sound
using a scripting language;
- A music tracker that allows the arrangement of sound samples on tracks
where a track (or channel) can't play more than one sample at a time.
Sets of tracks played simultaneously are called patterns with a pattern
typically having 64 entries per track.
From these modules are built, i.e. compact files containing
various patterns and samples along with a position list specifying
the playback order of the contents.
A source code distribution is available which requires
GTK for compilation.
- Source Coding Toolbox
- The Matlab source coding toolbox
contains programs related to systems for transmitting or storing data
use codes for data compression, data translation, and error correction.
The programs include:
- bitstring_to_index, converts any bitstring to an
- index_to_bitstring, reverses the previous operation;
- print_bitstrings, prints to the screen several bitstrings
whose indices are given in a vector;
- archive_bitstrings, prints the above to a file;
- input_bitstrings, inputs several bitstrings at once into
memory as a vector of indices;
- concat, concatenates two or more bitstrings input in the form
of a vector of indices;
- prefix_encode, encodes a data vector via a memoryless prefix
code induces by a given prefix set;
- compactcodeP, designs a compact prefix code having a given
proper Kraft vector as the vector of codeword lengths;
- compactcodeI, designs a compact prefix code whose vector of
codeword lengths is less than or equal to a given improper Kraft vector;
- numkraft, computes the number of compact prefix codeword sets
having a given number of codewords;
- frequency, computes the frequency with which each symbol appears
in a given data vector;
- huffmanlength, computes the length of the binary codeword that
results when a data vector is encoded via the Huffman code designed for
- huffmancode, computes the codeword lengths for the Huffman code
designed to encode a given data vector;
- pseudoseq, generates a pseudorandom sequence from a given
alphabet with prescribed symbol frequencies;
- entropy, computes the first order entropy of a given data
- block_entropy, computes the entropy from partitioning a data
vector into blocks of a given length;
- cond_entropy, computes the conditional entropy of a data vector
using a memory window of a given size;
- Bcomprate, computes the minimum compression rate achievable in the
encoding of a data vector via finite memory codes employing a memory window
of a given size;
- FMcomprate, computes the minimum compression rate achievable in
the encoding of a data vector via finite memory codes employing a fixed
- LZparse, computes the indices of the variable-length blocks
appearing in the Lempel-Ziv parsing of a binary data vector;
- LZcodelength, computes the length of the codeword generated by
the Lempel-Ziv encoder for a binary data vector;
- opt2level, determines the optimal two-level scalar quantizer
for a given data vector;
- lloyd, designs a scalar quantizer via Lloyd's algorithm;
- LBG, designs a scalar quantizer via the LBG algorithm;
- SQNR, computes the signal to quantizing noise ratio for a vector
- dist_rate_func, computes the distortion rate function of
a memoryless information source;
- laplace, a pseudorandom number generator for simulating a
Laplacian memoryless source; and
- signum, implements the signum function.
- source code documentation/formatting
- Packages related to the documenting and/or formatting of source code include:
- Sound Exchange is a sound file converter which also
does sample rate conversion and some sound effects.
This has been called the swiss army knife of sound tools.
The sound file formats understood by SoX include:
- RAW sound data in various data formats;
- RAW textual sound data;
- Microshaft WAV files (PCM, U-law, A-law, ADPCM read only,
IMA ADPCM read only);;
- MAUD files;
- Sound Blaster VOC files;
- IRCAM SoundFile files;
- Sun au files (PCM, U-law, A-law, G7xx ADPCM files);
- mutant DEC au files;
- Apple/SGI AIFF files;
- CD-R data, i.e. music CD format;
- GSM raw data (with an optional library);
- Mac HCOM files;
- Sounder files;
- NeXT snd files;
- Soundtool (DOS) files;
- Psion (palmtop) A-law files; and
- recording and playing from OSS /dev/dsp
or Sun /dev/audio.
The effects that SoX can apply to sound data include:
- channel averaging;
- band-pass filtering;
- a chorus effect;
- cutting out loop samples;
- adding an echo or sequence of echos;
- applying a flanger effect or a high- or low-pass filter;
- adding masking noise to a signal;
- applying a phaser effect;
- converting from stereo to mono and vice-versa;
- changing sampling rates via several different algorithms;
- applying a reverb effect;
- reversing sound samples;
- adding the Fender Vibro-Champ effect; and
- displaying general statistics of sound samples.
A source code distribution of SoX is available as are binary
packages for Linux Intel.
It is written in C and should compile
on most UNIX platforms.
Its use is documented on the site as well as in the
distribution. The second URL is the original home page while the second
contains an updated version with some new capabilities and several
- An SGML system conforming to
International Standard ISO 8879. It is a free, object-oriented
toolkit for SGML parsing and entity management.
The features of SP include:
- nsgmls, a program which parses and validates an
SGML document whose entity is specified by system identifiers
and prints to standard output a simple text representation of
its Element Structure Information Set (ESIS);
- spam, a markup stream editor or normalizer;
- sgmlnorm, a normalizer which focuses on producing
the same ESIS rather than preserving details of the markup;
- sx, converts from SGML to XML;
- spent, a program providing access to SP's entity manager;
- access to all the information about an SGML document, e.g.
to DTD and SGML declarations as well as document instance,
to markup as well as abstract document, etc., sufficient
to recreate an identical copy of any SGML document;
- support for almost all optional SGML features, e.g. arbitrary
concrete syntaxes, SHORTTAG, OMITTAG, RANK, SUBDOC,
- a sophisticated entity manager which supports ISO/IEC 10744
Format System Identifiers, SGML Open catalogs, and WWW and
can be used independently of the parser;
- support for multi-byte character sets, e.g. ISO/IEC 10646
Unicode, Japanese character sets (Shift-JIS, EUC), etc.; and
- production quality tested using several SGML test suites.
The SP distribution is available as source code. It is
written in C++ which can be compiled using gcc 2.7.2 or
later. Binary versions are also available for MS-DOS,
Linux Intel, DEC Alpha, Sun Solaris, and Windows NT and 95
- SP (Semidefinite Programming)
- The Semidefinite Programming software is an implementation
of Nesterov and Todd's primal-dual potential reduction method for
The package includes the full source code (written in C),
a Matlab interface to SP (although it can also
be used directly), Matlab examples, and the documentation.
The C source code includes calls to LAPACK.
The documentation is a user's manual in PostScript format.
See also CSDP, INCT,
SDPpack, and SDPSOL.
- The stochastic process analysis of
computer experiments package is for the analysis
of data with Gaussian stochastic processes, i.e. the analysis and
optimization of computer models or
Its major functions are:
A source code distribution of this C++ package
is available along with a manual in PostScript format.
- fitting the model;
- cross-validating the model fit;
- predicting new design sites using the fitted model;
- visualizing main and joint effects;
- minimizing a response in stages or automatically with
a supplied function of the response.
- A program which spatializes sound using a script by placing and
moving mono sound files using 3-D coordinates.
It will render the same script in stereo, Ambisonics, or
in crude mono.
The features of Space include:
- the use of delay lines to correspond to the distance the sound
is from the listener;
- the use of low-pass filtering and the inverse-square law to further
process the signal as it travels long distances;
- the capability for sounds to stay motionless, move in straight lines,
or in long arcs;
- the capability of mixing in pre-spatialized sound files which are
in the same format as the output;
- the use of Angled Cardiod Virtual Microphones to record the two
signals used for stereo;
- the inclusion of Ambisonic decoding equations so the system can be
modified to produce a four speaker feed; and
- the reflection of sounds off of configurable walls within a simple
room model to generate early reflection images or cruder echoes.
A source code distribution of Space is available.
Compilation requires C,
Yacc, and Lex and
it works by creating a shell and using the
Csound package to process output.
- A library for performing calculations involving 3-D kinematics and
dynamics of systems of rigid bodies.
It is based on an extension of the 4x4 transformation matrix approach
that adds 4x4 matrices for the velocity and accelerations (angular
and linear) plus similar matrices for forces, torques, angular and linear
momentum, and inertia.
The functionality of the library includes:
Both Matlab and C source
distributions of the library are freely available.
User's guides for both versions are available in PostScript format
as are several technical reports.
- basis operations on matrices;
- basic operations on points, lines and planes;
- basic operations of vectors;
- transformation matrices;
- velocity and acceleration matrices;
- Cardan/Euler angles; and
- linear systems.
- Send PACket is a collection of tools that can be used
to generate and send arbitrary packets to a UNIX socket.
It was originally written as part of a
firewall testing project,
and is designed to be modular and allow maximal control over the
design of the packet.
SPAK consists of several programs including:
A source code distribution of SPAK is available. It is written
in C and can be compiled on most UNIX flavors.
- makeip, which makes an IP packet;
- maketcp, which makes a TCP packet;
- makeudp, which makes a UDP packet; and
- sendpacket, which sends a packet to a socket.
- A combination glue/scripting/prototyping
The design goal of Spanner was to glue together software components
written in C++.
It is interpreted but can be translated to C++ and then compiled
if speed is of great necessity.
The syntax is similar to C although it is easier to use since
variables need not be declared. Strings, lists and associative
arrays are built into the language as first class objects.
Binary and source distributions of Spanner are available.
- A portable, fast graphics toolkit designed specifically for 16-bit graphics.
This library sits on top of a display system such as
The features include:
- raw and transparent blitting;
- alpha blending;
- font loading and rendering;
- native surface management;
- conversion from 16 to 24 bpp formats and vice-versa;
- loading/saving of raw PPM format images;
- RGB value mapping;
- extraction of RGB values from pixels;
- coordinate reference precalculation;
- a 16-bit memset;
- area clipping;
- horizonal and vertical lines;
- filled and empty rectangles;
- circles; and
- several demos including a 3-D starfield, image explosion, etc.
- A set of C subroutines for solving large sparse real or complex
systems. Besides being able to solve large linear systems it
solves transposed systems, finds determinants, and estimates
errors due to ill-conditioning in the system of equations and
instability in the computations. It is generally as fast or
faster than other sparse matrix packages when solving many
matrices of similar structure.
Sparse has several features beyond the basic creation, factoring
and solving of systems of equations. These include the ability
to handle both real and complex systems of equations, the ability
to quickly solve the transposed system, the dynamic allocation
of memory for matrix elements, the ability to efficiently compute
the condition number of the matrix, the ability to do much of
the matrix initialization and to preorder modified node admittance
matrices, the ability to exploit sparsity in the right-hand-side
vector, the ability to scale matrices prior to factoring to reduce
uncertainty in the solution, and much more.
The Sparse package includes the C source code, a user's guide
in ASCII and Troff format, and a selection of test matrices.
- The NIST Sparse BLAS library
provides computational kernels for fundamental sparse matrix
operations such as sparse matrix products and solution of
triangular systems. This package supports various sparse
formats such as compressed-row, compressed-column, and coordinate
storage formats (together with block and variable-block versions
The source code for Sparse BLAS is written in ANSI C and the routines
are callable from Fortran and C through the standard interface.
The source code is available along with a user's guide and
various other types of documentation in PostScript format.
- A C++ class library for efficient sparse matrix computations
across various computational platforms. The package consists
of matrix classes encompassing several sparse storage formats
and provides basic functionality for managing sparse matrices.
Various preconditioners commonly used in iterative solvers for
linear systems of equations are included. The focus is on
support for iterative methods (e.g.
but the objects in this package can be used in their own right.
SparseLib++ matrices can be built out of nearly any C++
matrix/vector classes and is shipped with the
MV++ classes. A PostScript
manual is available.
- A C or C++ routine which computes the QR decomposition of
a sparse matrix using row ordering.
See Robey and Sulsky (1994).
- A basic toolkit for sparse matrix computations which takes the
form of a general purpose Fortran
library. It includes several useful tools for developing
and implementing sparse matrix techniques, particularly for
iterative solvers. Examples of the tools available include programs for
converting data structures, printing simple statistics on
a matrix, and plotting a matrix profile.
It contains just about any algorithm you
might need for performing a sparse matrix operation as well as
several iterative accelerators and efficient preconditioners.
The distribution also includes a repository of sparse matrices.
SPARSKIT can handle conversions among most commonly used sparse matrix storage
formats including the dense, LINPACK
banded, compressed sparse row, compressed sparse column,
coordinate, Ellpack/ITPACK generalized
diagonal, diagonal, block sparse row, modified compressed sparse
row, symmetric skyline, nonsymmetric skyline, linked list,
jagged diagonal, symmetric sparse skyline, unsymmetric sparse
skyline, and variable block row formats.
Non-algebraic operations available include extraction of rectangular
submatrices, filtering and sorting matrix elements, in-place
transpositions, copying, extracting diagonals and upper and lower
matrix portions, column and row permutations, extracting bandwidth
information, and more.
A module called BLASSM (Basic Linear Algebra Subroutines for Sparse
Matrices) contains subroutines for computing various matrix products
A MATVEC module contains routines for matrix by vector products and
various sparse triangular solution methods.
A matrix generation module contains routines for generating various
symmetric and nonsymmetric matrices as might result from finite
difference or finite element algorithms.
An iterative solution module contains various subroutines including
conjugate gradient, biconjugate gradient, generalized minimum
residual (GMRES), several GMRES preconditioners, etc.
A source code distribution of SPARSKIT is available.
It is written in Fortran 77 and
takes the form of a library of efficient and well-tested
subroutines. It is documented in a user's manual
available in PostScript format
as well as in some technical reports.
- Spatial Statistics Toolbox
- A Matlab toolbox for estimating large-scale
lattice models that includes code for simultaneous spatial
autoregressions (SAR), conditional spatial autoregressions (CAR), and
mixed regressive spatially autoregressive (MRSA) models.
This toolbox includes most of the common estimators uses in spatial
econometrics. It also uses sparse matrices and other techniques to
accelerate computations and expanded the size of data sets that can
The components are divided into several categories.
The spatial weight matrix functions are:
- fclosestnn1, finds the closest neighbors to each observation;
- fdelw1, creates a spatial weight matrix using Delaunay triangles;
- fnndel1, creates individual neighbor weight matrices from first
and second order Delaunay neighbors;
- fnnsym1, creates overall symmetric weight matrices from
neighbor weight matrices;
- fnnasym1, forms overall asymmetric weight matrices from
neighbor weight matrices.
The spatial Jacobian computation and spatial autocorrelation testing
- fdetfil1, computes ln |l-aD| where D is a symmetric spatial
- fdetinterp1, similar to fdetfil1 but uses spline
interpolation to reduce determinant computations;
- fdetinterpasym1, similar to fdetinterp1 but handles
asymmetric weight matrices; and
- fary1, computes ML for a single vector or collection of vectors.
The lattice model estimation functions are:
- fcar1, computes maximum likelihood estimates for CAR errors;
- fclosestmix1, computes closed-form maximum likelihood estimates
when using only the nearest neighbor;
- fsar1, computes maximum likelihood estimates for SAR errors;
- fmix1, computes maximum likelihood SAR estimates with spatially
lagged X and Y;
- fpar1, computes maximum likelihood SAR estimates with spatially
lagged Y but not X;
- flagx1, computes maximum likelihood SAR estimates with spatially
lagged X and likelihoo ratios for the hypothesis that a variable and its
spatial lag have no effect; and
- flagx2, computes maximum likelihood SAR estimates with spatially
lagged X and likelihood ratios for the hypothesis that each individual
variable (lagged or not) has no effect.
The lattice model simulation and non-spatial estimation functions are:
- fsimcar1, simulates CAR random variables;
- fsimsar1, simulates SAR random variables;
- fsimmix1, simulates mixed and pure SAR random variables; and
- fols1, computes OLS with likelihood ratios in the same
form as fcar1, fsar1, etc.
- Speak Freely
- An application that allows you to engage in bidirectional conversations
over the network. Speak Freely uses both GSM
compression and sample interpolation to reduce the data bandwidth
sufficiently to allow conversations over the Web.
Conversations can also be encrypted using either DES or IDEA.
The individual programs that comprise the package are:
- sfmike, for sending sound to remote hosts;
- sfspeaker, to receive sound from remote hosts;
- sflwl, a client program which requests information from a
server running the Look Who's Listening server;
- sflwld, the Look Who's listening server which maintains
a list of users running Speak Freely who have identified themselves;
- sfecho, a server program that receives sound from a remote
host, buffers it, and then retransmits it to the sending host;
- sfreflect, operates a conference reflector; and
- sfvod, which monitors connections to a given port.
A source code distribution of Speak Freely is available.
The supplied makefile includes instructions on how to compile on
several UNIX platforms including Linux Intel.
The utilities are documented in separate man pages.
- A Starlink Project package
for SPECtroscopy Data REduction.
A typical SPECDRE data set is contained within a
hyper-cube where each row or hyper-column is a spectrum.
Any line or continuum fits calculated are stored along with
the data in this format, as well as are bad values or errors.
Variance information can also be included and is used in
the processing steps, e.g. for statistical weights, if present.
A SPECDRE extension to the basic NDF data format is used which
is recognized by all SPECDRE applications and uncritically
propagaged by other packages.
The tasks performed by the SPECDRE applications include:
- using the data and errors of hyper-cubes to write to or read
from printable/editable tables;
- plotting of spectra and data with full control of various
aspects such as font, color, line styles, error bars, etc. as
well as overlay on previous plots according to their world
coordinates if possible;
- hyper-cube manipulations such as extraction of averaged hyper-planes,
assembly of hyper-cubes from hyper-planes, and filling in hyper-cubes
from several other hyper-cubes;
- resampling capabilities including resampling all spectra in a
hyper-cube or resampling and averaging into one spectrum any
number of input spectra; and
- spectral fits using polynomials, blended Gauss, or triangle
profiles with fit results stored along with data.
A binary distribution of SPECDRE is available for DEC OSF/1,
Linux Intel, and Sun Solaris platforms.
The package is documented in a 78 page user's manual available
in PostScript format.
- A collection of portable Fortran
routines for calculating special functions.
The routines include:
- ALGAMA, for calculating the log(gamma) function for positive
- DAW, a program to evaluate Dawson's integral for real arguments;
- EI, for computing various exponential integrals;
- ERF, for computing the error function and its variants;
- GAMMA, for calculating the gamma function for a real argument;
- I0 and I1, for modified Bessel functions
of the first kind and order zero;
- J0Y0 and J1Y1, for zero- and first-order Bessel functions
of the first and second kind;
- K0 and K1, for modified Bessel functions of the second kind
and orders zero and one;
- PSI, for evaluating the logarithmic derivative of the gamma function;
- REN, a random number generator;
- RIBESL, for Bessel functions of non-negative argument and order
with or without exponential scaling;
- RJBESL, for Bessel functions of non-negative argument and order;
- RKBESL, for modified Bessel functions of the second kind of
non-negative argument and order and with or without exponential scaling;
- RYBESL, for Bessel functions of non-negative argument and order;
- MACHAR, for determining the parameters of the floating-point
arithmetic on a given machine.
A source code distribution of SPECFUN is available.
All of the programs are written in Fortran and are available in
single and double precision versions.
Each program is documented in comment statements within the program.
This is TOMS algorithm 715 and is documented
in Cody (1993b).
- A rewrite of SpecTcl for use with
- A development environment for building applications with
graphical user interfaces that run on multiple platforms.
The SpecTcl packages lets you design GUIs interactively
uses a geometry manager precise enough to keep elements aligned
across all platforms,
enables the fast development of applications that can require
many more lines of code in traditional procedural languages,
provides flexibility at runtime to to, e.g. generate menus
allows the integration of Tcl/Tk
scripts with scripts generated in SpecTcl,
allows the quick alternation between design and execution for
quick feedback on changes,
produces executable files that use Tcl/Tk and don't require
SpecTcl for use, and
lets you develop and test simple applications separately and
then combine them into subassemblies of a larger application.
A source code distribution of SpecTcl is available.
It is written in Tcl/Tk and requires recent versions of
those to work.
It is documented in a user's guide available in PostScript
and PDF formats.
- spectral analysis
- Packages for performing various types of spectral analyses include:
- Cubic Spline Library,
- Matlab Astronomy Library,
- STARPAC, and
- The S-coordinate Primitive Equations Model
is a finite difference ocean circulation model written in
It has been used for a variety of regional and basin scale
The features of SPEM include:
- an s-coordinate generalized topography following vertical coordinate
designed to retain resolution in the upper ocean even over deep
water so the mixed layer can be uniformly resolved independent of depth;
- staggered finite differences in the vertical;
- three available example simulations;
- floats and rotated mixing tensors;
- several C preprocessor flags to modify the model before compilation;
- options for using implicit time steps on the vertical viscosity and
- options for computing the vertical diffusion and viscosity
- an option for using NetCDF for input and
The source code is available. It is written in Fortran 77
and can be compiled with several Fortran compilers, including g77.
A user's guide is available in PostScript
The NCAR Graphics library is required for using the built-in
graphics capabilities of SPEM.
A package called gridpak is also available for creating
curvilinear orthogonal grids for use with SPEM.
- Spharmonic Kit
- A collection of routines that implement discrete Legendre and spheric
harmonic transforms via several different algorithms.
Some algorithms also include inverse transforms and routines for
The included Legendre algorithms are:
The included spherical algorithms are:
- a variation of the basic Driscoll-Healy algorithm;
- a bounded DH-Mid algorithm; and
- simple-split and hybrid algorithms.
- a hybrid transform (based on the hybrid Legendre transform) that
precomputes in memory all needed Legendre polynomial cosine transforms;
- a hybrid transform that reads the precomputed data off disk;
- a spherical convolution routine that uses the hybrid transform in
the forward direction and a semi-naive algorithm in the reverse, and
precomputes in memory prior to transforming;
- a version of the immediately previous that reads precomputed data
- A Fortran package for computing travel-times
in a spherical earth.
SPHERAY computes travel-times, epicentral distances, amplitudes, phases,
etc. using geometric ray theory in an isotropic spherical earth model.
The features include:
- use of an analytical expression for the integrals giving the
epicentral distance and travel-time increments in a layer wherein
the velocity varies linearly with radius (allowing a typical model
to be described with only about 40 layers);
- recognition of standard wave names such as pP, PKIKP, SKKS,
PcP, sPcS, etc.;
- acceptance of wave names built on discontinuities other than those
on which the standard names are based (as per a set of conventions);
- computation of the amplitude and polarization if the focal
mechanism is given;
- computation of amplitude changes and phase shifts due to reflection
and transmission along the ray;
- independence of particular planet models or p-delta tables, i.e.
for each considered wave a suite of rays that span the entire range of
allowed parameter values are shot;
- interactive, event-station oriented and network modes; and
- correction of epicentral distance from event to station for
- The SPeech HEader REsources library provides an
interface to NIST SPHERE-formatted speech waveform files.
The primary components of the package are a C
interface library and system level file manipulation utilities.
The library was developed to provide a simple, intuitive interface
to access and manipulate SPHERE files.
The utilities were written using the SPHERE library and allow
command-line manipulation of SPHERE files as well as functional
examples of the usage of the libraries.
The library functionality is divided into five main areas:
The available system level utilities include:
- file access functions;
- header manipulation functions;
- waveform I/O and conversion functions;
- file I/O error status functions; and
- data (waveform) buffer allocation and deallocation functions.
- h_read, readers headers from files;
- h_add, adds an empty header to raw unheadered speech samples;
- h_strip, strips the SPHERE header from an input file;
- h_edit, for editing specified header fields;
- h_delete, for deleting specified header fields;
- w_encode, encode the file in one of several available formats;
- w_decode, decode a file in a specified output format;
- w_edit, for manipulating and sampling waveform data
in a file; and
- w_diff, for comparing waveforms.
- An integrated toolkit for spatial interpolation and comparison
of spatial interpolation algorithms developed at the
(National Center for
Geographic Information and Analysis).
The capabilities of the package include large-scale interpolation,
smart interpolation, and error analysis.
Spherekit can interpolate over continental and global scales since
its computations are based on spherical distances and orientations,
as opposed to conventional interpolations based on various planar
projects of the Earth. It also permits the user to incorporate
knowledge or information about the processes that produced the
spatial fields in a process called smart interpolation. This is
implemented via the interpolation of user-defined, derived
variables. The performance of an interpolation method and its
associated set of parameters is evaluated using cross-validation
wherein the error at each observation point is defined as the difference
between its actual value and its estimated value using the remaining
n-1 points. The available interpolation methods are inverse distance
weighting, triangulation, kriging, multiquadric, and thin plate
Spherekit is UNIX based and includes a complete graphical interface.
The source code is available and should compile on most generic
UNIX platforms. It uses the
GMT package for displaying
- A library of 17 Fortran 77 routines for
computing spherical harmonic analyses and syntheses.
Harmonic analysis is used for problem solving in spherical coordinates
in the same way that Fourier analysis is used in Cartesian coordinates.
It simplifies the tasks interpolation and smoothing on the sphere,
and significantly lessens the problems of solving partial differential
equations (PDEs) on the sphere.
The options include that the grid in the latitudinal direction can be
either Gaussian or equally spaced, the number of grid points in either
latitude or longitude are arbitrary, the analysis can be performed
either on the entire sphere or only in the northern hemisphere,
the associated Legendre functions can either be stored or recomputed
as needed, multiple analyses or syntheses can be specified, and the
spectral truncation is completely under user control.
SPHEREPAK uses Gaussian integration to compute the analysis in the
programs that use a Gaussian grid in the latitude direction, and
uses multiple vectorized FFTs in the longitudinal direction.
The programs in SPHEREPAK are:
- SHAEC, for computing an analysis on a equally spaced grid using
- SHAECI, for initializing an array that may be used repeatedly
- SHSEC, for computing a synthesis on an equally spaced grid using
- SHSECI, for initializing an array that may be used repeatedly
- SHAES, for computing an analysis on a equally spaced grid using
- SHAESI, for initializing an array that may be used repeatedly
- SHSES, for computing a synthesis on an equally spaced grid using
- SHSESI, for initializing an array that may be used repeatedly
- SHAGC, for computing an analysis on a Gaussian grid using
- SHSGC, for computing a synthesis on a Gaussian grid using
- SHIGC, for initializing an array that may be used repeatedly by
either SHAGC or SHSGC;
- SHAGS, for computing an analysis on a Gaussian grid using stored
- SHSGS, for computing a synthesis on a Gaussian grid using stored
- SHIGS, for initializing an array that may be used repeatedly
by either SHAGS or SHSGS;
- DNLFK, which computes the Fourier coefficients in the trigonometric
expansion of the associated Legendre functions;
- DNLFT, which computes the associated Legendre functions using
the coefficients computed by DNLFK; and
- GAQD, which computes the Gaussian latitude and weights that
are used in the Gaussian integration.
A source code distribution of SPHEREPAK is available.
All the programs are written in Fortran 77. Several demonstation programs
are also included. The documentation is mostly contained within the
source code files.
- An open source speech recognition
software package that uses the FBS8 decoding engine.
The main features include:
- continuous speech decoding as opposed to isolated word recognition;
- speaker independence, i.e. a user isn't required to train the system;
- provision of a single best or several alternative recognitions;
- semi-continuous acoustic models; and
- bigram or trigram language models.
The components of Sphinx are the recognition engine and the libraries
that implement the API. These are divided into three main groups for
raw audio access, continuous listening/silence filtering, and
the core decoder itself.
The low-level audio access group provides platform-dependent code
encapsulated within a generic interface to audio recording and playback.
The functions include:
A similar set of playback functions are available.
- ad_open, opens an audio device for recording;
- ad_start_rec, starts recording on the audio device;
- ad_read, reads a specified number of samples into a buffer;
- ad_stop_rec, stops recording; and
- ad_close, closes an audio device.
The available functions for continuous listening and silence
- cont_ad_init, associates a new continuous listening
module with a specified raw A/D handle and a corresponding read function
- cont_ad_calib, calibrates the background silence level;
- cont_ad_read, reads and returns the next available
block of non-silence data;
- cont_ad_reset, flushes data buffered in the module;
- cont_ad_set_thresh, for adjusting the silence and
- cont_ad_detach, detaches a module from an audio device;
- cont_ad_attach, attaches a module to an audio device
without needing to calibrate the device; and
- cont_ad_close, closes a listening module.
- A general purpose circuit simulation program for nonlinear DC,
nonlinear transient and linear AC analyses.
The simulated circuits may contain resistors, capacitors, inductors,
mutual inductors, independent voltage and current sources, four
types of dependent sources, lossless and lossy transmission lines,
switches, uniform distributed RC lines, and the five most common
semiconductor devices, i.e. diodes, BJTs, JFETs, MESFETs and
A post-processing program called nutmeg is also available
for plotting simulated output.
The types of analyses that may be performed using Spice include:
- DC analyses that determine the DC operating point of circuits with
inductors shorted and capacitors opened;
- AC small-signal analyses that compute the output variables as a function
- transient analyses to compute output variables as a function of time
over a specified time interval;
- pole-zero analyses that compute the poles and/or zeros in the
small-signal AC transfer function;
- small signal distortion analyses that compute steady-state harmonic
and intermodulation products for small input signal magnitudes;
- noise analyses of device-generated noise for a given circuit; and
- analyses of circuit at a specified range of temperatures.
Circuits to be analyzed by Spice are described by a set of element lines
that define the circuit topology and element values as well as a set
of control lines that define the model parameters and the run controls.
Each element is specified by an element name, the circuit nodes to
which it is connected, and the values of the parameters determining
the electrical characteristics of the element.
The available elements include resistors, capacitors and inductors,
coupled (mutual) inductors, transmission lines (lossless and lossy),
linear and nonlinear dependent sources, independent sources (e.g.
pulses, sinusoids, exponential, piece-wise linear, and single-frequency
FM), switches and semiconductor devices.
Available semiconductor devices in Spice include:
- semiconductor resistors and capacitors;
- uniform distributed lossy RC lines;
- junction diodes;
- bipolar junction transistors (BJTs);
- junction field-effect transistors (JFETs); and
- MOSFETs and MESFETs.
A source code distribution of Spice is freely available.
Support was halted for The original Berkeley distribution in 1994,
after which various other groups compiled versions for various
Linux versions are available at Metalab and its mirrors
for versions 3f4 and 3f5, with the latest
version of the latter known as SpiceCAD.
RPM versions are also available in the usual places.
There is also a project to enhance Spice called
A user's manual is available in PostScript format.
- A GNOME application for
schematically capturing electrical
circuits simulated using Spice.
- A preprocessor for Berkeley Spice 3f5 that
adds support for structures provided by commercial versions of the program.
- A software simulator that runs
assembly language programs for
the MIPS R2000/R3000 processors which can read and immediately
run files containing assembly language code.
It can also read and run MIPS a.out files.
SPIM implements almost the entire MIPS assembler-extended
Other features include a debugger, an X Window interface,
a command line interface, a torture test to verify a port to
a new machine, and an optional extension that performs a
cycle-by-cycle MIPS simulation exposing the hardware pipeline.
A source code distribution of SPIM is available. It is
written in C and can be compiled and used on most UNIX
A user's manual is available in either
- A package which supports the formal verification of distributed
Spin has been used to trace logical design errors in distributed
systems design such as operating systems, data communications
protocols, switching systems, concurrent algorithms,
railway signaling protocols, etc.
It checks the logical consistency of a specification and
reports on deadlocks, unspecified receptions, flags incompleteness,
race conditions, and unwarranted assumptions about the
relative speeds of processes.
A design is verified by building a formal model with the Spin
input language PROMELA (Process Meta Language), which contains
the primitives for specifying asynchronous (buffered) message
passing via channels with arbitrary numbers of message parameters.
It also allows for the specification of synchronous message passing
systems and mixed systems using both.
The language can model dynamically expanding and shrinking systems with
new processes and message channels capable of being created and deleted
on the fly.
Correctness properties can be specified as standard system or process
invariants using assertions or as general linear temporal logic
Spin can be used in three basic modes:
- as a protocol simulator, allowing for rapid prototyping with
random, guided, or interactive simulations;
- as an exhaustive state space analyzer, capable of rigorously
proving the validity of user specified correctness requirements; or
- as a bit-state space analyzer that can validate even very large
protocol systems with maximal coverage of the state space (a proof
A source code distribution of Spin is available.
It is written in ANSI C and portable to most flavors of UNIX.
It is documented in a user's manual, a man page, some research
appears, and a book, all of which are available in
PostScript and other formats.
See Holzmann (1991).
- SPIN (OS)
- A project to build an OS that blurs the distinction between kernels
and applications. In SPIN applications can specialize the kernel
by dynamically linking new code into the running system. Kernel
extensions can add new kernel services, replace default policies,
or migrate application functionality into the kernel address space.
Sensitive kernel interfaces are secured via a restricted linker and
the type-safe properties of language in which it is programmed,
A source code distribution of the SPIN OS is available.
It is currently (12/98) built on a Linux system with
Modula-3 installed and has to be booted
on a machine with a
FreeBSD file system.
Quite a bit of documentation is available at the site.
- A program that superimposes colored graphs onto 2-D plots of
results of various projection methods as
analysis (PCA), nonlinear mapping (NLM), and self organizing
maps (SOM) that are used for analyzing multidimensional
data via dimensional reduction.
The colors of the graph edges encode the original
high dimensional distances between the connected points, allowing
the distortions produced by the projection
methods to be viewed.
Spinne can handle input data in four different ASCII formats
and can output results in PosScript format.
Binary versions of spinne are available for
MS-DOS, NextSTEP, SGI IRIX, and Linux Intel platforms.
A user's manual is supplied in PostScript format.
- This HTTP server software has been renamed
- The Sound Processing Kit is an object-oriented
class library for audio signal processing which includes
classes for various signal processing tasks written in
SPKit contains more than 20 classes including signal routing
and processing modules such as a multiplexer, an amplifier,
a signal inverter, sum units, delay lines, and a set of filters.
The SPKit classes are divided into several categories.
A sound input/output classes include:
The basic signal processing classes are:
- SPKitReader, which reads audio files in
16 bit linear NeXt/SUN format; and
- SPKitWriter, which writes files in the same format.
A dynamics processing class includes:
- SPKitAmp, an amplifier class which multiplies input samples
by a gain value;
- SPKitInverter, which outputs an input signal in opposite phase;
- SPKitMult, which multiplies two input signals with each other; and
- SpKitRectifier, which outputs absolute values of input signals.
The filtering classes are:
- SPKitCompressor, a signal amplitude compressor class which scales
the amplitude of input signals by a user-specified compression ratio;
- SPKitGate, which compares the input signal amplitude with
the threshold level and scales the amplitude to zero if the former is
less than the latter;
- SPKitLimiter, which scales the amplitude of an input signal to
match a maximum output level indicated by a threshold value; and
- SPKitCompressorLimiter, which feeds the input signal through
a compressor followed by a limiter.
The delay and reverberation class includes:
- SPKitBWLowPassFilter, a Butterworth low-pass filter;
- SPKitBWHighPassFilter, a Butterworth high-pass filter;
- SPKitBWBandPassFilter, a Butterworth band-pass filter;
- SPKitBWBandRejectFilter, a Butterworth band-reject filter; and
- SPKitResonator, a second-order all-pole
A distortion class contains
- SPKitDelay, a delay line class;
- SPKitFBDelay, a delay line class specialized for use in
a feedback loop;
- SPKitSchroederReverb, a reverberator class;
- SPKitAllPassNetwork, an implementation of an
allpass network or filter;
- SPKitComb, a comb filter class; and
- SPKitCombLowPass, a comb low-pass filter class.
A signal routing class comprises:
- SPKitWaveShaper, a waveshaping or non-linear distortion class.
- SPKitFeedBack, which outputs the summed signal of two inputs;
- SPKitMux, a signal multiplexer; and
- SPKitSum, which outputs the summed signal of one or more inputs.
A source code distribution of SPKit is available. It is written
in bare-bones C++ (i.e. templates and exceptions aren't needed).
It requires ANSI C standard libraries and uses ANSI C routines
for sound file I/O.
- The spectral transform library contains
programs for a variety of spectral transform functions.
It can handle both scalar and 2-D vector fields.
Some splib functions are spectral interpolations between
two grids, spectral truncations in place on a grid, and basic
spectral transforms between grid and wave space.
The programs in splib are written in Fortran 77
and are documented internally as well as in a large ASCII document
which also contains several example programs.
See also iplib.
- A library of iterative solvers with preconditioners for rapid
prototyping of solvers for nonsymmetric linear systems of
equations. SPLIB was primarily developed for comparing iterative
methods and preconditioners in a uniformly coded implementation
while facilitating interdisciplinary collaboration, although the
solvers themselves are also of research interest.
It is written in Fortran 77 and can be
called as a subroutine from Fortran, C or C++. The number of
arguments that have to be passed has been kept as small as
possible, and common blocks are avoided except internally.
The code is heavily instrumented to provide information such
as convergence history, memory usage, and CPU time used.
SPLIB implements 13 iterative solvers and 7 preconditioning
methods, with the preconditioners including those that allow
multiple levels of fill-in through positional and numerical
strategies. All preconditioners are parameterized.
The iterative methods available are BICG, CGNE, CGNR,
CGS, CGSTAB, GMRES, QRMTF, BICGS, GMREST, JACOBI, GAUSS, SOR,
and ORTHM. The preconditioners are ILU, MILU, ILUT, SSOR,
TRID, ILU0, and ECIMGS.
A source code distribution of SPLIB is available. It is written
in Fortran and reasonably portable to most compilers with
a tweak or three.
It is documented in a user's manual and reference guide
available in PostScript format.
- This is a set of Fortran routines for spectral methods, efficient
tools for recovering accurate approximate solutions to differential
equations in terms of high-degree trigonometric or algebraic
polynomials. The polynomials bases used in this library include
Jacobi, Legendre, Chebyshev, Laguerre and Hermite, and the integration
formulas include Gauss, Gauss-Lobatto, and Gauss-Radau. A 180+ page
PostScript format manual and reference guide resides in the same directory.
- A Fortran package for computing synthetic
seismograms of shear waves split by travelling through a stack of
The seismograms are computed by solving the Eikonal equation.
- A subroutine which solves linear
The user inputs the number of constraints and the number of entries
in the solution vector, the coefficients of the linear objective
function, the coefficient matrix, input parameters defining
the form of the bounds for the unknowns, and an array containing
switches for modifying various parts of the routine.
A source code distribution of SPLP is available.
It is written in Fortran 77 and documented via comment statements
contained within the source code file.
This is part of CMLIB.
- A Matlab toolkit implementing Statistical
Parametric Mapping for users familiar with the
underlying statistical, mathematical, and image processing
concepts (i.e. you really need to understand to concepts to
use the software). It is used to test hypotheses about neuro-imaging
data fro SPECT/PET and fMRI sensors.
The SPM approach can be (reasonably briefly) summarized
as a procedure in which:
images are spatially normalized into a standard space and smoothed;
parametric statistical models are assumed at each voxel with hypotheses
expressed in terms of the model parameters assessed at each voxel using
univariate statistics; and
comparisons of all of the voxel statistics are simultaneously assessed
using the theory of continuous random fields.
The functionality of SPM includes:
- realignment of image sequences,
- automated non-linear spatial normalization using basis warps of
discrete cosine transforms,
- image segmentation into grey/white/CSF tissue types,
- spatial smoothing via convolution with Gaussian kernels,
- formation and assessment of statist images,
- manipulation of results (e.g. plotting, overlaying statistical
results onto structural images, rendering on template surface volumes),
- eigenimage analysis,
- global adjustment and image averaging, and
- image calculations.
A source code distribution of the SPM Matlab toolkit is
available. It consists mostly of Matlab M-files and functions
although some external C programs are also compiled and linked to
Matlab via C-mex files. This is known to work with Matlab 4.2c.
A great deal of documentation is available including technical
reports and a set of tutorial course notes on both the use of
the package and the methods used in the package.
- A high-end molecular graphics package for displaying protein and nucleic
acid structures as well as a powerful search engine which allows users
to search through a directory of PDB files for proteins with specific
Spock provides typical molecular visualization views (e.g. ribbons of
several types, line and rod bonds, etc.) as well as molecular and
accessible surfacing routines. It also provides interfaces to
DSSP for reading secondary structure information and a
quasi-WYSIWYG interface for Molscript for producing publication
Spock was designed from the ground up to be powerful,
flexible, easy to use, and to bring molecular modeling
programs into the age of the internet.
The features of spock include:
- use of OpenGL for maximum portability;
- dynamic memory allocation with no hard-coded upper limits on the
size of structures or the resolution of surfaces;
- a choice of bond display modes including line, ball, ball-and-stick,
and cylinder styles;
- a choice of backbone ribbon styles including tubular, rectangular,
secondary structure, and a variable radius style;
- calculation and display of molecular and accessible surfaces;
- calculation and display of 2-D and 3-D isopotential contours;
- determination of hydrogen bonding patterns from structure with
secondary structure determined from this data;
- saving and easily switching between multiple views of a structure;
- defining and independently manipulating subsets of atoms;
- simple modeling features including dynamic bond editing, rotation of
torsion angles, and a simple mutation facility;
- history and macro mechanisms for creating shortcuts to complex scripts;
- use of environment variables for command customization;
- calculation and display of axes of helices and major moments of sheets;
- export of results to Molscript, Raster3D, VRML 1.0 and 2.0 formats;
- a built-in function calculator for applying functions to atomic or
- support for several image formats including
PPM, GIF, TIFF, FBM, and
- a selection mechanism for easily specifying groups of atoms or molecules; and
- an integrated help facility with context-sensitive help which uses an
external WWW browser.
Versions of spock are available for SGI IRIX and Linux Intel platforms.
A user's guide is available in HTML format in addition to the extensive
- A simple system monitoring package written in Perl.
SPONG features include
This is not SNMP-based but rather communicates
via simple TCP-based messages.
The source code for SPONG is available and requires
Perl 5.003 or greater for installation and use. Also required
are a web server which can run
CGI programs and a browser on which
to display results.
- client-based monitoring,
- monitoring of network services,
- grouping of hosts,
- host-specific contact and downtime information,
- configurability on a client-by-client basis,
- results displayable on the Web,
- a problem history,
- messaging via email or pager when problems occur, and
- verbose information to help with problem diagnosis.
- The SParse Object Oriented Linear Equations
Solver is a library for solving sparse real and complex linear
systems of equations.
The functionality includes:
The source code is available as is a massive amount of documentation.
The program is written in object-oriented C.
- computing multiple minimum degree, generalized nested dissection
and multisection orderings of matrices with symmetric structure;
- factor and solve square linear systems of equations with symmetric
structure, with or without pivoting for stability;
- factor and solve overdetermined full rank systems of equations using a
multifrontal QR factorization, in serial or using
POSIX threads; and
- solve square linear systems using a variety of Krylov iterative
- A Web-based discussion board software package with a unique interface,
extensive administrative features, and easy installation.
The detailed features of Sporum include:
A freely available version is available with the above functionality, and
a commercial version with additional features can also be obtained.
- storage of all information (e.g. messages, configuration data, etc.)
in a server-side SQL database such as
- a cookie-based login option;
- support for both flat and threaded message organization;
- user profile information for specifying email, homepage, default
display and view modes, default sort order, etc.;
- a choice of forum types including public, public protected, private and
- tracking of new post information for individual users;
- a search engine with a choice of searching ranges and
boolean queries; and
- a browser-based administration interface with options including
assigning users to be moderators, creating new boards, reordering existing
boards, modifying/deleting existing boards, etc.
- The Statistical Pattern Recognition and
Artificial Neural Network LIBrary is
a combination of the former SPRLIB and ANNLIB packages, the
former of which supports the easy construction and simulation
of classifiers and the latter of which contains functions for
creating, training, and testing feed-forward neural networks.
Both use the same set of support routines for memory management,
I/O, and the like so they were combined into SPRANNLIB.
The pattern recognition methods implemented in SPRLIB include:
The feedforward networks supported by ANNLIB are multilayer
perceptrons, shared weight networks, and maximum likelihood
networks. Kohonen networks are also supported.
The available learning methods include backpropagation,
conjugate gradient descent, Levenberg-Marquardt, and
- mean and covariance estimation;
- within and between scatter estimation;
- principal component analysis (PCA);
- random number generators;
- the Fisher linear discriminant function;
- a K-nearest neighbor classifier;
- a nearest neighbor classifier;
- clustering methods;
- Parzen classification;
- a quadratic discriminant function;
- a multiclass Mahalanobis classifier; and
- error estimation routines.
A source code implementation of SPRANNLIB is freely
available for academic or research purposes upon filling out
an online request form.
It is written in C and includes make files for several platforms
including Linux Intel.
The package also uses some of the routines in
Press et al. (1994a) which have to be obtained
A user's guide and reference manual is available either in
- A toolkit and daemon that provide multicast and group communications
support to applications across local and wide area networks.
Spread is designed to make it easy to write full-featured
and reliable groupware, networked
multimedia, reliable server, and collaborative work applications.
Some of the services provided by Spread include:
- reliable multicast from any number of senders to many receivers;
- scalable group services that allow thousands of active groups;
- membership services that inform each instance of an application
which other instances are running, and enables easy recovery from
- agreed ordering of messages to a group, i.e. all receivers receive
messages sent to the group in exactly the same order; and
- FIFO ordering of data streams to allow applications to easily
add networked streaming multimedia without having to make changes to
existing codecs or libraries that expect an in-order stream with
Spread consists of a library with which user applications are linked,
a binary daemon that runs on each computer that is part of
the processor group, and various utility and demo programs.
It is currently (6/98) supported on several platforms including
- Freely available spreadsheets for
Linux platforms include:
- See SPRANNLIB.
- A GIS and image processing system whose capabilities include:
- reading images generated by INPE, SPOT IMAGE and EOSAT;
- importing and exporting data in a wide range of popular
formats, e.g. ARC/INFO GENERATE, AUTOCAD DXF, ASCII, RAW raster
data, and TIFF raster data;
- processing remote sensing images including techniques for
- classification of remote sensing images using traditional or
new techniques developed by the SPRING project, e.g. segmentation
plus region classifiers, mixture models, and Markovian post-classification;
- performing geographic analysis using an object-oriented language
- processing digital terrain models;
- generating TINs and grids from samples;
- producing slope/aspect maps;
- 3-D visualization;
- map generation via a GUI and creating PostScript and HPGL
The SPRING distribution includes:
Extensive documentation including a user's manual, a geoprocessing
tutorial, a programming manual, and a reference manual are available
online in hypertext format.
Binaries are available for several platforms including Linux.
- a set of files shared by all applications, e.g. for interfaces
and menus, on-line help, map symbols, and cartographical projection
- spring, an application containing geoprocessing and image
- scarta, for interactively producing PostScript and HPGL output;
- impima, for reading satellite data in several formats and
from several devices; and
- several sample data sets.
- The Scalable Parallel Random Number
Generators package is a set of libraries for scalable
and portable pseudorandom number generator which has been developed
especially for use in parallel Monte Carlo simulations.
SPRNG provides user-friendly interfaces for parallel
Fortran, C and
which enables the easy use of sufficiently uncorrelated pseudorandom
number streams on different processors with minimal inter-processor
communication. Random numbers can also be generated from more than
one stream on each processor.
The pseudorandom number generators included in SPRNG are:
The MPI message passing software is supported
with PVM support planned for future versions.
- two versions of linear congruential with prime addend,
- modified additive lagged Fibonacci,
- combined multiple recursive
- prime modulus linear congruential generators.
A source code distribution of SPRNG is available. It
is written in C and can be compiled into the five libraries on
several types of parallel and serial platforms including
It is used by linking these libraries to programs written in any
of the abovementioned languages.
The documentation includes quick start and references guides,
a user's guide, a reference manual, and an introductory guide to
parallel random number generators.
- Signal Processing Using C++ was created to
provide communication systems or DSP designers with simple, efficient
and reusable DSP building block objects.
SPUC compares favorably to Matlab (the most popular and useful
current alternative for DSP design) in that it implements a sample
by sample simulation approach that is often most useful for communications
system design, as opposed to Matlab's matrix/block-based approach.
It is also more efficient when dealing with several interactive
feedback loops, and generally outperforms Matlab for bit-accurate
The SPUC library classes include:
- basic building blocks such as complex data types, fixed-bit width
integer classes, pure-delay blocks, Gaussian and random noise, etc.;
- basic DSP building blocks such as FIR, IIR, allpass, running
average and Lagrange interpolation filters, numerically controlled
oscillators (NCOs), cordic rotators, etc.;
- communication functions such as timing, phase and frequency
discriminators for BPSK/QPSK signals and raised-cosine type
FIR filter functions; and
- miscellaneous DSP and communications related functions and
A source code distribution for this C++ library
is available along with a complete manual in
- A system that provides public key based strong authentication for
individual users and server principals in a distributed environment.
Principals install their SPX credentials and then use SPX to generate
authentication tokens to authenticate themselves to remote principals
or to decide whether to accept a token received from a remote
SPX provides strong authentication with the network utilities
flogin, fcp and fsh, all of which permit strongly
authenticated remote access.
- SPX (IRC)
- Sula PrimeriX is a multiple-server
IRC client running under X11.
The features include:
A source code distribution is available.
This is an extension of the earlier sula project.
- channel bookmarks and history for recently visited channels;
- simultaneous connection to multiple IRC servers/networks;
- hosting many channels and DCC chat connections on the same window;
- automatic lag check and display;
- nickname groups for organizing nicknames in circular groups and binding
such groups to servers;
- notify groups;
- a circular command history that can be saved and loaded;
- a flexible and extended ignore feature using timeouts;
- a flexible notify feature in combination with notify groups;
- hook types for all events;
- the use of Guile as a scripting language;
- named connections that allow the use of external programs as scripts
- flexible keybinding routines;
- timers, alarms and clocks to which actions can be bound; and
- high configurability via both X11 resources and the SET command.
- A LAN protocol analyzer with a built-in interface to a capture
facility supporting Ethernet,
Other SPY features include:
An extensive user's manual is available in several popular formats.
- a User Capture Interface (UCI) that allows user programs to feed
packets to SPY;
- provision of prefilters on the MAC and IP layers for reducing
network traffic to relevent data based on addresses or encapsulated
- a built-in protocol description language (PDL) allowing users to
define nearly any protocol; and
- the definition of postfilters using the PDL.
- The Structure Query Language is a language for
accessing data in a relational database.
After this was originally developed by IBM in the late 1970s
many other vendors created
their own dialects, leading to the usual Tower of Babel situation.
ANSI and ISO began developing a standards for this in the early 1980s and
published standards in 1986 and 1987, respectively.
The organizations jointly developed an extension to the standard
called SQL2 or SQL-92 that was released in 1992.
There is currently an ongoing effort to develop SQL3.
SQL is technically a data sublanguage used to interface to a relational
database, with all SQL statements being instructions to that database.
The features include:
The functionality provided by the various SQL commands includes:
- processing sets of data as groups rather than individual units;
- providing automatic navigation of data; and
- standalone statements that are complex and powerful.
- querying data;
- inserting, updating and deleting rows in a table;
- creating, replacing, altering and dropping objects;
- controlling access to the database and its objects; and
- guaranteeing database consistency and integrity.
Useful SQL-related sites include:
- SQL Test Suite
- A test suite for evaluating the conformance of an
SQL implementation to Entry or Intermediate SQL
as specified in ANSI X3.135-1992 and ISO/IEC 9075:1992 through one or
more standard programming language interfaces.
There are also additional tests to evaluate conformance to:
The test contains documentation, schemas and test programs for Interactive
SQL, Embedded SQL C, Embedded COBOL, Embedded Fortran, Embedded Ada,
Embedded Pascal, Module Language C, Module Language COBOL, Module
Language Fortran, Module Language Ada and Module Language Pascal.
- Transitional SQL as per FIPS PUB 127-2;
- sizing parameters for database constructs specified in FIPS 127-2, Section
- flagging of extensions as specified in FIPS PUB 127-2, Section 10.d,
SQL Flagger; and
- X/Open Extensions for features specified in X/Open CAE Specifications.
- SQL Server
- A free portable multiuser relational database management system (RDBMS)
that supports the full SQL89 dialect along with
some bits from SQL92.
It also provides multiuser access and transaction isolation based on
SQL Server is based on a client-server architecture for DBMS
A source code distribution is available.
- A project to build a database full compliant
with the ANSI SQL-92 standard.
It will also be multi-threaded, written entirely in ANSI C, distributed,
and fault tolerant.
This is an ongoing project and as of 5/98 is still in the early
- The SQ SHell is a replacement for the isql program
created by Sybase for working with their
This was designed to provide much of the functionality provided by
a good shell as well as to be easily
The features include:
Source and binary distributions are available.
- all the commands provided by isql as well as many extended
- variables for storing and retrieving information;
- redirection and pipes;
- full csh-style command aliasing;
- command substitution;
- backgrounding and job control;
- SQL batch history;
- configurable exit status;
- transferring the result set from any command batch to another
server via the Sybase BCP protocol;
- remote procedure calls;
- multiple styles for displaying output;
- support for redirecting any output display style into a separate
X Window; and
- macro preprocessing.
- A rapid prototyping environment based on Smalltalk.
This was originally creates by the folks at Apple but has
been ported to various UNIX platforms by the wonderful
folks at INRIA.
The Squeak programming environment includes a Smalltalk-80 compiler,
a run-time virtual machine, large class libraries, and an interactive
It uses an integral Smalltalk-to-C translator which is used to
generate the virtual machine, the source for which is actually written
in Smalltalk and then translated and compiled.
The features of the Squeak environment include:
- real-time sound and music synthesis written entirely in Smalltalk;
- extensions of BitBlt to handle color of any depth and anti-aliased
image rotation and scaling;
- network access support allowing the simple construction of servers
and other useful utilities;
- bit-identical running on many platforms;
- a compact object format that requires on a single word of overhead
- a simple and efficient garbage collector for 32-bit direct pointers; and
- efficient bulk-mutation of objects.
Squeak distributions are available for several platforms and operating
systems including Linux Intel.
Documentation can be found in Smalltalk programming manuals.
There are also several online tutorials on how to use the Squeak
- A package which offers high-performance proxy caching for Web
clients. Squid supports FTP, Gopher and HTTP requests, and the
cache software is more than an order of magnitude faster then
the CERN httpd and other popular Internet caches since it never
needs to fork (except for FTP), is implemented with non-blocking
I/O), keeps meta data and hot objects in virtual memory (VM),
and caches DNS lookups. The caches can also be arranged hierarchically
for an improvement in reponse times and a reduction in bandwidth usage.
The features of Squid include:
- the use of private objects (i.e. objects associated with a single
client as opposed to public objects which may be sent to multiple
- request resolution in a hierarchy which
cuts down on the server load since neighbors and parents are only
sent ICP queries for cacheable objects;
- the proper parsing of
HTTP reply codes to determine which objects should be cached;
- support for an If-Modified-Since GET;
- access log improvements (e.g. only one log entry per client
request with timestamp, elapsed, src-address, type/code, size, method,
and URL fields);
- automatic reloading of cache metadata in
- unlinking of swap files on restart and the -U
option to remove invalid objects from the disk;
- a more flexible
- a new access control scheme; changes to cache
- using SIGHUP to reconfigure the cache; and
- assigning weights to cache neighbors.
Squid is distributed in source code form and is designed to
install and operate on any modern UNIX
system including Linux.
The documentation, including a user's guide and a FAQ, is
currently (4/97) available in ASCII text format.
- A program that parses Squid logs and generates
all sorts of nifty reports.
- A scalable Internet proxy cache implemented as an extension to version
1.1.20 of Squid.
A CRISP cache is structured as a collection of autonomous proxy servers
that share their cache contents via a mapping service that can be queried
with at most one message exchange. Individual servers can be configured
to replicate all or part of the global map to balance cost and overhead
and hit ratio depending on the size and geographic dispersion of the
- The Central Squid Server is
a server that records the location of internet objects in a distributed
cache. It does't cache the objects itself but is rather a form of
ICP routing where caches in a distributed hierarchy
or mesh send an ICP query for an object to the server the the
server resends the query to a local cache or another CSS claiming to
hold a reference to the object.
- A cooperative Web cache which allows faster access to the Web, decreases
network usage, and decreases server load. It can cooperate with a number
of neighbor caches to group their contents and abilities.
This is distributed as a patch to Squid and
can be used on any platform on which the latter works.
- A combined filter, redirector and access controller plug-in for
Squid. The functionality includes:
- limiting Web access for some users to a list of accepted Web
servers and/or URLs;
- blocking access to Web servers and/or URLs for some users;
- blocking access to URLs matching a list of regular expressions
- enforcing the use of domain names (rather than IP numbers) in URLs;
- redirecting blocked URLs to an intelligent CGI
based info page;
- redirecting unregistered users to a registration form;
- redirecting popular downloads to local copies;
- redirecting banners to an empty GIF:
- different access rules based on time of day, day of week, etc; and
- different access rules for different user groups.
- A fast and configurable redirector for Squid.
The features include virtually no memory usage, re-reading its config
files while running by sending a HUP signal,
an interactive test mode for checking new configs,
full regular expression matching and replacement,
config files for patterns and IP addresses, and more.
This can be used on any platform on which Squid has been installed.
- Synchronizing Resources is a language for writing concurrent
programs. The main language constructs are resources and
operations, the former of which encapsulate processes and
variables that are shared and the latter of which provide
the primary mechanism for process interaction.
SR provides a novel integration of the mechanisms for invoking
and servicing operations, which means that local and remote
procedure calls, rendezvous, message passing, dynamic process creation,
multicast, and semaphores are supported, as well as global variables
consists of a compiler that translates SR to C, a linker that
serves as a front-end to ld, and associated other programs
and library files. SR runs on one or more networked UNIX machines
of the same architecture, with Linux being one of the supported
platforms. The primary documentation for SR is contained within
a book that must be purchased, although some technical reports
about various aspects of SR are also available.
- A Fortran 77 package that constructs a smooth
interpolatory or approximating surface to data values associated with
arbitrarily distributed points in the plane.
It uses automatically selected tension factors to preserve shape
properties of the data and to avoid overshoot and undershoot associated
with steep gradients.
The domain of the fitting function may be nonconvex or multiply connected,
and the surface may be constrained to have a discontinuous value or
derivative across a user-specified curve representing, e.g. a geological
fault line. The method is triangle based but avoids the inaccuracies
that can be associated with long thin triangles on boundaries.
This is TOMS algorithm 752 and is documented
in Renka (1996b).
- A color space designed to complement current color management strategies
by enabling a third method of handling color in operating systems,
device drivers, and the Internet that uses a simple and robust
device independent color definition.
The sRGB standard is based on a calibrated colorimetric RGB color space
that is well suited to CRT monitors, television, scanners, digital
cameras and printing systems.
The definition of the sRGB standard consists of two parts:
- a set of viewing environment parameters taking into account the
dependencies on the human visual system; and
- standard device space colorimetric definitions and transformations.
- The SRL Testing Toolkit is a toolbox of useful testing tools
aimed at providing mechanisms for programmers to develop code that closely
meets system specifications. SRLT is also targeted at giving
programmers another useful set of tools to allow the integration of
testing into their development practice.
The features of SRLT include:
A source code distribution is available which is supported on several
platforms including Linux Intel.
- a logging facility that gets the print statements out of the process
using named pipes (FIFOs);
- assertion and context facilities for checking pre/post conditions
and to ensure that reusable components are used correctly and to provide
traces of behaviors that violate assertions; and
- a basic framework for a log message analyzer.
- The Software Release Management package is a tool
for, strangely enough, managing the release of complex software packages.
It supports the release of systems of systems (i.e. software packages
created from pre-existing, independently produced, and independently
released systems) from geographically distributed organizations.
In particular, it tracks dependency information to automate and
optimize the retrieval of components.
Both developers and users of software systems are supported, with
developers supported by a simple release process that hides
distribution details. Users are supported by a simple retreival
process that allows a system of system to be retrieved via the Web
in a single step and as a single package.
A source code distribution is available. It is written in C and
has been successfully compiled and used on several platforms including
Linux Intel. Documentation includes a technical report and a set
of man pages.
This uses NUCM as an underlying storage
- The Secure Remote Password project includes a protocol
and software representing a new mechanism for performing secure
password-based authentication and key exchange over any type
The project is developing secure Internet software for free worldwide
use starting with a fully secure Telnet
and FTP distribution.
This protocol combines techniques of zero-knowledge proofs with asymmetric
key exchange protocols to offer significantly improved performance over
comparably strong extended methods that resist stolen-verifier attacks
such as Augmented EKE or B-SPEKE.
The security features of SRP include:
Source code and binary distributions of the SRP implementation are
- resistance to dictionary attacks mounted by either passive or
active network intruders;
- perfect forward secrecy which protects past sessions and passwords
against future compromises;
- storage of user passwords in a form that is not plantext-equivalent
to the password itself.
- A Fortran program to calculate an approximate
orthonormal basis for a dominant invariant subspace of a real matrix
by the method of simultaneous iteration.
This is TOMS algorithm 776 and is documented
in Bai and Stewart (1997).
- SSA (Matlab)
- A set of Matlab scripts for
Singular Spectrum Analysis.
The programs include:
- SSA, a shell program that calls the other programs;
- SSAEIG, calculates the SSA eigenvectors/values;
- AC, estimates the autocovariance function;
- BK, estimates the autocovariance function using the
method of Broomhead/King;
- PC, calculates principal components for SSA;
- RC, calculates RCs for SSA;
- SSACONF, computes variance estimates for eigenvalues; and
- ITC, uses information theory criteria to estimate the
- The Singular Spectrum Analysis-Multiple
Taper Method toolkit is a set of programs
that perform detailed spectral analyses and decompositions on
an input time series.
It contains procedures for:
decomposing time series into trends, quasiperiodic and period
oscillations, other significant components, and noise;
reconstructing the contributions of selected components of the
time series; and
estimating spectral properties of the time series or any of its
components by modern spectral methods.
Singular spectral analysis (SSA) is used for separating
the various components of the time series.
Spectral analysis can be performed via classic Blackman-Tukey
correlogram estimation, the multi-taper method (MTM), and
the maximum-entropy method (MEM).
The numerical programs that comprise the toolkit are:
ssa, which performs SSA decomposition of an input time
series and reconstruction of selected components;
mcssa, performs Monte Carlo tests of SSA against noise;
spectrum, computes Blackman-Tukey correlogram and MEM
estimates of power spectra;
mtm, computes MTM estimates of spectral amplitudes; and
carlo, which generates Monte Carlo realizations of white or
red noise that resemble a given series.
Each program can be used in stand-alone mode as standard
UNIX-type commands, and all can be used via a GUI
interface called spectra.
A source code distribution of SSA-MTM is available as is
a binary distribution for Linux Intel platforms.
It is written in Fortran 77 and
C and can be compiled and used with
the GNU compiler suite.
The GUI is written using the
The results can be viewed graphically using either the
The package is documented in a user's guide and each program
also has a man page.
- Secure SHell is a secure
replacement for existing remote access
programs (i.e. Telnet,
rlogin, rcp and rsh) that provides secure
TCP tunnels between hosts.
It also provides optional compression of traffic and can be
used with a choice of authentication schemes.
The first version of this was SSH1. It used version 1.2 and 1.5 of
the protocol and was and is freely available.
The licensing gets more restrictive starting with v1.2.12,
with the obvious goal being to get people to switch to the
wholly commercial SSH2.
Free implementations include
OSSH (i.e. SSH1 v1.2.12 with bug fixes) and
the OpenSSH project.
The features of SSH1 include:
- strong authentication that closes several
security holes (IP, routing, DNS spoofing, etc.) and provides new
authentication methods, i.e. .rhosts together with RSA-based
host authentication as well as pure RSA authentication;
- automatic and transparent encryption of all communications;
- X11 connection
forwarding for secure X11 sessions;
- arbitrary TCP/IP ports
that can be redirected over the encrypted channel in both directions;
- client RSA that authenticates the server machine at the beginning of
every connection to prevent trojan horses and man-in-the-middle attacks;
- server RSA that authenticates the client machine before accepting
.rhosts or /etc/hosts.equiv authentication;
- an authentication agent that can be used to hold the user's RSA
authentication keys; and
- multiple convenience features that fix annoying problems with
rlogin and rsh.
SSH2 is the new, commercial version, including improved cryptography
and a design aimed at more general purpose VPNs.
The additional features include:
- sftp, an FTP program tunneled through SSH2;
- separate configuration files from SSH1, although with backwards
- DSA and Diffie-Hellman key exchange.
The source code is available and can be installed
on most UNIX variants.
Documentation is included in the distribution.
- A tool for establishing an ssh tunnel for remotely
executing commands without requring an ssh authentication on every
connection. Commands can be executed almost instantaneously once the
tunnel is established.
A source code distribution is available.
- A C implementation of the
ssh version 2 protocol available under
- A free Java version of a
SSH client program.
It can be run as a standalone program or as an applet in a web page,
and can be run with or without a GUI in standalone mode.
The two chief additional features are:
Other features include:
- a built-in SCP client with a GUI for
simple file transfers; and
- full proxying of FTP connections, i.e. a tunnel
which can work with other FTP clients.
- full xterm/VT102 terminal emulation including colors, line draw
graphics and mouse support;
- authentication via a choice of methods, either with a single
method or via a list in a given order;
- support for Blowfish, DES, 3DES, Idea and RC4 blockciphers;
- connection through proxy types, e.g. HTTP,
SOCKSv4 and SOCKSv5;
- SSH tunneling including X11 forward;
- tunnels that listen on explicit local addresses;
- arbitrary simultaneous sessions in different windows to different
- automatic storage of settings on a per-host basis; and
- listing of all currently open connections through the tunnels.
- A port of the OpenBSD project (to
develop a freely available version of
SSH) to other UNIX versions including Linux.
The features include:
- completely free source code, i.e. all licensed or patented
portions of SSH have been removed;
- Kerberos 4 and S/Key authentication;
- support for SSH protocols v1.3 and v1.5;
- use of 3DES and Blowfish for session encryption and RSA for
- PAM support;
- support for IPv6; and
- better pseudo-random number generation than SSH1.
- An open source version of SSH.
This is basically SSH1 v1.2.12 (the last version without increased
restrictions) with bug fixes.
- The Secure Sockets Layer is a security
protocol developed by Netscape and
implemented on top of a transport service such as
that provided by TCP/IP.
It actually consists of two protocols: a record protocol
and a handshake protocol.
The record protocol deals with fragmentation, compression,
data authentication and encryption of messages provided by
applications. It provides support for keyed MD5 and SHA
for data authentication as well as RC4 and DES for
The keys used for these tasks are negotiated by the
handshake protocol, which deals with the exchange of
protocol version numbers and supported cryptographic
algorithms as well as mutual authentication and key exchange.
- A project to develope a robust, commercial-grade, full-featured and
Open Source toolkit implementing the
SSL and TLS protocols
with full-strength cryptography world-wide.
This is based on SSLeay.
- A set of Python scripts for setting up and
maintaining a certification authority using
The functionality of pyCA includes:
This requires Python 1.5.1 or greater and
- generating certificate requests with widely-used Web browsers;
- a search tool for client certificates in the database;
- downloading of client certificates/certificate revocation lists
with appropriate MIME types;
- storing all certificate data in LDAP repositories;
- scripts for handling the certification process; and
- easy configuration based on the OpenSSL
- A free implementation of Netscape's SSL, i.e.
the software encryption protocol behind the various Netscape products.
The contents of the package include:
- a library implementation of SSLv2, SSLv3 and all the code
required to support both in one server;
- various ciphers including a DES encryption package with 15
variations thereof as well as RC4, RC2, Blowfish and IDEA encryption;
- various digests including MD5 and MD2 digest algorithms,
SHA-0 and SHA-1 digest algorithms, and an MDC2 message digest;
- public key encryption implementations including RSA and DSA
encryption, decryption and generation, and Diffie-Hellman
key-exchange and generation;
- X509v3 certificates including X509 encoding/decoding into/from
binary ASN1 and a PEM-based ASCII-binary encoding supporting
encryption with a private key as well as a program to generate
RSA and DSA certificate requests and certificates;
- systems including normal digital envelope routines and base64
encoding, higher-level access to ciphers and digests by name, and
the BIO I/O system, i.e. a simple non-blocking I/O abstraction; and
- various data structures including a dynamically growing hashing
system, a simple stack, and a configuration loader.
Programs in the SSLeay package include:
- enc, a general encryption/decryption program that can use
any one of 17 different cipher/mode combinations;
- dgst, a program for generating message digests in one of
- asn1parse, for parsing and displaying the structure of an
ASN.1 encoded binary file;
- rsa, for manipulating RSA private keys;
- dsa, for manipulating DSA private keys;
- dh, for manipulating Diffie-Hellman parameter files;
- dsaparam, for manipulating and generating DSA parameter files;
- crl, for manipulating certificate revocation lists;
- crt2pkcs7, for generating a pkcs7 object containing a crl and
- x509, for manipulating x509 and self-sign certificates;
- req, for manipulating PKCS#10 certificate requests and also
generating certificate requests;
- genrsa, for generating an arbitrary-sized RSA private key;
- gendh, for generating a set of Diffie-Hellman paramters;
- ca, for creating certificates from PKCS#10 certificate
- verify, for checking x509 certificate signatures;
- speed, for benchmarking the SSLeay ciphers;
- s_server, a test server;
- s_client, a test client;
- s_time, for benchmarking SSL performance of SSL servers; and
- errstr, for converting from SSLeay hex error codes to
human readable form.
A source code distribution of SSLeay is available which is configured
to recognize and compile on a wide variety of platforms.
Documentation includes a programmer's reference manual and a FAQ, both
of which are available in PostScript format.
The latter is also available in HTML format.
- A Python wrapper for the
- A program designed to function as an SSL
encryption wrapper between remote clients and local or remote
This uses SSL-aware daemons for easily
establishing communications with clients over a secure SSL channel.
The features include:
- a client mode to connect remote SSL servers;
- strong authentication with certificates;
- POSIX threads
- a session cache based on threads.
- A set of Fortran 77 subroutines
for the fast in-core sorting of real arrays (SSORT),
integer arrays (ISORT), and character strings (CSORT).
These are available as Fortran source code and are documented
in comment statements within each source code file.
This is part of CMLIB.
- A Fortran 77 package that constructs a smooth
interpolatory or approximating surface to data values associated with
arbitrarily distributed points on the surface of a sphere.
It uses automatically selected tension factors to preserve shape
properties of the data and avoid overshoot and undershoot associated
with steep gradients.
This is TOMS algorithm 773 and is documented
in Renka (1997b).
- Secure Syslog is a cryptographically secure system logging
tool designed to replace the syslog daemon.
This implements a cryptographic protocol called PEO-1 that allows
the remote auditing of system logs.
Auditing is still possible even is an intruder gains superuser
privileges, and the protocol guarantees that the information logged
before and during the intrusion process cannot be modified without the
A source code distribution has been placed in the public domain.
- A solar system simulator that uses the OpenGL
library. Ssystem includes the Sun, the planets, a few of the major
satellites, and the background stars. Positions are not 100% accurate
but within reasonable range of the actual posiitions on a given date.
The camera can be freely moved and can be pointed at any planet or
other position desired.
Versions of Ssystem are available for Linux and Windows 95, with
a source code version available for the former.
The Linux version requires the Mesa 2.6
- A method of using the compiler to defend programs and systems against
buffer overflow attacks, i.e. attacks that intentionally overflow
a buffer that is allocated on a stack, inject code onto the stack,
and change the return address to point to the injected code.
It is a simple compiler extension that limits the amount of damage
that a buffer overflow attack can inflict on a program by effectively
preventing changes to the return address while the function is still
It does this by either detecting the change of the return address
before the function returns or by completely preventing the write to
the return address.
StackGuard attacks the problem at the destination (i.e. the stack that
is being overflowed) rather than at the source (i.e. the vulnerable
program), thus replacing the present patchwork solutions to the problem
with a more systematic approach.
StackGuard is implemented as a patch to GCC
220.127.116.11. It is available as a patch as well as in the form of
an installable or source RPM or the complete patched
A complete Redhat 5.1 Linux distribution compiled with StackGuard
is also available.
This cannot be used to compile the kernel nor should it be used
to compile programs to be debugged via |it gdb.
Documentation is available online and in a technical report.
- A library supporting fine-grain multithreading in
It consists of a set of C library routines that
are callable from any GCC/G++ code that satisfies a few conditions.
It supports dynamic thread migration on multiprocessor systems,
assuming cache-coherent shared memory.
StackThreads tolerates a large number (10,000 or more) of threads
and imposes a very small overhead for creating and terminating threads.
It can be used to parallelize existing C code via fine-grain
- The STAtic Language ImplementatioN is
a compiler for Scheme.
It is designed to be generate extremely efficient executable
images for application delivery or production research runs.
Stalin is a batch mode compiler which compiles a single Scheme
source file into an executable image, although it does this
indirectly via C.
The executable has equivalent run-time semantics to loading the
Scheme source file into an interpreter and then terminating its
The major limitation is that it is not possible to LOAD or EVAL
new expressions or procedure definitions into a running program
after compilation, although this is traded off for substantial
global compile-time analysis of the source program.
The strategies used for generating efficient code include:
- global static type analysis using a soft type system that
supports recursive union types, a strategy that reduces and
often eliminates run-time type checking and dispatching;
- low-level representation selection on a per-expression basis which
allows the use of unboxed base machine data representations
for all monomorphic types;
- global static life-time analysis for all allocated data which
allows much temporary allocated storage to be reclaimed without
garbage collection; and
- very efficient strategies for compiling closures.
A source code distribution of Stalin is available.
It is written in Scheme and is currently (5/97) compiled with
It is documented in a long README file included in the
- A Graphplan-based planner that uses a number
of different state analysis techniques to improve its performance.
Not all of the techniques are Graphplan-dependent so STAN can be
used by any STRIPS language planner.
The techniques include:
- the automatic generation of state invariants through the inference
- the automatic generation of fixed-resource invariants that allows
some unsolvable goal sets to be identified as such without planning; and
- the automatic identification of symmetry in a domain description for
reducing the size of the constructed graph.
The STAN system is currently (1/99) available as two separate programs:
The programs are available in binary form for Linux Intel systems.
- TIM, a Type Inference Module which implements the type
and state invariant inference techniques; and
- STAN, which implements the remainder of the techniques.
- Standard ML
- One of the ML family of languages.
One implementation is
- Stanford GraphBase
- A collection of programs which demonstrate the art of
literate programming while
offering state-of-the-art explanations of many important algorithms
and data structures. They also define a workbench for combinatorial
computing and offer a collection of standard sets of data which can be
used for benchmark tests.
The use of these programs requires the installation of
The collection is described and detailed in
Knuth (1993b) and is freely available at the given URL.
Hundreds of additional programs which use the Stanford GraphBase will
be made available as a supplement to Volume 4 of Knuth's
The Art of Computer Programming series.
- A library of Matlab programs (m-files) designed to facilitate the
analysis of oceanographic data during and after a cruise via
a graphical user interface.
The features include:
- station memory which allows them to be color-code by cruise,
location, a property minimum and maximum, or by any other chosen
- the ability to add new user-defined properties at any time during
a session (and save them from session to session);
- polar projections and 10-minute bathymetry and topography at
10 to 10000 meters available from within Matlab;
- the selection of stations by any property and property range;
- specification of a large number of user options which can be
changed and saved for each cruise or data set;
- contouring of irregularly sampled data; and
- the automatic recalculation of distance between selected stations.
- The fastest known implementation of a tar-like archiver.
It can make backups at more than 12 MB/s if the disk and tape
drive support it.
The features of star include:
A source code distribution of star is available. It
is written in C and can be compiled on most UNIX platforms.
- a fifo that keeps the tape streaming,
- a pattern matcher to control the list of files to be processed,
- a sophisticated diff command,
- no limitations on filename lengths,
- automatic recognition of the type of archive so it can handle
other archive types in their native mode, and
- automatic recognition and handlingof byte-swapped archives.
- A reusable iterative
optimization library suite
for combinatorial problems
with fuzzy constraints.
Typical application areas for combinatorial constraint optimizers
include scheduling, design, configuration, planning and
This family of C++ libraries is designed for
reusability and applicability for a wide range of combinatorial problems.
The StarFLIP++ is planned to consist of several layered sub-libraries
- FLIP++, the fuzzy logic inference processor library;
- ConFLIP++, the fuzzy constraint library;
- DynaFLIP++, the dynamic constraint generation library;
- DomFLIP++, the domain knowledge representation library;
- OptiFLIP++, several heuristic optimizing libraries;
- InterFLIP++, the user interface with support for X11 and other GUIs;
- DocuFLIP++, the HTML documentation suite;
- CheckFLIP++, the knowledge-change consistency checker library;
- TestFLIP++, the version control and test environment for the
complete library set;
- SimFLIP++, the simulation toolkit;
- ReaFLIP++, the reactive optimizer; and
- NeuroFLIP++, the neural network extension that allows automatic
tuning of fuzzy membership functions.
A subset of the suite is currently (1/99) available in the form
of precompiled demonstration applications including FLIP++,
ConFLIP++, DynaFLIP++, DomFLIP++ and OptiFLIP++.
Documentation is also available for each of these.
These binaries are available for Linux Intel and other platforms.
- A package for simulating the evolution of dense stellar systems
and analyzing the resulting output.
It comprises a collection of loosely coupled programs which, in the
traditional UNIX style, can be combined in arbitrarily complex
ways to study the dynamics of star clusters and galactic nuclei.
A novel feature of Starlab is a flexible external data representation
scheme which guarantees that tools can be combined without loss of
data or internal comments.
The package consists of several modules containing:
- three- and four-body automated scattering packages constructed
around a time-symmetrized Hermite integration scheme;
- a collection of initialization and analysis routines for use
with general N-body systems;
- a general Kepler package for the manipulation of two-body orbits;
- N-body integrators incorporating both 2nd-order leapfrog and
4th-order Hermite integration algorithms; and
- a general N-body integrator called Kira which incorporates
recursive coordinate transformations, allowing the uniform treatment
of hierarchical systems of arbitrary complexity with the general
A source code distribution of Starlab is available. It can be
compiled and installed on most generic UNIX systems.
It is documented in a user's manual available in PostScript format.
- Starlink Project
- A project established in 1980 to help astronomers use computers
to analyze their observations. It consists of a network of
computers used by UK astronomers, a collection of software to
reduce and analyze astronomical data as well as to work on some
types of theory, and a team of people offering hardware, software,
and administrative support.
The objectives of the project are to
provide and coordinate interactive data reduction and analysis
facilities for use as a research tool by UK astronomers, encourage
software sharing and standardization to prevent unnecessary duplication
of effort, and provide systems software support for astronomers.
The main software product offered by the Project is the
Starlink Software Collection (SSC) which consists of about
120 items divided into 40 packages, 40 utilities, and 40 subroutine
libraries. Much of the software is available and can be obtained
via the Web. It is divided into three general categories: applications
and user interfaces, utilities, and libraries.
Source code distributions are available for most packages as are
binary versions for Linux Intel platforms.
The applications and user interface packages include:
Most of these applications can be used either from a UNIX
shell or within the Starlink
ICL (Interactive Command Language).
- CCDPACK, for processing and reducing
- CONVERT, for converting data files between
Starlink Project format and other common data formats;
- CURSA, for manipulating astronomical
catalogues and other tabular datasets;
- DAOPHOT, a stellar photometry package
for dealing with crowded fields;
- DIPSO, a plotting package incorporating
basic astronomical applications;
- ECHOMOP, for extracting spectra from
2-D data frames;
- ESP, for determining the photometric properties
of galaxies and other extended objects;
- FIGARO, a general purpose reduction package
for a wide range of images and spectra;
- GAIA, for displaying images;
- IRCAMPACK, for processing IRCAM data;
- IUEDR, which provides facilities for the
reduction of IUE data;
- KAPPA, a general purpose package with over
180 programs for image processing, data visualization, and data
- PERIOD, for searching for periodicities
in data via time series analysis;
- PHOTOM, for measuring the sky corrected
magnitudes and fluxes of astronomical objects within circular and
- PISA, for locating and parameterizing
objects on an image frame;
- POLMAP, for the interactive data analysis
of linear spectropolarimetric data;
- PONGO, for interactively plotting data;
- SAOimage, an astronomical image display
- SPECDRE, a package for spectroscopy
data reduction; and
- TSP, for handling time series and
- The Standards Time Series And
Regression PACkage (which was available in an
earlier version called STATLIB) is
a portable library of approximately 150
user-callable Fortran routines
for statistical analysis originally developed at the NIST.
It contains routines for normal random number generation, univariate
sampling, one-way analysis of variance, correlation analysis,
linear least squares, nonlinear least squares, digital filtering,
complex demodulation, correlation analysis, spectrum analysis,
and time series analysis.
The Fortran 77 source code is available. The documentation
is contained within a large ASCII document that prints out to
well over 200 pages.
- A package for creating images and animations from astrophysical
particle simulation data.
StarSplatter renders collections of particles as Gaussian
blobs or (more colorfully) splats.
The position, color, opacity and size of each splat are
controlled by the particle and bunch properties, with
bunch properties being position, color, density, and scale length.
The scale length provides a length scale for the exponential
decay of bunches in the final image.
A camera is used to define a viewpoint for looking at all of the
particles, and a renderer is used to transform the camera and
particle information into a final image.
The features of the renderer include the anti-aliasing of
points which produces good visual results even
with very small particles.
This is designed to work with the
A source code distribution of StarSplatter is available.
It is written in C++ and
Tcl and should compile and installed
on most UNIX flavors with this software.
Makefiles are provided for several platforms but not for
Linux Intel, although one can be created fairly easily.
A user's manual is provided in several formats.
- A typesetting system built on top of TeX.
Starter TeX is designed to help students typeset
reports, essays, and similar small documents quickly and easily,
and as such hides many of the gory details behind an interface
suited for those with little previous knowledge of document
processing tools. It is also designed to be more robust, i.e.
be more forgiving of various errors.
- A set of programs for estimating (via an expectatino-maximization
algorithm) parameters relevant to the evolutionary relationship
between a pair of DNA or protein sequences.
Statalign performs pairwise alignment and allows the reliability
of alignment positions to be visually examined.
The most notable feature is a reasonable and statistical treatment
of the insertions and deletions that can occur in a sequence
over evolutionary time based on an explicit evolutionary model.
The evolutionary model allows multiple-residue insertion and
deletion events, regional heterogeneity of amino acid
replacement or nucleotide substituion rates, and special treatment
of terminal gaps.
A source code distribution of these C programs is available.
Documentation exists in an ASCII file in the distribution as well
as in several journal papers.
- A toolbox of statistical routines for Matlab
including ordinal logistic regression, Poisson regression, nonlinear
regression with sums of exponentials, maximum likelihood and REML
for randomized block models, probability distributions, Gaussian
quadrature, and various special functions and matrix operations.
The programs include:
- regr, for least squares regression;
- logist, for ordinal logistic regression;
- poisson, for Poisson regression;
- mprony, fit a sum of exponential functions by nonlinear least
- frequenc, frequency estimation by nonlinear least squares;
- rb_ml, fit a randomized block model by maximum likelihood;
- rb_reml, fit a randomized block model by residual maximum
- orthpoly, for generating orthogonal polynomials;
- levenb, the Levenberg-modified Newton-Raphson method;
- betap, betaq and betar, for the Beta distribution
function, quantiles and random deviates;
- binp, for the binomial distribution function;
- chisqp and chisqq, the chi-squared distribution and
inverse distribution functions;
- fp and fq, Fisher's F distribution function and quantiles;
- gammad, gamma distribution density function;
- normp and normq, the normal distribution and inverse
- randbin, randgamm and randpois, for random deviates
from the binomial, gamma and Poisson distributions;
- tp and tq, the Student's t distribution function and
- digamma and trigamma, the digamma and trigamma functions;
- gquad and gquad6, for regular and six-point Legendre
- grule, for computing Legendre nodes and weights;
- int0infy, for Laguerre quadrature;
- laguerre, for computing Laguerre nodes and weights;
- laguerr2, for Laguerre nodes and weights for gamma expectation; and
- clencurt, for Clenshaw-Curtis integration.
- Good places to search for statistical software are the
Statistics and Statistical Graphics Resources
Guide to Statistical Computing Resources on
the Statistics on the Web
site, and the
Statistics Related Links
at Duke University.
Repositories for statistical software and other resources are
(Globally Accessible Statistical Procedures), and the
Geostatistics Web Site.
- A repository for many megabytes of various types and
sizes of statistical software, data, etc.
- A program for gathering and showing information about network
activity. Althoug it is not a full-featured network traffic analyzer,
it is intended to be at least more informative than flashing lights
on a hub.
Statnet can view statistics for
Displayed information includes the number of kilobytes per second on
each interface, the Ethernet load, frames per second, and how
many frames of each type are passing through.
Source code and Linux binary distributions are available.
- A package of Fortran routines that calculates cumulative
functions, their inverses, and parameters of the following
distributions: incomplete beta, binomial, negative binomial,
chi-square, non-central chi-square, variance ratio-f, non-central f,
incomplete gamma, normal, Poisson and t. Additionally, when
normal or t cdfs are being computed, it calculates the
associated two-sided p-value. The probability of exactly
n events is calculated and printed with the cumulative
distribution for the binomial and Poisson distributions.
The distribution includes the source code and a 50+ page
user's manual in ASCII format.
- A structured BASIC interpreter which uses the program and
data structures of Chipmunk Basic, an example program
included in the p2c translator.
It also uses the graphics routines from SGRP and
the functionality of GFA-BASIC on Atari ST (i.e. basically
GFA-BASIC ported to UNIX).
The package includes the source and a binary distribution
for Linux Intel programs.
Installation from source requires the prior installation of
p2c and SGRP, with both already included in the binary
- An open source Web application server environment in
which database applications can be developed completely
in an extended version of HTML.
Session and user-associated data as well as
SQL commands can be
directly embedded into HTML pages, with no
CGI programming needed.
The distinguishing features of SteelBlue include:
- maintenance of the HTML format for extensions;
- automatic security enforcement before a single line of a script
- allowance or denial of special privileges on a group basis;
- automatic restoration of form data;
- automatic server- and client-side type checking; and
- combining HTML generation, data checking and database interaction
within a single script.
- A steganographic file system for Linux that
not only encrypts data but also hides it such that it cannot be
proved to be there.
StegFS builds on top of the Ext2 filesystem
and can be mounted with the ext2 driver.
A source code distribution is available under the
- A multi-platform Atari 2600 emulator for Linux, DOS, OS/2,
Power Macs, UNIX/X, and Windows NT/95 platforms.
There is a binary distribution for each platform which
includes three 2600 ROM images (i.e. .BIN files): a test
program, a game called Elk Attack, and a game called Okie Dokie.
The ROM images from the Atari 2600 Action Packs by Activision
can also be used with Stella.
- A program for the calculation of molecular steric parameters primarily
for organometallic and crystal chemistry.
It can calculate steric effects about a point as well as
free space effects.
Steric effect parameters calculated involving angular quantities include:
The radial profiles of all these parameters can also be calculated.
The free space effect calculations available include:
- the Tolman cone angle involved primarily in determining the
bonded structure of organometallic molecules where only one ligand
is attached to a metal;
- the total enveloping cone angle, i.e. the vertex angle of the entire
- the solid angle used for describing the angular
steric size of a ligand (with multiple calculation methods available
including numerical, semi-analytical, and semi-analytical using
multiple overlap); and
- the angle of overlap, a rough approximation to steric congestion.
- several steric volumes of interest using both Monte Carlo
and fixed grid approaches (e.g. free unit cell, molecular, and
cavity volumes); and
- projected areas via either fully analytical or numerical procedures.
A source code distribution of STERIC is available as are binaries
for several platforms including Linux Intel (upon which the
program was developed).
It was written entirely in ANSI C and can be compiled on most
Graphics capabilities are handled externally via the
- The Stochastic Spatial Simulator is a package
for the interactive exploration of particle systems on one and
two dimensional grids with at most eight states at each site.
It offers a number of built-in models which can be simulated
from a variety of initial states. It is also designed for
easy extensibility, i.e. new models can easily be added by writing
C code which describes the simulation loop and then adding the
name of that model to a parameter structure.
The source code for s3 is available. It is written in
C and can be compiled and used on generic UNIX/X11 platforms.
An additional package containing user-contribed code is also
available at the site.
The documentation includes an installation manual and a tutorial.
- SGML Transformations In Lisp is a style
sheet language with which you can build structure-controlled
applications. It builds an abstract tree representation of an
SGML document instance and allows you to
express transformations using STIL functions.
STIL is a superset of Common Lisp
enriched by a set of constructs
targeted for this task domain which can be used for manipulating
the structure of an SGML document instance by accessing both the
markup and the data.
The source code for STIL is available. It is a CLOS
application written in Common Lisp and requires both
CLISP and sgmls
for compilation and use.
The package is documented in a 20+ page user's manual
available in PostScript format.
See also sdc.
- A Scheme interpreter that can access the
Tk graphical tools package.
This can be seen as the Tk package where the
Tcl language has
been replaced by Scheme, and where a full object oriented system
called STKlos (related to CLOS and Dylan) is also provided.
The features of STk include:
- an interpreter that conforms to R4RS with some additions from
R5RS such as multiple values and dynamic-wind;
- an extensive object-oriented system called STklos with multiple
inheritance, generic functions, multi methods, and a Meta Object
- extension of the interpreter via adding C modules;
- availability of all commands in Tk to the interpreter;
- callbacks in a GUI are Scheme closures;
- support for Tk 8.0;
- Tcl interpreter not used when using Tk widgets;
- a set of STklos classes have been defined to manipulate Tk
commands as STklos objects; and
- building new widgets in Scheme by composition of existing widgets.
A source code distribution of STk is available. It has been
successfully installed on several platforms including Linux Intel.
Binaries are also available for Linux Intel platforms.
Documentation includes a reference manual and a FAQ, both of which
are available in several formats.
- The Synthesis ToolKit is a set of audio
signal processing C++ classes and instruments
for music synthesis.
The sound synthesis classes include:
- RawWave, a looping or one-shot linearly interpolating wavetable;
- RawLoop, a looping linearly-interpolating wavetable;
- RawWvIn and RawWvOut, linearly interpolating in and out
- ADSR, ADSR flavor of envelope;
- Noise, a random number generator;
- OnePole, a one pole filter;
- AllPass1, a first-order allpass filter;
- FormSwep, a sweepable two-pole filter;
- DLineL, a linearly interpolating delay line;
- DLineA, an allpass interpolating delay line;
- JetTabl, a cubic jet nonlinearity;
- LipFilt, a pressure-controlled biquad with nonlinearity; and
- SingWave, a looping wavetable with modulator envelope.
The algorithms and instruments classes include:
- Plucked, a basic plucked string;
- Mandolin, a commuted mandolin;
- Clarinet, a clarinet;
- Flute, a flute;
- Modal4, four resonances;
- FM4Op, a four operator FM master;
- HeavyMtl, a a distorted FM synthesizer;
- PercFlut, a percussion flute;
- Rhodey, a Rhodes-like electric piano;
- TubeBell, a classic FM bell;
- Sampler, a sampling synthesizer;
- DrumSynt, a drum synthesizer;
- Reverb, a reverberator effects processor;
- Flanger, a flanger effects processor; and
- Chorus, a chorus effects processor.
A source code distribution is available. This has been successfully
compiled and used on a Linux Intel platform.
Documentation is a wee bit sparse.
- The Standard Template Library is a
C++ library that provides a set of
easily composable C++ container classes and generic algorithms
(i.e. template functions).
The container classes include vectors, lists, deques, sets, multisets, maps,
multimaps, stacks, queues, and priority queues, while the
algorithms include many fundamental algorithms for the most common
types of data manipulations, e.g. searching, sorting, merging,
copying, and transforming.
The ANSI/ISO C++ Standards Committee voted in July 1994 to adopt
the STL as part of the standard C++ library.
The Standard C++ library consists of 51 headers,
of which 13 constitute the STL. These are:
- algorithm, defines numerous templates that implement useful
- deque, defines a template class implementing a deque container;
- functional, defines several templates that help construct
predicates for the templates defined in algorithm and numeric;
- iterator, defines several templates that help define and
- list, defines a template class implementing a list container;
- map, defines a template class implementing associative containers;
- memory, defines several templates that allocate and free storage
for various container classes;
- numeric, defines several templates implementing useful numeric
- queue, defines a template class implementing a queue container;
- set, defines template classes implementing associative containers
with unique elements;
- stack, defines a template class implementing a stack container;
- utility, defines several templates of general utility; and
- vector, defines a template class implementing a vector container.
STL has been included in the libg++ used by GCC
since version 2.6.3 and has been included in all versions of
egcs (both of which will be combined starting
with GCC 2.9.5 now that the projects have merged).
Ammerall and Ammeraal (1997),
Glass and Schuchert (1996),
Musser et al. (1996),
Plauger et al. (1998),
Robson (1998) and
Schildt and Schildt (1999).
Useful STL-related links include:
- A project whose goal is to make the SGI STL implementation
usable with most compilers while retaining full functionality.
The main non-portability issue fixed is the default template
class parameters for containers, although several other smaller
problems are being smoothed over.
Several extensions have also been added to ease the task of
porting STL to the range of available C++ compilers.
A source code distribution of STLport is available which
has been successfully compiled and tested using a test suite
on a wide range of compilers including GCC 2.7.2 and
Documentation can be found on the site.
- An Atari ST emulator for UNIX/X11 platforms.
The features include:
A source code distribution is available.
- MC68000 CPU emulation,
- 4 or 14 Mb RAM,
- color or monochrome graphics modes,
- YM2149 sound chip emulation,
- IKBD and BIOS-level disk routines,
- a bootable UNIX filesystem interface,
- FDC emulation complete enough to run some games,
- emulation of serial and parallel ports,
- a VDI driver for Xlib, and
- use of either
an X Window or SVGAlib with Linux.
- Stony Brook Algorithm Repository
- A comprehensive collection of algorithm implementations of eighty
of the most fundamental problems in combinatorial algorithms.
The problem taxonomy, implementations, and supporting
material are drawn from Skiena (1997).
The site provides implementations of useful algorithms via
either links to sites that have them or local copies.
The implementations for each type of problem are rated according
to usefulness on a scale of 1 through 10, with usefulness
defined as how likely it is that someone lookin for code will
be happy with what they find. The author invite feedback on
The problems are classified by category (e.g. data structures,
numerical problems, combinatorial problems, graphic problems
in polynomial time, graph problems in exponential time,
computational geometry, and set and string problems) and also
by the computer language in which they are implemented.
- A GNU program for managing the installation of
software packages. It enables packages to be kept separate while
making them appear to be installed in the same place.
Historically this has been a difficult task because of the
need to administer, upgrade, install, and remove files in
independent packages without confusing them with other files
sharing the same filesystem space.
The approach used in Stow is to install each package into its
own tree and then use symbolic links to make it appear as though
the files are installed in a common tree. This allows administration
to be performed in the package's private tree with Stow being used
to update the symbolic links.
Stow was inspired by Depot but is much
simpler, e.g. no database files are needed.
A source code distribution of Stow is available.
It is a Perl script which should run
correctly under either version 4 or 5.
A manual is available in the usual formats.
- A stratigraphic modeling package designed for simulating the
evolution of sedimentary ocean basins.
The key assumption used by this model is that sediment transport
behaves diffusively, with the sediment source proportional to water
depth for carbonate simulations and a user-specified function for
It also has the capability of predicting the seismic response of
a modeled basin since the density and sound velocity of all parts
of the basin can be determined.
The strata package consists of four programs:
- setbasin, for setting model parameters;
- simbasin, for running the model with the assigned parameters;
- plotbasin, for plotting results; and
- filmbasin, for creating animations of series of results.
The controlling variables set with the setbasin program are
divided into several parameter groups including measures, ages,
clastics, carbonates, sealevel, subsidence, compaction, and heat
The details of the parameters within each group include:
- measures - for setting total width, spatial divisions, total
divisions, and timelines for saving the simulation state at regular
- ages - for setting increments at which time slices should be
saved or for saving individual slices;
- clastics - for defining the diffusion constant k for various
materials as well as the pelagic sedimentation rate;
- carbonates - for setting parameters concerning calcium carbonate
sedimentation including both epeiric and oceanic sedimentation algorithms
and the rate constants for each;
- sealevel - for defining the eustatic curve in varying amounts
- subsidence - for setting the subsidence rate, type of profile (e.g.
cratonic, foreland, or passive), isostatic compensation, flexural
rigidity, and densities of the various materials;
- compaction - for determining whether compaction occurs and, if so,
defining the decay constants, porosities, and whether erosion will
affect it; and
- heat flow - for setting the heat flow constant in the steady state
vertical thermal equation as well as the boundary temperatures and the
thermal conductivities of the various materials.
A source code distribution of Strata is available under the
GPL. It can be compiled and used on most
generic UNIX/X11 platforms.
It is documented in a user's guide as well as in several
- A radiative transfer model that can be used for computing either radiances
(intensities) or irradiances (fluxes) for a wide variety of atmospheric
and surface conditions.
The features of Streamer include:
- computing fluxes using two or more either broad or narrow band streams;
- the use of DISORT for more than two streams;
- computation of radiances for any polar and azimuth angle using four
or more streams;
- computation of upwelling and downwelling shortwave and longwave,
net fluxes, cloud forcing, and heating rates;
- parameterization of 24 shortwave and 105 longwave absorption bands for various
gases and overlapping gases and clouds;
- built-in atmospheric data including water and ice cloud optical
properties, five aerosol optical models, four aerosol vertical
profiles, and seven standard atmospheric profiles;
- computations performed on scenes consisting of a mixture of up to
10 cloud types occurring individually, up to 10 overlapping cloud sets
of up to 10 clouds each, and clear sky (with all over some combination
of up to three surface types);
- inclusion of spectral albedo data for open ocean, meltponds, bare ice,
snow, green vegetation, and dry sand; and
- a user interface providing a looping structure for up to ten variables
at a time.
A source code distribution of Streamer is available. It is written
in Fortran for UNIX platforms.
It is documented in a user's guide available in PostScript format.
- STarmode Radio IP is a protocol for carrying IP packets
over the Starmode interface of Metricom's 900 MHz packet radios.
It produces a wireless IP subnet similar to a conventional
Ethernet network although slower.
STRIP has been a standard component of the Linux kernel
since 1.3.82, but this site has a newer version of the STRIP driver
software than is in even the most recent kernels.
Some updated versions of a few of the
NetTools programs should also be obtained
- A Fortran 77 package that uses an incremental
algorithm to construct a Delaunay triangulation and a Voronoi diagram
of a set of points (i.e. nodes) on the surface of the unit sphere.
The triangulation covers the convex hull of the nodes while the
Voronoi diagram covers the entire surface.
The package provides several capabilities including an efficient
means of updating the triangulation with nodal additions
This is TOMS algorithm 772 and is documented
in Renka (1997a).
- A tool that converts a polygonal model into triangle strips to
speed up rendering time.
- Scan trn is a news reader based on
It contains all of the features of trn and adds several
a newsgroup browser, virtual newsgroups, scoring/rating
of articles, and easy configuration menus.
- A Web site management system that applies state of the art database
research to addressing the problems of handling multiple data sources
and of automating the management of site content and structure.
The steps for developing a site with Strudel are:
Source and Linux binary distributions of Strudel are available.
- defining the data that will be made available (with the raw data
residing in either external sources or in Strudel's internal data
repository) and modeling that data as a labeled, directed graph;
- declaratively specifying the site structure using a site-definition
query in StruQL (Strudel's query language) to obtain a site graph, which
models both the site's content and structure; and
- using the HTML generator to produce HTML text for every node
in the site graph using an HTML template.
- A system for reducing and analyzing data from the Hubble Space
This runs in and requires the
- A sound editing tool which enables recording, playback, and simple
cut and paste editing of sound files in diverse formats on
a Linux PC with the OSS sound drivers.
Studio is a Tcl/Tk application.
- Seismic Unix is a self-contained
software environment for seismic research
and data processing used by exploration geophysicists, earthquake seismologists,
environmental engineers, software developers and others.
It provides a standard environment for the testing of new processing
algorithms. It is easy to use because it does not require learning a special
language-its application uses only the standard facilities
afforded by the UNIX
operating system. Once UNIX shell-redirecting
and pipes are mastered, there is no
further artificial language to learn. The seismic commands
and options can be used as
readily as other UNIX commands. In particular, the user can write ordinary UNIX
shell scripts to combine frequent command combinations into meta-commands (i.e.,
processing flows). These scripts can be thought of as ``job files.''
SU has a layered structure consisting of:
There are also codes the buffer the graphics routines
of PSPLOT, xplot, and
Xtcwp, an internal X Window based graphics package. Some of the
more common processing programs compute autocorrelations, gain,
normal-moveout corrections, prediction error filtering, velocity
analysis, and much more.
- cwp, a library of scientific
routines (e.g. FFT routines) written in C as well as utility programs
- par, a library supporting the CWP programming style (e.g.
self-documentation, error reporting, parameter passing, etc.); and
- su, seismic processing codes that use a standard SEG-Y trace
The source code to SU, written in ANSI C, is available and
should compile successfully on almost any generic UNIX platform
with a C compiler. The documentation is contained within
a user's manual available in both HTML and PostScript formats.
A version of this package called
DSU that runs on a network
of workstations is also available.
- A Java-based user interface construction
toolkit. SubArctic is a complete, full-functioned, industrial
strength toolkit designed to provide a solution to all user
interface needs. It is based on 10 years of research and designed
to offer advanced techniques that go beyond static interfaces and
simple collections of widgets.
As such is is highly extensible and supports a number of sophisticated
effects not available in other toolkits.
The features of SubArctic include:
- support for sophisticated drawing effects which can be applied
to all interface elements;
- animation support based on a high-level path model
with controlled timing;
- facilities for semantic snapping interactions;
- provision for standard and custom interactor (widget) styles that
can be dynamically switched;
- support for semantic lens interactions;
- a full-functioned interactor library with the usual buttons, check boxes,
and sliders along with more sophisticated techniques supporting
dragging, snapping, lenses, and animation;
- techniques which support interactive interface debugging;
- a built-in, efficient, and easy to use constraint evaluator for support
of flexible dynamic layouts; and
- a well-developed and carefully designed infrastructure for
extensibility at all levels.
A distribution of SubArctic which contains both source and
executables is available.
The documentation includes a user's manual, a JavaDoc for the
API, and a source code guide.
- A knowledge discovery system which discovers interesting and repetitive
subgraphs in a labeled graph representation using the minimum description
length (MDL) principle.
The substructures can be used to compress the database and represent
structural concepts in the data.
Multiple passes of SUBDUE wherein previously discovered substructures
in the data are replaced produce a hierarchical description of the
structural regularities in the data.
Inclusion of background knowledge can guide it toward appropriate
substructures for a particular domain or discovery goal, and the
use of an inexact graph match allows a controlled amount of deviations
in the instance of a substructure concept.
A source code distribution of this C package
is available. It is documented in a series of technical papers
available in PostScript format.
- SUperuser DO is a program that allows a sysadmin to give
certain users or groups of users the ability to run commands as root
while logging all such commands and arguments.
It runs on a per-command basis and is not a replacement for the
The features include:
A source code distribution of sudo is available.
See also the related runas.
- restricting the commands a user may run on a per-host basis;
- extensive logging of each command to provide a clear audit trail of
who did what;
- use of timestamp files to implement a ticketing system wherein when
a user invokes sudo and enters the password they are granted a ticket
for 5 minutes; and
- a configuration file that can be used on more than one machine to
allow for central administration and defining privileges on a per-host
- A set of Fortran 77 routines for the solution of
overdetermined and underdetermined systems of linear algebraic
The SODS routine solves an overdetermined system of
linear equations AX=B where A is M by N with MN.
If the rank of A equals N then X is the unique least squares
solution vector, and if it is less than N then the least squares
solution of minimal length can be provided.
The SUDS routine solves an underdetermined system of
linear equations AZ=B where A is M by N with MN.
If the rank of A equals I then a vector X and a matrix U are
determined such that X is the unique solution of smallest length.
If the system of equations aren't compatible then only the
least squares solution of minimal length is computed.
A source code distribution of SUDSODS is available.
The routines are written in Fortran 77 and documented via
comment statements contained within each source code file.
This is part of CMLIB.
- A genetic algorithm package
featuring a wide range of operators and datatypes.
SUGAL was designed with particular emphasis on making it
easy to extend and configure without having to modify the
existing source code.
- This IRC client
has been superseded by SPX.
- The Scalable Universal Matrix Multiplication
Algorithm is a straightforward, highly efficient, and scalable
implementation of common matrix multiplication operations.
The algorithms are simpler than previously published methods,
yield better performance, and require less work space.
An implementation written in C for use with
MPI is available in source code format.
- Super Delaunay
- A fully dynamic constrained Delaunay triangulation engine with which
triangulations can be created point by point, e.g. individual points
can be inserted or deleted at any time during the process and the
triangulation will be dynamically changed.
The features of SD include:
- inserting or deleting points from a triangulation by coordinates
or reference number;
- creating or deleting constraints in a triangulation (from existing
points or not);
- flipping triangles where the common edge becomes a constraint;
- saving the result in different formats including DXF, Inventor,
3DS, POV, ASCII and VRML;
- locating points in a triangulation, i.e. returning a triangle
given coordinates; and
- defining specific areas with which to work.
SD is an ANSI C library providing the above functionality for 2-D
It is available in binary format for several platforms including
Linux Intel by contacting the author at an address given at the
- A program for visualizing and interacting with 3-D surfaces.
Interaction capabilities include rotation, zooming and panning, and
- A library for the direct solution of large, sparse, nonsymmetric
systems of linear equations that is callable from either
C or Fortran (and
written in the former).
SuperLU contains a collection of three related subroutine libraries:
- SuperLU, a sequential version of uniprocessors;
- SuperLU_MT, for medium-size SMP machines; and
- SuperLU_DIST, which uses MPI for
large, distributed memory machines.
The features of SuperLU include:
- solving by performing an LU decomposition with numerical
pivoting and triangular system solves via forward and back substitution;
- LU factorization routines that can handle non-square matrices (with the
triangular solvers working only with square matrices;
- preordering the matrix columns (before factorization) via either
library or user-supplied routines, with the preordering for sparsity
completely separate from the factorization;
- working precision iterative refinement subroutines for improved
- routines for equilibrating the system, estimating the condition
number, calculating the relative backward error, and estimating
the error bounds for the refined solutions;
- a factorization algorithm that uses a graph reduction technique
to reduce graph traversal time in the symbolic analysis;
- reduction of data movement between levels of the memory hierarchy
via loop ordering and the use of dense matrix operations in the
numerical kernel; and
- a 2-D block cyclic matrix distribution to enhance scalability
in the distributed memory implementation.
The source code is available as well as documentation in the
form of a manual and several papers
in PostScript format.
- A normal mode acoustic propagation model.
This is written in Fortran 77 and comes supplied
with a makefile for compiling on several platforms including Linux.
- Surface Evolver
- An interactive program for the study of surfaces shaped by surface
tension and other energies and subject to various constraints.
A surface is implemented as a simplicial complex, i.e. a union
of triangles. An initial surface is defined in a data file
and the Evolver evolves the surface toward minimal energy via
a gradient descent method. The aim can be to find a minimal
energy surface configuration or to model the process of evolution
by mean curvature. The energy can be a combination of surface
tension, gravitational energy, squared mean curvature, user-defined
surface integrals, or knot energies. The Evolver can handle
arbitrary topology, volume constraints, boundary constraints,
boundary contact angles, prescribed mean curvature, crystalline
integrands, gravity, and constraints expressed as surface integrals.
Surfaces can be interactively modified to change their properties or
to keep their evolution well-behaved. It was written for 1- or 2-D
surfaces but can also do higher dimensions with some restrictions
on available features.
The Surface Evolver is available for UNIX, Windows 95 or NT,
MS-DOS, NeXT, and Macintosh systems. On UNIX systems graphics
are handled by means of an X Window System interface or by
an interface to the Geomview package.
The 150 page user's manual is available in both PostScript
and HTML formats.
Versions of the Evolver are also available which use either
the MPI or PVM
packages for distributed parallel processing.
See Brakke (1992).
- This has been renamed Plume.
- The Smallest Univalue Segment Assimilating
Nucleus is a program containing algorithms for image
noise filtering, edge finding, and corner finding.
In the SUSAN principle a circular mask with a center pixel
called a nucleus is placed on images consisting of light and
dark patterns. The brightness of each pixel within the mask
is compared to that of the nucleus to define an area with
a brightness similar to that of the nucleus, with this area
known as the USAN. 2-D features and edges can then be detected
from the size, centroid, and second moments of the USAN, with
no image derivatives or noise reduction required as in most
The USAN area is at a maximum when the nucleus lies in a flat
region, falls to half of the maximum very near a straight
edge, and falls even further when inside a corner. This gives
rise to the SUSAN principle wherein an image processed to give
as output inverted USAN area has edges and 2-D features strongly
enhanced, with 2-D features enhanced more strongly than edges.
The noise reduction algorithm is related to the SUSAN principle
in that the USAN is used to choose the best local smoothing
A source code distribution of SUSAN is available. It
is a single self-contained C program which inputs and outputs
PGM format images of any size, performing any of the three
SUSAN algorithms. The use of the program is documented in
comment statements within the code as well as in several
technical reports available online.
- A collection of visualization programs built on top of
the Karma package.
The programs include:
- xray and krot for the volume rendering of
- kview and kubes to play movies of data cubes as
well as inspect two cubes at the same time;
- kslice_3d for slicing a cube;
- ksnow and ktrek for rendering or flying through
- cube2mpeg for compressing movies to MPEG
- khuei for superposing images;
- kpvslice for the interactive selection of position-velocity slices;
- krenzo for interactive renzograms; and
- koords for interactive coordinate placement.
Much of this package requires only the same basic system as
does the Karma package, i.e. a generic UNIX/X11 platform, although
special hardware may be required for a few programs.
The package is documented in a user's manual available in
It appears that this is slowly being absorbed into the Karma package.
- A finite element simulation model for saturated or unsaturated,
variable density ground water flow with energy or chemically reactive
single species solute transport.
SUTRA can be used to areal and cross-sectional modeling of
saturated ground water flow systems as well as for cross-sectional
modeling of unsaturated zone flow.
Solute transport can be used to model natural or man-induced
chemical species transport including the processes of solute
sorption and production and decay.
Groundwater contaminant transport problems and aquifer restoration
designs can also be analyzed.
The solute transport capabilities can also be used for modeling
variable density leachate movement and the cross-sectional modeling
of saltwater intrusion in aquifers on near-well or regional scales
with either dispersed or relatively sharp transition zones between
freshwater and saltwater. The energy transport simulation capabilities
can be used to model thermal regimes in aquifers, subsurface heat
conduction, aquifer thermal energy storage systems, geothermal
reservoirs, thermal pollution of aquifers, and natural hydrogeologic
The SUTRA model uses a 2-D hybrid finite element and integrated
finite difference method to approximate the governing equations
describing the processes simulated, i.e. fluid density-dependent
saturated or unsaturated groundwater flow and transport of either
solute or thermal energy in the groundwater.
A source code distribution of SUTRA for UNIX platforms is
The primary documentation is contained within
This is part of the USGS
Water Resources Applications Software
- The Singular Value Decomposition PACKage
consists of four numerical (iterative) methods for computing
the singular value
decomposition (SVD) of large sparse matrices using double precision ANSI
Fortran 77. A compatible
ANSI-C version (SVDPACKC) is also available. This software package
implements Lanczos and
subspace iteration-based methods for determining several of the largest
singular triplets (singular
values and corresponding left- and right-singular vectors) for large
sparse matrices. The package has
been ported to a variety of machines ranging from supercomputers to
workstations: CRAY Y-MP,
CRAY-2S, Alliant FX/80, SPARCstation 10, IBM RS/6000-550, DEC 5000-100,
and HP 9000-750.
The development of SVDPACK wa motivated by the need to compute large
rank approximations to
sparse term-document matrices from information retrieval applications.
Future updates to
SVDPACK(C), will include out-of-core updating strategies, which can be
used, for example, to handle
extremely large sparse matrices (on the order of a million rows or
columns) associated with extremely
large databases in query-based information retrieval applications.
See Berry (1992).
- Scalable Vector Graphics is a specification for a format
written as a modular XML tagset and usable as an
XML namespace which can be widely implemented in browsers and
authoring tools and which can serve as a replacement for the many
current raster graphics implementations.
The graphics features required by the standard include:
- a complete and general-purpose format that meets the needs of all
creators and consumers of Web graphics;
- sufficient power and precision for graphic designers to use it instead
of raster formats when vector graphics are more appropriate;
- a rich enough feature set so most existing standard static graphics
files can be readily converted into SVG;
- sufficient compatibility with existing feature sets and file formats
such that there is a straightforward and lossless as possible mapping
from them to SVG;
- compatibility with high-quality and efficient printing at full
printer resolution and with reliable color; and
- a basic foundation with presentation-level graphics facilities that is
sufficiently extensibility to allow a higher-level standard to sit on top
- The SVG Viewer is a viewer for 2-D graphics files in
This is implemented as a set of Java libraries.
It requires JDK 1.2 and the Java Project X Core
It is freely available under a license based on the BSD license.
- A library for the creation of GUIs which will work with both
SVGAlib and Xlib.
The available objects include buttons (normal, light, pixmap,
check, and radio), sliders (vertical, horizontal, nice horizontal
and vertical, and nice value), image, browser, pulldown,
text (normal and embossed), numbers (normal and digital),
input (normal, float, and integer), and more.
- A low-level graphics library for Linux platforms.
SVGALIB was originally based on VGAlib 1.2, but has been greatly
extended to support many more chipsets.
It supports transparent virtual console switching, i.e. you can
switch consoles to and from text and graphics mode consoles
with just a keystroke.
It includes code to hunt for a free virtual console on its own in
case it is not being started from one, i.e. from over a network
or within screen or xterm.
When it is used by a program at runtime, the chipset is first
detected and then the appropriate driver is used, thus enabling
the graphics program to work on any card supported by SVGALIB if
the mode it uses is supported by the chipset driver for that card.
A source code distribution of SVGALIB is available which can
be easily configured and compiled on Linux Intel systems.
Documentation consists of some ASCII text files and an extensive
set of man pages for the available library calls.
- This uses extra features found in all SVGA video cards to enhance
Linux text modes independently of what the BIOS can do.
It is configured with an XF86Config-like file, and allows
setting of pixel clock, H/V timings, font size, cursor size, etc.
It enables using the video card AND the monitor to their full
potential in textmode, as in the
X Window system.
- The Support Vector Machines
Matlab toolbox implements a set of
statistical learning methods.
Documentation is contained within a technical report available
in PostScript format.
- The Shared Virtual Memory library is an
emulation of shared memory in a distributed memory environment.
The features of SVMlib include:
In addition to the native SVMlib C++ API it
also offers additional APIs for compatibility with other projects
- designed to run on WinNT boxes although an emulation layer called
nt2unix can be used to compile and run it on UNIX boxes;
- integration of scalable distributed synchronization algorithms for
implementing consistency models;
- support for regular protocols such as TCP/IP
as well as special high-performance interfaces;
- implementation of user-configurable consistency models; and
- support for high level distributed services like parallel
shared virtual memory allocation.
A binary version for Linux platforms is available upon the completion
of a registration form.
- SMI, the Shared Memory Interface for NUMA cluster;
- CVM, the Coherent Virtual Machine;
- SPLASH, a suite of multiprocessor applications; and
- JIAJIA, a software DSM system.
- A implementation of Support Vector Machines in C.
SVMs are used in pattern recognition problems such as text
The features of SVMlight include a fast optimization algorithm,
handling several thousands of support vectors, handling several tens of
thousands of training examples, support for standard kernel functions
as well as the capability of defining your own, and use of sparse vector
The source code is available as are binaries for Sun SunOS and Solaris and
Documentation is contained within a man page as well as in some
- A GUI toolkit implemented entirely in Java.
SWANK is to Jacl as Tk is
to Tk, and as such it is designed to provide
a reasonable level of backwards compatibility with Tk.
This uses an automatic code generation technique wherein the methods for
each Swing class are deduced and then Java code is automatically
written with a Tcl script to implement a Tcl/Tk-like scripting
- A software package for
multi-agent simulation of complex
systems intended to be a useful tool for researchers in a variety
of disciplines, especially artificial life. The basic Swarm
architecture, in which a large variety of agent-based models can
be implemented, is the simulation
of collections of concurrently
interacting agents. The package provides object-oriented
libraries of reusable components for building models and
analyzing, displaying, and controlling experiments on those
The Swarm package can be divided into
simulation, software support, and model specific libraries.
The simulation libraries are further divided into:
The software support libraries were written to support modeling but
could also have applications beyond simulation, i.e. they encapsulate
the basic engineering tasks needed to write effective software.
The include general purpose tools for building object-oriented
programs, a random number class, and a graphical interface library.
The model specific libraries are those that are used for particular
modeling domains, e.g. libraries for two-dimensional spaces, genetic
algorithms, and neural networks.
- a swarmobject
library containing the core classes upon which agents in Swarm
models are based;
- an activity library containing the heart of
the simulation mechanism, i.e. the scheduling data structures and
execution support; and
- a simtools library containing a miscellaneous
collection of classes needed to build simulations, e.g. classes to
control the execution of the entire simulation apparattus and
classes for data analysis and display support.
The source code for the Swarm software is available as are binaries
for some platforms (including Linux). It is written in GNU
Objective C and the X Window system.
It also requires the
There is quite of bit of documentation available in PostScript
and HTML format.
- A security package for conveniently monitoring
events on a large number of servers and workstations.
The package modifies several programs on each
system to enhance their logging
capabilities and then configures the logging facilities of each system
to send a copy of the critical system and security related information
to a dependable, secure, central logging host system.
A reasonably large group of machines can create a considerably large
central large each day, so a program called swatch was
created as an easily configurable log file filter and monitor.
It monitors log files and acts to filter out unwanted data and take
one or more user-specified actions (e.g. send an email, execute a
script, sound an alarm) based upon patterns found in
A source code distribution of this collection of
Perl scripts is available.
It is documented in man pages as well as
in a conference paper in PostScript format.
- See Scientist's Workbench.
- A editor for sound samples whose features include:
- loading and saving PCM encoded sound formats, e.g. AIFF, AU and WAV;
- multiple views of each sound sample, e.g. viewing different parts
of the same sample in different windows, etc.;
- discontinuous interactive selecting of subsamples;
- cut, copy and paste;
- multiple undo and redo;
- simple effects filters, e.g. normalization and time reversing;
- choice of playback modes, e.g. entire sample, selected regions,
- piano-style playback wherein keyboard keys behave like musical keys; and
- separate volume levels per view.
- A software feedback toolkit for building adaptive and predictable
SWiFT is designed to offer the same sort of feedback mechanisms
used in hardware systems to software systems.
It offers a general method for implementing feedback mechanisms as
opposed to the current ad hoc structure of the various available
The toolkit can be used to create complex feedback components
from simpler components in a hierarchical fashion.
It introduces the concept of guarded feedback components, i.e.
those that function well under some conditions but which can
be replaced with others designed to work under different conditions
if the environment changes sufficiently.
The process is known as the replugging of the guarded component and
allows a system to adapt to highly dynamic environments.
A source code distribution of the SWiFT software is available.
It includes both C++ and
Java versions, with the former having a more
complete library and the latter supporting distributed and threaded
components (while the former doesn't).
The toolkit is documented in a thesis available in PostScript format.
- The Simplified Wrapper
and Interface Generator is
a tool for scientists and programmers to use to integrate
common scripting and interface languages such as
Guile with programs
containing collections of functions written in
C or C++.
SWIG automates the process of writing highly specialized
wrapper codes for each language and makes it easy to extend
an interface language without having to worry about the
nasty details. SWIG was developed to provide a system
that would make it easy to put together interesting applications
involving numerical simulation, data analysis, and visualization
without having to worry about tedious systems programming or
making substantial modifications to existing code.
Possible applications of SWIG include:
- building powerful interfaces to existing C programs;
- rapid prototyping and application development;
- interactive debugging;
- creating a GUI (e.g. using Tk);
- testing of C libraries and programs using scripts;
- building high-performance C modules for scripting languages;
- making C programming either more enjoyable or tolerable; and
- impressing babes.
SWIG is used by
first creating an interface file containing C style
declarations of functions, variables and constants that
you want to build into a user interface. Next a parser
takes this file and converts it into an internal representation,
which is passed to a code generation module which produces C
code and a documentation module supporting ACII,
LaTeX, and HTML. Each
module is implemented as a collection of C++ classes which simplifies
the process of supporting new languages and allows the user
to expand the system.
The significant features include:
- usage of ANSI C syntax, although the parser isn't designed to be a
full ANSI C compiler, e.g. advanced C/C++ constructs may not be recognized;
- non-intrusive interface building requiring minimal modifications to
existing C code;
- hands-off code generation requiring no hand modifications;
- an event-driven program development style, i.e. programs are
collections of functions and an infinite loop that sits and waits for
something to be done; and
- automatic document generation in several different formats.
The SWIG source code is available and can be compiled and
installed on generic UNIX boxes with an ANSI C compiler,
e.g. GCC. The documentation is contained within a 50+ page
users guide available in PostScript and ASCII formats.
- A set of components in the JFC for creating
GUIs for applications and applets.
These are included in JDK 1.1 and greater, and replace
the AWT components used in JDK 1.0.
The features of Swing include:
- the usual range of standard GUI components such as buttons, lists,
menus, text areas, etc. as well as containers such as windows and tool bars;
- a choice of five layout managers;
- efficient handling of a wide range of event types;
- an upper level class called JComponent that provides descendant
functionality including tool tips, borders, keyboard-generated actions,
an application-wide pluggable look and feel, support for layout and
acessibility, double buffering, and methods to increase efficiency;
- Action objbects providing support for sharing data and state
between two or more components that can generate action events;
- support for assistive technologies such as screen readers; and
- separate data and state models that allow more efficient working
with components as well as more easily sharing data and state between
- A Prolog compiler in the
Edinburgh Prolog family.
It has been designed and implemented to create a Prolog implementation
which can be used for experiments with logic programming and its relation
to other programming paradigms, with the intention being to build an
environment offering sufficient power and flexibility to write
substantial applications as well as one straightforward enough to be
modified for experiments with debugging, optimization, or the
introduction of non-standard data types.
The features of SWI-Prolog include:
The speed of compiled code isn't great, but it does
have fast database manipulation and efficient implementations
for various meta-call procedures.
The GUI development environment is supplied by connecting
the XPCE package to SWI-Prolog.
- a comprehensive set of built-in predicates,
- a module system and a garbage collector,
- dynamic expansion of runtime stacks,
- an interactive development environment,
- an execution profiler,
- exception-based autoloading,
- a quick load format and fast compiler,
- a two way interface to C that is
safe to the garbage collector,
- machine-independent saved states, and
- embedding in C applications.
The source code for SWI-Prolog is available. It is written in
ANSI C and can be easily compiled on Sun SunOS and Solaris and
Linux Intel systems via the supplied configure file.
An executable binary is available for Linux Intel platforms.
The systems is documented in a reference manual available
from within the program or as a separate document in either
HTML or PostScript format.
- The Simple Web Indexing System for
Humans can index directories of files on a Web site and
search the generated indices. The features include:
- support for multiple search indexes on a single system via
multiple configuration files;
- mostly user configurable;
- fast searches and fairly stingy with disk space; and
- several sample configurations included in the distribution.
- The Simple Web Indexing System for
Humans is a tool that lets
you create indexes of directories of files (including HTML files)
and search them for key words or combinations thereof. The search
process can be done via a command line interface or automated for
use on a Web page using a program called
WWWWais. Swish is simpler
than some other indexing systems and is designed to work well with
Web pages. It was written in vanilla C and should compile readily
on UNIX boxes, e.g. it compiled using GCC on my Linux box on the
- A file indexing and searching engine most often used to index and search
files on Web sites.
It is a complete rewrite of SWISH-E developed
to circumvent limitations in that package.
The features include:
A source code distribution is available.
It is written in C++ and requires a version
of STL for compilation.
It is documented via a series of man pages.
- extremely fast indexing via the use of good algorithms and data structures
as well as fast I/O;
- automatically splitting
and merging partial indices for large collections of files to avoid
memory exhaustion and swapping problems;
- extremely fast searching;
- a results format that is easy to parse;
- indexing non-text files such as Microshaft Office documents; and
- not crashing while indexing any file.
- A program that tracks changes in suid/sgid files and folders, i.e.
it ascertains whether there are any new ones, ones that were set
but currently aren't, or ones that have chnaged bits or other
modes. This also tracks suid/sgid files by MD5 checksums to help
detect if a root kit has been installed which would not show under
normal name and permissions checking. Directories are tracked via
This is meant to be run as a cron job but can also be
run manually for spot checking.
A source code distribution of this C program is available.
- Programs for finding all eigenvalues and eigenvectors of real
symmetric diagonalizable matrices in parallel. These can be
easily adapted to resolve only a part of the eigenvalue
spectrum. SYISDA uses MPI
for message passing, and as such should run on any machine
support that message passing system, including Linux.
- A Fortran 77 package for solving the
Sylvester matrix equation, with separate methods used for the
continuous-time symmetric and discrete time versions.
This is TOMS algorithm 705 and is documented
in Gardiner et al. (1992b) and
Gardiner et al. (1992a).
- Scott's Yet another Language Unification
is a version of Xerox PARC's ILU
written entirely in Python. It
is on-the-wire compatible with ILU although all of the features
are not yet (10/97) implemented.
- A mixed symbolic numeric program package for the treatment
of parameter dependent systems of equations. The program is a
combination of symbolic and numerical computations with graphical
output and menu interface. The numerical part is written in C,
and the graphical part is supposed to run under either SUNVIEW
or the OPENWINDOWS environment, the latter of which should be
available for Linux platforms (although I haven't attempted this
A source code distribution of SYMCON is available.
It is written in C and is documented in a user's manual
available in PostScript format.
This is part of CodeLib.
- A computer algebra package devoted to representation theory,
invariant theory, and the combinatorics of finite symmetric
groups and related classes of groups (e.g. the alternating
groups, wreath products of symmetric or alternating groups, finite
and infinite linear groups, and other classes of groups).
It is meant to be a tool for those working on representation
theory or on its application to mathematics, physics or chemistry.
Symmetrica provides routines for handling several mathematical
- ordinary irreducible and Brauer characters
as well as decomposition numbers of symmetric groups;
- ordinary irreducible characters of alternating groups;
- ordinary irreducible
characters of wreath products of symmetric groups;
- ordinary and
modular irreducible matrix representations of symmetric groups;
- ordinary irreducible polynomial representations of general
- multivariate polynomials and, in particular, Schubert
and zonal polynomials;
- Schur polynomials as well as several other
series of symmetric polynomials;
- cycle indicator polynomials for
combinatorial enumeration; and
- the ordinary group algebra of the
The Symmetrica distribution includes the source code, written in
standard C that should compile on most platforms with a C
compiler, and a 180 page user's manual in TeX and PostScript
- A program designed to solve systems of linear equations Ax = b
where A is an n-by-n symmetric matrix and b is a given vector.
The matrix A is not required to be positive definite but is
intended to be large and sparse.
Preconditioning is also offered as an option.
The program is available as Fortran source code and is documented
in comment statements in the code.
- A mailing list manager that automates
various functions such as subscription, moderation and management
of archives. The features include:
A source code distribution is available which requires
Perl 5.003 or greater.
- compatibility with most SMTP engines;
- multilingual capabilities with English and French currently
- storage of internal data in a RDBMS (with current support for
- MIME support;
- per list configuration including basic distribution control
and various moderation tools;
- abuse protection via a fine-tuned definition of who has the
right to post messages in a list;
- various membership options including a conceal option to not
appear in the member list; and
- a design for high performance with very large lists.
- The Single- or Multi-Process Optimization over
Networks package is a fully parallel, generic implementation of
the branch, cut and price algorithm for solving integer and
SYMPHONY allows users to implement a state of the art branch and cut
algorithm for virtually any problem setting by supplying only model-specific
preprocessing and separation functions.
The remaining components of the branch and cut framework are entirely
internal to the library.
Executables can be built for single processor machines, for any
environment supporting PVM and for shared
memory architectures using any OpenMP
- A command and a software suite for large-scale systems administration,
with the former being an intelligent file copier and the latter
a set of programs for describing, generating and managing system
This uses a file form database to hold a full network's configuration
in an understandable, secure location.
Synctree uses a compare-before-copy strategy, with a fairly rigorous
definition of identical including date, size and MD5 digest.
It also checks file ownership, group and mode, and will correct them
if they are wrong but the file's contents are correct.
Other utilities in the package include:
- presas and posas, for stopping and starting daemon
programs during the distribution of new versions;
- precedence, for determining which classes a given file
- mksynclist, lists Synctree clients and/or classes;
- whosyncs, displays a list of all machines and classes
containing a given filename;
- cisync, copies a file from a local machine to Synctree classes;
- cosync, obtains a particular file from Synctree;
- addclass, installs a new Synctree class on a machine; and
- rmclass, removes Synctree classes.
- A ray tracing package.
The ray tracer can handle a variety of quadric surfaces,
a few planar objects, and circular tori. The tracer
also supports reflection and refraction.
A fully procedural description language has rich
support for 3-D manipulation and offers vector arithmetic
and colors and built-in types.
The synpic system is written in ANSI C and can be installed on
most generic UNIX platforms using a supplied configure script.
The installation and use of synpic requires the
uri library package.
The ray tracer is documented in a man page.
- A set of tools for the design and implementation of the front-end
part of translators in the compilation field. The SYNTAX tools
allow the generation of analyzers and the compilation of source
texts with those analyzers.
This has all the capabilities of lex
and yacc plus some additional features
including better error processing, i.e. an automatic (and
tunable) error repair and recovery mechanism.
The modules comprising SYNTAX are:
Distributions are available for several systems including
Linux Intel. A user's manual written in French is available in
- BNF, a which takes a context-free grammar (CFG) and produces
an internal form used by the other modules;
- CSYNT, which checks that the input CFG is LALR(1) compliant;
- LECL, a scanner generator which takes as input the lexical
specification level in regular expression form;
- RECOR, which processes the lexical and syntactic error
processing specifications; and
- TABLES-C, the collects the output of the other modules and
generates a C program to be linked with the SYNTAX library.
- A system monitor daemon written in
Perl 5. This monitors the components
comprising a UNIX server, e.g. sendmail, inetd, named and
A configuration file containing the server daemons to be monitored
is scanned at a specified interval.
If one or more is missing an email is sent to a specified address.
- SYSLINUX is a boot loader for Linux that operates
off of an MS-DOS/Windows FAT filesystem.
It is intended to simplify first-time Linux installations as well as for
the creation of rescue discs and other special purpose boot discs.
PXELINUX, a SYSLINUX derivative, is for booting Linux from a network
server using a network ROM conforming to the Intel PXE (Pre-Execution
- A syslogd replacement for UNIX systems with an enhanced and
improved configuration scheme.
Messages can be filtered based not only on priority/facility pairs
but also on message content. Regular expressions can be used to
direct log streams to different destinations, with a destination
being anything from a simple file to a network connection.
TCP log forwarding and hashing are supported
to prevented unauthorized modification.
Log file changes can be detected since a digital fingerprint of
all messages is stored.
- A Common Lisp library for remote system
and network management based on SNMP.
This currently (1/99) supports SNMP version 1, i.e.
- system administration
- Packages developed for administering one or more machines in other
than a random way include:
- acct, a set of accounting utilities which
provide information about system usage;
- ACMAINT, a system for account creation and
maintenance on distributed UNIX systems;
- ACUA, for administering user accounts and
enforcing access restrictions;
- AgentD, a scheduling daemon which schedules
system administration procedures at chosen intervals;
- Cfengine, a language for testing and
configuring heterogeous UNIX-like systems;
- chklogs, maintains system logs;
- COAS, a project to improve the way users
administer their Linux systems;
- DQS, which distributes computational resources
across a network;
- GASH, a special shell
for distributed NIS administration;
- GeNUAdmin, an automatic sysadmin tool for
configuring heterogeneous UNIX boxes;
- ipfwadm, for administering the IP accounting
and firewall services offered by the Linux kernel;
- KerbNet, an implementation of Kerberos
that provides an administrative interface;
- Linuxconf, a fully integrated
system administration tool for maintaining a working Linux system;
- Logcheck, for spotting problems in system
- logtail, for dynamically monitoring any
number of system log files;
- LogWatch, a log monitoring system;
- psntools, for adminstering large numbers
of user accounts;
- SATAN, a security administrator tool;
- SFI Director, a tool for managing
distributed and heterogeneous UNIX system clusters;
- SNMP, under which several administration
tools are listed;
- SumLog, creates summaries of system logs;
- traceroute, for tracing the route that
IPpackages take in getting to a destination system;
- Webmin, a Web-based interface for system
- XUser, an interface to the shadow password
- The goal of the Open SystemC Initiative is to establish a modeling
platform for System-on-Chip (SoC) design
that enables, promotes and accelerates system-level co-design
and IP (intellectual property) model exchange.
SystemC is the the modeling platform and consists of
C++ class libraries and a simulation kernel
for design at the system-, behavioral- and register-transfer-levels.
Models are created using SystemC with a standard ANSI C++ compiler.
The SystemC Class Library (SCL) provides the constructs needed to model
software interrupts and hardware timing, concurrency and reactive
behavior that are missing in standard C++.
The features of SystemC that allow it to be used as a co-design language
- a container class called a module that can have other modules or
processes contained within it;
- the use of three different process abstractions to describe
- both single- and bi-directional ports for modules that allow them
to connect to other modules;
- support for both resolved and unresolved signals;
- a large set of port and signal types to support modeling at different
levels of abstraction;
- a large set of data types to support multiple design domains and
- the available of clocks (as special signals) to timekeeping during
- cycle-based simulation via a cycle-based simulation kernel that
allows high-speed simulation;
- multiple abstraction levels ranging from high-level functional
models to detailed RTL models;
- successive refinment of high level models into lower levels of
- multi-level communication semantics that allow the description of
I/O protocols with different abstraction levels;
- debugging via run-time error checking; and
- waveform tracing in VCD, WIF and ISDB formats.
SystemC is freely available via an Open Community License wherein
users are required to license bug fixes back to other users and
modifications that effect interoperability are not allowed.
Obtaining the package entails completing an online form and
obtaining a username and password combination for downloading.
It is currently (9/99) supported on Linux and Solaris platforms.
- A emulator of the Sega System16 arcade
- A freeware, portable, general-purpose, lossless compression program
with high speed, compression, and memory demands.
It uses a blocksort variant with a maximum blocksize of 4.1 MB, so
compression is better for larger files. It uses a byte-oriented
coder for output and a prediction model specifically developed for
A binary version of szip is available for Linux Intel platforms.
[ home /
Up: Linux Software Encyclopedia