Next: Ta-Tm Up: Linux Software Encyclopedia Previous: Sa-Sm Contents

Sn-Sz

Last checked or modified: Jan. 8, 2001

SNA: 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:

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 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.''
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:

APPN Implementers Workshop
http://www.networking.ibm.com/app/aiwhome.htm

AnyNet: Guide to SNA over TCP/IP
http://ppdbooks.pok.ibm.com:80/cgi-bin/bookmgr/bookmgr.cmd/BOOKS/ISTI4002/CCONTENTS

AnyNet: SNA Over TCP/IP Installation and Interoperability
http://www.raleigh.ibm.com:80/cgi-bin/bookmgr/BOOKS/EZ302400/CCONTENTS

APPC Application Suite User's Guide
http://ppdbooks.pok.ibm.com:80/cgi-bin/bookmgr/bookmgr.cmd/BOOKS/APPA2000/CCONTENTS

Linux-SNA

A project to develop a working SNA implementation for Linux.
[http://www.linux-sna.org/]
Snacc: 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:

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.

The ASN.1 features supported include:

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.

A source code distribution is available.
[http://www.fokus.gmd.de/ovma/freeware/snacc/entry.html]
Snack: 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 1-D signals. The features include:

commands for basic sound operations, e.g. playing, recording, reading and writing;

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.

[http://www.speech.kth.se/snack/]
SnapFS: An enhancement for Linux journaling filesystems that provides snapshots and versioning. The main components of SnapFS include:

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 transactions.

SnapFS is based on parts of both the Lustre and InterMezzo projects.
[http://www.snapfs.org/]
Snapix: 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:

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.

A Linux version is freely available and comes with 110+ page manual in PostScript format.
[http://sunsite.unc.edu/pub/Linux/X11/devel/builders/]
SnarfNews: The name of this has been changed to Sitescooper.
snd: 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 CLM package.
[http://www-ccrma.stanford.edu/CCRMA/Software/snd/snd.html]
SNDAN: 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.
[http://cmp-rs.music.uiuc.edu/cmp/facil/software.html]
SNePS: The Semantic Network Processing System is a system for building, using, and retrieving from propositional semantic networks. 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 and CMUCL. It may also work with AKCL and Allegro CL. The program and its use are documented in a 94 page user's manual available in PostScript format.
[http://www.cse.buffalo.edu/sneps/]
snes: 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.
[http://www.snes9x.com/]
[http://sunsite.unc.edu/pub/Linux/system/emulators/]

SNES9EXPRESS

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 fly.
[http://www.linuxgames.com/snes9express/]
SNI: 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.
[http://iee.umces.edu/~villa/sni/]
sniffers: 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.
Sniffit: A packet sniffer which supports both Ethernet and PPP. See the related TOD.
[http://reptile.rug.ac.be/~coder/sniffit/sniffit.html]
[http://lrp.steinkuehler.net/Packages/sniffit.htm]
SNLS1E: 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.
[http://sunsite.doc.ic.ac.uk/public/computing/general/statlib/cmlib/]
SNMP: 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 locating information. 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 UCD-SNMP. 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 SNMP agent;

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 to TCP/IP;

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 network management;

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. see Black (1995a), Comer (1991), Comer and Stevens (1991), Comer and Stevens (1993), Feit (1994), Griffith and Hein (1994), Halsall (1996), Leinwand and Fang (1993), Miller (1993), Perkins and McGinnis (1997), Rose (1994), Rose and McCloghrie (1995), Stallings (1993), Stevens (1994), Taylor (1996), and Townsend (1995).
[http://netman.cit.buffalo.edu/Archives.html]
SNMPY: An interface to SNMP for Python.
[http://snmpy.sourceforge.net/]
SNMX: 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:

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 device;

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.

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 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.
[http://www.ddri.com/Products/ace-snmx.html]
SNNAP: 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 framework;

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 PostScript format.
[http://nba19.med.uth.tmc.edu/snnap/home.htm]
SNNS: 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 neural networks. 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 SNNS include:

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.

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.
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.
[http://www.informatik.uni-stuttgart.de/ipvr/bv/projekte/snns/snns.html]
Snob: 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 numerical taxonomy. 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 missing data.
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.
[http://www.cs.monash.edu.au/~dld/Snob.html]
SNOBOL: 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.
[http://people.ne.mediaone.net/philbudne/snobol.html]
[http://iris1.let.kun.nl/TSpublic/coppen/SNOBOL.html]

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 Griswold (1975).
[http://people.ne.mediaone.net/philbudne/src.html]
Snort: 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.
[http://www.snort.org/]
SNP: 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 PostScript format.
[http://lib.stat.cmu.edu/general/]
SOAR: 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.
[http://bigfoot.eecs.umich.edu/~soar/]
Socket++: A library of C++ classes that can be used more effectively to work with sockets than directly calling the underlying low-level system functions. It has the same interface as that of the iostream library in the G++ library.
[http://www.cs.utexas.edu/users/lavender/courses/socket++/]
[ftp://ftp.virginia.edu/pub/tools/]
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 complex. 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.
[http://www.linsupport.com/sw/socketscript.html]
SOCKS: An open Internet standard for performing network proxies at the transport layer. This is also known as authenticated firewall traversal (AFT) and is described in RFC-1928. 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:

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.

These features allow SOCKS users to build virtual private networks (VPN) over the Internet which offer: one-time sign on, user-based authentication, 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.
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.

[http://www.socks.nec.com/]
SoftFloat: 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:

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.

The only required IEC/IEEE functions not supplied are conversions to and from decimal.
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.
[http://HTTP.CS.Berkeley.EDU/~jhauser/arithmetic/SoftFloat.html]
SoftRelTools: 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 Fortran, C and C++. 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 offline software.
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 package;

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.

[http://RunIIComputing.fnal.gov/runiiweb/cmgt.html]
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 runtime. The components are also programmable in that they can be composed into larger components.
The components of the ChipSet are:

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.

A source code distribution is available. All components are written in C for maximum portability.
[http://www.sander.cupertino.ca.us/source.html]
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 and hardware;

EVES, a formal methods tool;

Expect, a tool for automating and testing interactive applications;

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 tool;
software configuration management: Related packages include:

Aegis

BitKeeper

Bonsai

CVS

CSSC

Depot

DVS

gbuild

ICE

LUDE

MK

NUCM

ODE

PRCS

RCS

SCCS

SEPP

ShapeTools

SRM

Stow

TCCS

UCM

WISE

XDelta
SOLID: 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 VRML. 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 vertex arrays;

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.
[http://www.win.tue.nl/cs/tt/gino/solid/]
SOLO: A standalone shell and boot loader for protected mode 32-bit x86 microkernels, operating systems, and standalone programs. The SOLO features include:

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 files;

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 modes;

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 about crashes;

an extensible built-in help command; and

several 32-bit test programs.

Source code and demo binary disk images are available.
[http://www.csh.rit.edu/~shaggy/software.html]
SOLVATE: A program for constructing atomic solvent environment models for given atomic macromodule models (solutes) used in molecular dynamics simulations. The capabilities of SOLVATE include:

generation of irregularly shaped solve volumes adapted to a given solute's structure;

efficient computation of boundary forces as required in molecular dynamics simulations;

a guaranteed minimal solute boundary distance;

specification of a minimum solvent surface curvature to avoid flat surface regions;

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.
[http://www.mpibpc.gwdg.de/abteilungen/071/solvate/docu.html]
[ftp://ftp.osc.edu/pub/chemistry/software/SOURCES/FORTRAN/solvate/]
SOMA: 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.
[http://sunsite.unc.edu/pub/Linux/system/mail/mua/]
SOM_PAK: 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).
[http://www.cis.hut.fi/nnrc/nnrc-programs.html]
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 than two.

[http://www.cis.hut.fi/projects/somtoolbox/]
SoPlex: 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:

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 pricer classes include:

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 ratio test 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 simplifier classes are:

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 start basis classes include:

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.

The linear system solver classes are

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 the site.
[http://www.zib.de/Optimization/Software/Soplex/index.html]
sound: Useful metasites for such things include:

Linux Sound Applications
[http://www.bright.net/~dlphilp/linux_soundapps.html]

Applications for Open Sound System
[http://www.opensound.com/ossapps.html]

Audio File Formats FAQ
[http://home.sprynet.com/~cbagwell/AudioFormats.html]

Sound HOWTO
[http://metalab.unc.edu/mdw/HOWTO/Sound-HOWTO.html]

Audio Quality HOWTO
[http://members.tripod.com/~slinkP/pw_linux/Audio-Quality-HOWTO.html]

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 package;

CM, an object-oriented music composition environment;

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 music composition;

PD, a programming language for computer music;

saolc, an MPEG-4 feature allowing sound to be described with a high-level, sophisticated synthesis language;

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 processing suite;

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 manipulation;

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 music typesetter;

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 sequencer;

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 WAVE converter.
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:

MOD FAQ
[http://www.castlex.com/modfaq/]

Exotica File Formats
[http://perso.club-internet.fr/lclevy/exotica/formats.html]

Wotsit's Formats
[http://www.wotsit.org/]

Amiga MOD Packers
[http://www.multimania.com/asle/ampd.html]

Available sound and module players include:

FMP

FreeAmp, an MP3 audio player;

Maplay, an MPEG audio player;

MikMod, a sound module player;

Tracker, for playing Soundtracker and Protracker MOD files;

WavPlay, for recording and playing WAV files; and

xmp.

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:

sf ALSA, a project to create a fully modularized sound driver for Linux systems;

BashFest, a virtual drum machine front-end to CMIX;

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;

See also the CD-ROM, MPEG and MBone sections for related packages.
[http://www.bright.net/~dlphilp/linux_soundapps.html]
[http://www.castlex.com/modfaq/]
[http://www.digiserve.com/ar/linux-snd/]
SoundTracker: 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.
[http://www.soundtracker.org/]
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 integer index;

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 that vector;

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 vector;

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 memory window;

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 quantizer;

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.

[http://www.ee.umn.edu/users/kieffer/programs.html]
source code documentation/formatting: Packages related to the documenting and/or formatting of source code include:

Artistic Style, an automatic indentation filter;

Cxref;

DOC++;

Exuberant Ctags; and

literate programming packages are one elegant and useful way to document and print source code.
SoX: 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 bug fixes.
[http://home.sprynet.com/~cbagwell/sox.html]
[http://www.spies.com/Sox/]
SP: 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, LINK, etc.;

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 platforms.
[http://ftp.jclark.com/sp/]
SP (Semidefinite Programming): The Semidefinite Programming software is an implementation of Nesterov and Todd's primal-dual potential reduction method for semidefinite programming.
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, LMITOOL, MAXDET, SDPA, SDPpack, and SDPSOL.
[http://www-ISL.Stanford.EDU/people/boyd/SP.html]
space: 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 simulations. Its major functions are:

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 source code distribution of this C++ package is available along with a manual in PostScript format.
[http://www.schonlau.net/space.html]
Space: 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.
[http://www.muse.demon.co.uk/csound.html]
SPACELIB: 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:

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.

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.
[http://bsing.ing.unibs.it/~legnani/]
[http://isb.ri.ccf.org/tgcs/software/]
SPAK: 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:

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 source code distribution of SPAK is available. It is written in C and can be compiled on most UNIX flavors.
[http://www.xenos.net/~xenon/software/spak/index.html]
Spanner: A combination glue/scripting/prototyping programming language. 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.
[http://www.ataman.com/spanner/index.html]
SparkGL: A portable, fast graphics toolkit designed specifically for 16-bit graphics. This library sits on top of a display system such as SDL, OpenPTC or SVGALIB. The features include:

scaling;

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.

[http://sparkgl.netpedia.net/]
Sparse: 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.
[http://www.netlib.org/sparse/index.html]
SparseBLAS: 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 of these).
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.
[http://math.nist.gov/spblas/]
SparseLib++: 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. IML++), 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.
[http://math.nist.gov/sparselib++]
SparseQR: A C or C++ routine which computes the QR decomposition of a sparse matrix using row ordering. See Robey and Sulsky (1994).
[http://www.arc.unm.edu/~trobey/]
SPARSKIT2: 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 and sums. 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.
[http://www.cs.umn.edu/Research/arpa/SPARSKIT/sparskit.html]
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 be analyzes. 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 functions are:

fdetfil1, computes ln |l-aD| where D is a symmetric spatial weight matrix;

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.

[http://www.spatial-statistics.com/software_index.htm]
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.
[http://www.speakfreely.org/]
SPECDRE: 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.
[http://star-www.rl.ac.uk/store/storeapps.html]
SPECFUN: A collection of portable Fortran routines for calculating special functions. The routines include:

ALGAMA, for calculating the log(gamma) function for positive real arguments;

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).
[http://www.netlib.org/specfun/]
[http://www.acm.org/calgo/contents/]
[http://www.netlib.org/toms/index.html]
specPerl: A rewrite of SpecTcl for use with Perl.
[http://keck.ucsf.edu/~kvale/specperl.html]
SpecTcl: A development environment for building applications with graphical user interfaces that run on multiple platforms. The SpecTcl packages lets you design GUIs interactively and graphically, 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 at runtime, 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.
[http://dev.scriptics.com/software/spectcl/]
spectral analysis: Packages for performing various types of spectral analyses include:

ARfit,

Cubic Spline Library,

FFTPACK,

Matlab Astronomy Library,

MCSSA,

MSSA,

MTM,

PSD,

SNP,

SSA,

SSA-MTM,

STARPAC, and

XQz.
SPEM: The S-coordinate Primitive Equations Model is a finite difference ocean circulation model written in Fortran 77. It has been used for a variety of regional and basin scale simulations.
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 diffusion;

options for computing the vertical diffusion and viscosity coefficients; and

an option for using NetCDF for input and output files.

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 format. 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.
[http://marine.rutgers.edu/po/models/spem.html]
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 spherical convolutions. The included Legendre algorithms are:

a variation of the basic Driscoll-Healy algorithm;

a bounded DH-Mid algorithm; and

simple-split and hybrid algorithms.

The included spherical algorithms are:

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 from disk.

[http://www.cs.dartmouth.edu/~geelong/sphere/]
SPHERAY: 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 ellipticity.

[http://geosp6.ipgp.jussieu.fr/pub/logiciels/rays/]
SPHERE: 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:

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.

The available system level utilities include:

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.

[ftp://jaguar.ncsl.nist.gov/pub/]
Spherekit: An integrated toolkit for spatial interpolation and comparison of spatial interpolation algorithms developed at the NCGIA (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 spline.
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 interpolated fields.
[http://www.ncgia.ucsb.edu/pubs/spherekit/]
SPHEREPAK: 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 computed functions;

SHAECI, for initializing an array that may be used repeatedly by SHAEC;

SHSEC, for computing a synthesis on an equally spaced grid using computed functions;

SHSECI, for initializing an array that may be used repeatedly

SHAES, for computing an analysis on a equally spaced grid using stored functions;

SHAESI, for initializing an array that may be used repeatedly by SHAES;

SHSES, for computing a synthesis on an equally spaced grid using stored functions;

SHSESI, for initializing an array that may be used repeatedly by SHSES;

SHAGC, for computing an analysis on a Gaussian grid using computed functions;

SHSGC, for computing a synthesis on a Gaussian grid using computed functions;

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 functions;

SHSGS, for computing a synthesis on a Gaussian grid using stored functions;

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.
[http://www.scd.ucar.edu/css/software/spherepack/]
Sphinx: 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:

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.

A similar set of playback functions are available.
The available functions for continuous listening and silence filtering include:

cont_ad_init, associates a new continuous listening module with a specified raw A/D handle and a corresponding read function pointer;

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 speech thresholds;

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.

[http://www.speech.cs.cmu.edu/sphinx/Sphinx.html]
Spice: 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 MOSFETs. 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 of frequency;

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 platforms. 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 ng-spice. A user's manual is available in PostScript format.
[http://www-cad.eecs.berkeley.edu:80/Software/software.html]
[http://metalab.unc.edu/pub/Linux/apps/circuits/]

Oregano

A GNOME application for schematically capturing electrical circuits simulated using Spice.
[http://www.dtek.chalmers.se/~d4hult/oregano/]

spicepp

A preprocessor for Berkeley Spice 3f5 that adds support for structures provided by commercial versions of the program.
[http://www.reptechnic.com.au/spicepp.README.html]
SPIM: 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 instruction set. 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 flavors. A user's manual is available in either PostScript or HTML format.
[http://www.cs.wisc.edu/~larus/spim.html]
Spin: A package which supports the formal verification of distributed systems. 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 requirements.
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 approximation technique).

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).
[http://www.netlib.org/spin/]
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, i.e. Modula-3.
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.
[http://www.cs.washington.edu/research/projects/spin/www/]
spinne: A program that superimposes colored graphs onto 2-D plots of results of various projection methods as principal components 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.
[http://www2.organik.uni-erlangen.de/Bruno_Bienfait/Spinne/]
Spinner: This HTTP server software has been renamed Roxen.
SPKit: The Sound Processing Kit is an object-oriented class library for audio signal processing which includes classes for various signal processing tasks written in C++. 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:

SPKitReader, which reads audio files in 16 bit linear NeXt/SUN format; and

SPKitWriter, which writes files in the same format.

The basic signal processing classes are:

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.

A dynamics processing class includes:

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 filtering classes are:

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 band-pass filter.

The delay and reverberation class includes:

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 distortion class contains

SPKitWaveShaper, a waveshaping or non-linear distortion class.

A signal routing class comprises:

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.
[http://www.music.helsinki.fi/research/spkit/]
splib: 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.
[ftp://nic.fb4.noaa.gov/pub/nws/nmc/codes/interp/]
[http://sgi62.wwb.noaa.gov:8080/reanl2/wd20tm/grib/]
[ftp://ftp.ncep.noaa.gov/pub/nws/nmc/codes/interp/]
SPLIB: 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.
[ftp://ftp.cs.indiana.edu/pub/bramley/]
SPLIB: 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.
[ftp://microian.ian.pv.cnr.it/pub/splib/]
SPLIT: A Fortran package for computing synthetic seismograms of shear waves split by travelling through a stack of anisotropic layers. The seismograms are computed by solving the Eikonal equation.
[http://geoscope.ipgp.jussieu.fr/pub/logiciels/aniso]
SPLP: A subroutine which solves linear optimization problems. 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.
[http://sunsite.doc.ic.ac.uk/public/computing/general/statlib/cmlib/]
SPM: 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,

coregistration,

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.
[http://www.fil.ion.bpmf.ac.uk/spm/]
spock: 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 characteristics. 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 quality output. 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 surface properties;

support for several image formats including RGB, JPEG, PPM, GIF, TIFF, FBM, and PostScript;

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 online help.
[http://quorum.tamu.edu/jon/spock/]
SPONG: A simple system monitoring package written in Perl. SPONG features include

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.

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.
[http://www.edsgarage.com/ed/spong/]
SPOOLES: The SParse Object Oriented Linear Equations Solver is a library for solving sparse real and complex linear systems of equations. The functionality includes:

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 methods.

The source code is available as is a massive amount of documentation. The program is written in object-oriented C.
[http://www.netlib.org/linalg/spooles/]
Sporum: A Web-based discussion board software package with a unique interface, extensive administrative features, and easy installation. The detailed features of Sporum include:

storage of all information (e.g. messages, configuration data, etc.) in a server-side SQL database such as MySQL);

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 private protected;

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.

A freely available version is available with the above functionality, and a commercial version with additional features can also be obtained.
[http://smallpig.net/sporum/sporum.shtml]
SPRANNLIB: 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:

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.

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 psuedo-Newton.
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 separately. A user's guide and reference manual is available either in HTML or PostScript format.
[http://www.ph.tn.tudelft.nl/~sprlib/]
Spread: 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 failures;

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 no holes.

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 Linux Intel.
[http://www.spread.org/]
spreadsheets: Freely available spreadsheets for Linux platforms include:

Abacus

abs

MacroCALC,

moodss,

SIAG,

Teapot,

VOTE,

WINGZ, and

xxl.
SPRLIB: See SPRANNLIB.
SPRING: 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 multi-sensor integration;

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 called LEGAL;

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 output files.

The SPRING distribution includes:

a set of files shared by all applications, e.g. for interfaces and menus, on-line help, map symbols, and cartographical projection parameters;

spring, an application containing geoprocessing and image processing functions;

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.

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.
[http://www.dpi.inpe.br/spring/]
SPRNG: 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 C++ programs 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:

two versions of linear congruential with prime addend,

modified additive lagged Fibonacci,

combined multiple recursive generator, and

prime modulus linear congruential generators.

The MPI message passing software is supported with PVM support planned for future versions.
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 Linux Intel. 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.
[http://sprng.cs.fsu.edu/]
SPUC: 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 simulations.
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 classes.

A source code distribution for this C++ library is available along with a complete manual in HTML format.
[http://spuc.webjump.com/]
SPX: 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 principal. SPX provides strong authentication with the network utilities flogin, fcp and fsh, all of which permit strongly authenticated remote access.
[ftp://ftp.funet.fi/pub/unix/security/login/SPX/]
SPX (IRC): Sula PrimeriX is a multiple-server IRC client running under X11. The features include:

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 or extensions;

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 source code distribution is available. This is an extension of the earlier sula project.
[http://members.xoom.com/sprimerix/]
SPY: A LAN protocol analyzer with a built-in interface to a capture facility supporting Ethernet, FDDI, SLIP/CSLIP. PPP and PLIP. Other SPY features include:

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 protocols;

a built-in protocol description language (PDL) allowing users to define nearly any protocol; and

the definition of postfilters using the PDL.

An extensive user's manual is available in several popular formats.
[http://www.gromeck.de/Spy/]
SQL: 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:

processing sets of data as groups rather than individual units;

providing automatic navigation of data; and

standalone statements that are complex and powerful.

The functionality provided by the various SQL commands includes:

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 Information Links
[http://domaindlx.com/infolinx/sql.htm]

SQL Reference Page
[http://www.contrib.andrew.cmu.edu/usr/shadow/sql.html]

SQL Forum
[http://www.sqlforum.com/]

Ask the SQL Server Pro
[http://www.inquiry.com/techtips/thesqlpro/]

Introduction to SQL
[http://www.geocities.com/ResearchTriangle/Node/9672/sqltut.html]

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:

Transitional SQL as per FIPS PUB 127-2;

sizing parameters for database constructs specified in FIPS 127-2, Section 16.6;

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.

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.
[http://www.itl.nist.gov/div897/ctg/sql_form.htm]
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 predicative locks. SQL Server is based on a client-server architecture for DBMS organization. A source code distribution is available.
[http://www.ispras.ru/~kml/gss/index.html]
SQRL: 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 stages.
[http://www.sqrl.org/sqrl/]
sqsh: The SQ SHell is a replacement for the isql program created by Sybase for working with their SQL databases. This was designed to provide much of the functionality provided by a good shell as well as to be easily extensible. The features include:

all the commands provided by isql as well as many extended commands;

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.

Source and binary distributions are available.
[http://www.voicenet.com/~gray/Home.html]
Squeak: 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 development environment. 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 per object;

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 environment.
[http://www.create.ucsb.edu/squeak/]
[http://squeak.cs.uiuc.edu/]
Squid: 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 clients simultaneously);

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 the background;

unlinking of swap files on restart and the -U option to remove invalid objects from the disk;

a more flexible debugging scheme;

a new access control scheme; changes to cache shutdown;

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.
[http://www.squid-cache.org/]

Calamaris

A program that parses Squid logs and generates all sorts of nifty reports.
[http://Cord.de/tools/squid/calamaris/]

CrispySquid

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 collective cache.
[http://www.cs.duke.edu/ari/cisi/crisp/]

CSS

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.
[http://www.senet.com.au/css/]

Relais

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.
[http://www-sor.inria.fr/projects/relais/relais.html]

squidGuard

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 or words;

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.

[http://info.ost.eltele.no/freeware/squidGuard/]

Squirm

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.
[http://www.senet.com.au/squirm/]
SR: 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 and operations.
The implementation 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.
[http://www.cs.arizona.edu/sr/www/index.html]
SRFPACK: 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).
[http://www.acm.org/calgo/contents/]
[http://www.netlib.org/toms/index.html]
sRGB: 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.

[http://www.w3.org/Graphics/Color/sRGB.html]
SRLT: 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 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.

A source code distribution is available which is supported on several platforms including Linux Intel.
[http://research.ivv.nasa.gov/SRLT/]
SRM: 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 mechanism.
[http://www.cs.colorado.edu/serl/cm/SRM.html]
SRP: 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 of network. 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:

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.

Source code and binary distributions of the SRP implementation are available.
[http://srp.stanford.edu/]
SRRIT: 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).
[http://www.acm.org/calgo/contents/]
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 signal-to-noise cutoff.

[ftp://ftp.gi.alaska.edu/pub/eric/ssa/]
SSA-MTM: 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 Tcl/Tk toolkit. The results can be viewed graphically using either the ACEgr or Gnuplot packages. The package is documented in a user's guide and each program also has a man page.
[http://www.atmos.ucla.edu/tcd/ssa/]
ssh: 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 compatibility; and

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.
[http://www.ssh.org/]
[http://www.onsight.com/faq/ssh/ssh-faq.html]
[http://www.tac.nyc.ny.us/~kim/ssh/]

fsh

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.
[ftp://ftp.lysator.liu.se/pub/unix/fsh/]

lsh

A C implementation of the ssh version 2 protocol available under the GPL.
[http://www.lysator.liu.se/~nisse/archive/]
[http://www.net.lut.ac.uk/psst/]

MindTerm

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:

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.

Other features include:

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 SSH servers;

automatic storage of settings on a per-host basis; and

listing of all currently open connections through the tunnels.

[http://www.mindbright.se/mindterm/]

OpenSSH

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 PK encryption;

PAM support;

support for IPv6; and

better pseudo-random number generation than SSH1.

[http://www.openssh.com/]

OSSH

An open source version of SSH. This is basically SSH1 v1.2.12 (the last version without increased restrictions) with bug fixes.
[ftp://ftp.sunet.se/pub/unix/admin/mirror-pdc/ossh/]
SSL: 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 data encryption. 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.

OpenSSL

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.
[http://www.openssl.org/]

pyCA

A set of Python scripts for setting up and maintaining a certification authority using OpenSSL. The functionality of pyCA includes:

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 config file.

This requires Python 1.5.1 or greater and OpenSSL.
[http://sites.inka.de/ms/python/pyca/]

SSLeay

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 several formats;

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 a certificate;

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 requests;

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.
[http://www.psy.uq.edu.au:8080/~ftp/Crypto/]
[http://drachma.varner.com/~mpearce/ssl.html]
[ftp://ftp.psy.uq.oz.au/pub/Crypto/SSL/]

mxCrypto

A Python wrapper for the SSLeay library.
[http://www.lemburg.com/files/python/mxCrypto.html]

stunnel

A program designed to function as an SSL encryption wrapper between remote clients and local or remote servers. 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 support; and

a session cache based on threads.

[http://www.stunnel.org/]
SSORT: 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.
[http://sunsite.doc.ic.ac.uk/public/computing/general/statlib/cmlib/]
SSRFPACK: 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).
[http://www.acm.org/calgo/contents/]
[http://www.netlib.org/toms/index.html]
ssyslog: 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 auditor noticing. A source code distribution has been placed in the public domain.
[http://www.core-sdi.com/english/slogging/ssyslog.html]
Ssystem: 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 OpenGL clone.
[http://www1.las.es/~amil/ssystem/]
StackGuard: 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 active. 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 2.7.2.3. It is available as a patch as well as in the form of an installable or source RPM or the complete patched source code. 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.
[http://www.cse.ogi.edu/DISC/projects/immunix/StackGuard/]
StackThreads: A library supporting fine-grain multithreading in GCC/G++. 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 threading.
[http://www.yl.is.s.u-tokyo.ac.jp/sthreads/]
Stalin: 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 execution. 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 Scheme-to-C. It is documented in a long README file included in the distribution.
[http://www.neci.nj.nec.com/homepages/qobi/software.html]
STAN: 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 of types;

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:

TIM, a Type Inference Module which implements the type and state invariant inference techniques; and

STAN, which implements the remainder of the techniques.

The programs are available in binary form for Linux Intel systems.
[http://www.dur.ac.uk/~dcs0www/research/stanstuff/stanpage.html]
Standard ML: One of the ML family of languages. One implementation is SML/NJ.
[http://foxnet.cs.cmu.edu/sml.html]
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 CWEB.
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.
[ftp://labrea.stanford.edu/pub/sgb/]
[http://tug2.cs.umb.edu/ctan/tex-archive/support/graphbase/]
STAPLOT: 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 attribute;

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.

[ftp://gyre.umeoce.maine.edu/pub/staintro.html]
star: 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 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 source code distribution of star is available. It is written in C and can be compiled on most UNIX platforms.
[ftp://ftp.fokus.gmd.de/pub/unix/star/]
StarFLIP++: 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 classification. 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 including:

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.
[http://www.dbai.tuwien.ac.at/proj/StarFLIP/]
Starlab: 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 N-body framework.

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.
[http://www.sns.ias.edu/~starlab/starlab.html]
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:

CCDPACK, for processing and reducing CCD-like data;

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 manipulation;

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 elliptical apertures;

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 program;

SPECDRE, a package for spectroscopy data reduction; and

TSP, for handling time series and polarimetric data.

Most of these applications can be used either from a UNIX shell or within the Starlink ICL (Interactive Command Language).
[http://star-www.rl.ac.uk/]
STARPAC: 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.
[http://www.scd.ucar.edu/softlib/STARPAC.html]
StarSplatter: 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 TIPSY package.
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.
[http://www.psc.edu/Packages/StarSplatter_Home/]
StarTeX: 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.
[http://tug2.cs.umb.edu/ctan/tex-archive/macros/startex/]
statalign: 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.
[ftp://ftp.bio.indiana.edu/molbio/evolve/]
Statbox: 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 squares;

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 likelihood;

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 distribution functions;

randbin, randgamm and randpois, for random deviates from the binomial, gamma and Poisson distributions;

tp and tq, the Student's t distribution function and quantiles;

digamma and trigamma, the digamma and trigamma functions;

gquad and gquad6, for regular and six-point Legendre quadrature;

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.

[http://www.maths.uq.oz.au/~gks/matlab/statbox.html]
statistics: Good places to search for statistical software are the Statistics and Statistical Graphics Resources site, the Guide to Statistical Computing Resources on the Internet, the Statistics on the Web site, and the Statistics Related Links at Duke University. Repositories for statistical software and other resources are Statlib, GASP (Globally Accessible Statistical Procedures), and the Geostatistics Web Site.
Statlib: A repository for many megabytes of various types and sizes of statistical software, data, etc.
[http://lib.stat.cmu.edu/]
Statnet: 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 Ethernet, PLIP, PPP, IPX and Appletalk. 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.
[http://packetstorm.securify.com/UNIX/utilities/]
STATTAB: 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.
[http://lib.stat.cmu.edu/general/Utexas/]
STBasic: 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 distribution.
[http://www.ibiblio.org/pub/Linux/devel/lang/basic/]
SteelBlue: 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 is executed;

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.

[http://www.steelblue.com/]
StegFS: 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 GPL.
[http://ban.joh.cam.ac.uk/~adm36/StegFS/]
Stella: 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.
[http://www4.ncsu.edu:8030/~bwmott/2600/]
STERIC: 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 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 ligand;

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.

The radial profiles of all these parameters can also be calculated. The free space effect calculations available include:

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 compliant platforms. Graphics capabilities are handled externally via the Gnuplot package.
[http://www.ccl.net/cca/software/SOURCES/C/steric/]
[ftp://hobbes.gh.wits.ac.za/pub/steric/]
s3: 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.
[http://gumby.syr.edu/]
STIL: 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.
[ftp://ftp.th-darmstadt.de/pub/text/sgml/stil/]
STk: 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 Protocol;

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.
[http://kaolin.unice.fr/]
STK: 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 streaming devices;

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.
[http://ccrma-www.stanford.edu/CCRMA/Software/STK/]
STL: 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 algorithms;

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 manipulate iterators;

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 functions;

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). See Ammerall and Ammeraal (1997), Austern (1998), Breymann (2000), Glass and Schuchert (1996), Ladd (1996), Musser et al. (1996), Nelson (1995), Plauger et al. (1998), Robson (1998) and Schildt and Schildt (1999).
Useful STL-related links include:

STL Newbie Guide
[http://www.xraylith.wisc.edu/~khan/software/stl/STL.newbie.html]

STL FAQ
[ftp://butler.hpl.hp.com/stl/stl.faq]

STL Programmer's Guide
[http://www.sgi.com/Technology/STL/]

STL Tutorial
[http://www.infosys.tuwien.ac.at/Research/Component/tutorial/prwmain.htm]

Introduction to STL
[http://www.linuxgazette.com/issue34/field.html]

G++ FAQ
[http://egcs.cygnus.com/onlinedocs/g++FAQ_toc.html]

STLport

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 egcs. Documentation can be found on the site.
[http://www.stlport.org/]
STonX: An Atari ST emulator for UNIX/X11 platforms. The features include:

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.

A source code distribution is available.
[http://www.complang.tuwien.ac.at/nino/stonx.html]
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 their ratings.
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.
[http://www.cs.sunysb.edu/~algorith/]
Stow: 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.
[http://www.gnu.org/software/stow/stow.html]
Strata: 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 clastic simulations. 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 flow groups. The details of the parameters within each group include:

measures - for setting total width, spatial divisions, total time, temporal divisions, and timelines for saving the simulation state at regular intervals;

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 of detail;

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 technical publications.
[http://hydro.geosc.psu.edu/Sed_html/ strata_front_page.html]
Streamer: 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.
[http://stratus.ssec.wisc.edu/streamer/streamer.html]
STRIP: 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 here.
[http://mosquitonet.stanford.edu/software/strip.html]
STRIPACK: 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 or deletions. This is TOMS algorithm 772 and is documented in Renka (1997a).
[http://www.acm.org/calgo/contents/]
STRIPE: A tool that converts a polygonal model into triangle strips to speed up rendering time.
[http://www.cs.sunysb.edu/~stripe/]
Strn: Scan trn is a news reader based on trn. It contains all of the features of trn and adds several capabilities including: a newsgroup browser, virtual newsgroups, scoring/rating of articles, and easy configuration menus.
[ftp://ftp.uu.net/.vol/10/news/readers/trn/strn/]
Strudel: 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:

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.

Source and Linux binary distributions of Strudel are available.
[http://www.research.att.com/sw/tools/strudel/]
STSDAS: A system for reducing and analyzing data from the Hubble Space Telescope. This runs in and requires the IRAF environment.
[http://ra.stsci.edu/]
Studio: 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.
[http://studio.sourceforge.net/studio.shtml]
SU: 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:

cwp, a library of scientific routines (e.g. FFT routines) written in C as well as utility programs and shells;

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 structure.

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.
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.
[http://timna.Mines.EDU/cwpcodes/]
SubArctic: 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.
[http://www.cc.gatech.edu/gvu/ui/sub_arctic/]
SUBDUE: 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.
[http://cygnus.uta.edu/subdue/]
sudo: 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 shell. The features include:

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 basis.

A source code distribution of sudo is available. See also the related runas.
[http://www.courtesan.com/courtesan/products/sudo/]
SUDSODS: A set of Fortran 77 routines for the solution of overdetermined and underdetermined systems of linear algebraic equations. The SODS routine solves an overdetermined system of linear equations AX=B where A is M by N with M $\ge$ N. 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 M $\le$ N. 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.
[http://sunsite.doc.ic.ac.uk/public/computing/general/statlib/cmlib/]
SUGAL: 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.
[http://www.trajan-software.demon.co.uk/sugal.htm]
sula: This IRC client has been superseded by SPX.
SUMMA: 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.
[http://www.cs.utexas.edu/users/rvdg/software.html]
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 triangulation. It is available in binary format for several platforms including Linux Intel by contacting the author at an address given at the site.
[http://www.dlc.fi/~dkpa/]
Superficie: A program for visualizing and interacting with 3-D surfaces. Interaction capabilities include rotation, zooming and panning, and illumination.
[http://superficie.sourceforge.net/]
SuperLU: 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 backward stability;

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.
[http://www.nersc.gov/~xiaoye/SuperLU/]
[ftp://ftp.cs.berkeley.edu/pub/lapack/SuperLU]
[http://HTTP.CS.Berkeley.EDU/~xiaoye/superlu.html]
SUPERSNAP: 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.
[http://acoustics.mit.edu/arctic0/henrik/www/snap.html]
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).
[http://www.geom.umn.edu/software/evolver/]
SurfIt: This has been renamed Plume.
SUSAN: 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 other algorithms. 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 neighborhood.
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.
[http://www.fmrib.ox.ac.uk/~steve/susan/]
Sutra: A collection of visualization programs built on top of the Karma package.
The programs include:

xray and krot for the volume rendering of data cubes;

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 tabular data;

cube2mpeg for compressing movies to MPEG format;

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 PostScript format. It appears that this is slowly being absorbed into the Karma package.
[http://www.atnf.csiro.au/computing/software/visualisation/]
SUTRA: 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 convection systems.
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 available. The primary documentation is contained within Voss (1984). This is part of the USGS Water Resources Applications Software collection.
[http://water.usgs.gov/software/sutra.html]
[http://www.geogr.uni-jena.de/software/sutra.html]
SVDPACK: 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).
[http://www.netlib.org/svdpack/index.html]
SVG: 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 of SVG.

[http://www.w3.org/TR/WD-SVGReq]

svgv

The SVG Viewer is a viewer for 2-D graphics files in SVG format. This is implemented as a set of Java libraries. It requires JDK 1.2 and the Java Project X Core Library. It is freely available under a license based on the BSD license.
[http://sis.cmis.csiro.au/svg/]
SVGAGUI: 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.
[http://www-jcr.lmh.ox.ac.uk/pub/linux/toolkits/svgagui/]
SVGALIB: 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.
[http://www.svgalib.org/]
[http://www.cs.bgu.ac.il/~zivav/svgalib/]
SVGATextMode: 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.
[http://sunsite.unc.edu/pub/Linux/utils/console/]
SVM: The Support Vector Machines Matlab toolbox implements a set of statistical learning methods. Documentation is contained within a technical report available in PostScript format.
[http://www.isis.ecs.soton.ac.uk/resources/svminfo/]
SVMlib: The Shared Virtual Memory library is an emulation of shared memory in a distributed memory environment. The features of SVMlib include:

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.

In addition to the native SVMlib C++ API it also offers additional APIs for compatibility with other projects including:

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 binary version for Linux platforms is available upon the completion of a registration form.
[http://www.lfbs.rwth-aachen.de/~karsten/projects/SVMlib/index.html]
SVMlight: A implementation of Support Vector Machines in C. SVMs are used in pattern recognition problems such as text classification. 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 representation.
The source code is available as are binaries for Sun SunOS and Solaris and Linux Intel. Documentation is contained within a man page as well as in some technical reports.
[http://ais.gmd.de/~thorsten/svm_light/]
SWANK: 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 interface.
[http://www.nmrview.com/swank/]
Swarm: 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 models.
The Swarm package can be divided into simulation, software support, and model specific libraries. The simulation libraries are further divided into:

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 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.
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 Tcl/Tk software. There is quite of bit of documentation available in PostScript and HTML format.
[http://www.swarm.org/]
Swatch: 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 the log. 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.
[ftp://ftp.stanford.edu/general/security-tools/swatch/]
[ftp://coast.cs.purdue.edu/pub/tools/unix/swatch/]
SWB: See Scientist's Workbench.
Sweep: 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, looped, etc.;

piano-style playback wherein keyboard keys behave like musical keys; and

separate volume levels per view.

[http://sweep.sourceforge.net/]
SWiFT: A software feedback toolkit for building adaptive and predictable systems. 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 implementations. 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.
[http://www.cse.ogi.edu/DSRG/swift/]
SWIG: The Simplified Wrapper and Interface Generator is a tool for scientists and programmers to use to integrate common scripting and interface languages such as Tcl/Tk, Perl, Python and 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.
[http://www.swig.org/]
Swing: 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 components.

[http://web2.java.sun.com/docs/books/tutorial/uiswing/]
SWI-Prolog: 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:

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 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.
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.
[http://www.swi.psy.uva.nl/projects/SWI-Prolog/]
swish: 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.

[http://www.rru.com/~meo/useful/www.html]

SWISH-E

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 first try.
[http://sunsite.berkeley.edu/SWISH-E/]

SWISH++

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:

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 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.
[http://www.best.com/~pjl/software/swish/]
sXid: 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 inodes. 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.
[ftp://marcus.seva.net/pub/sxid/]
SYISDA: 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.
[http://www.mcs.anl.gov/Projects/PRISM]
SYL: 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).
[http://www.acm.org/calgo/contents/]
[http://www.acm.org/toms/V18.html]
[http://www.netlib.org/toms/index.html]
SYLU: 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.
[http://www.dotfunk.com/projects/sylu]
SYMCON: 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 one yet).
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.
[http://elib.zib.de/pub/elib/codelib/symcon/]
Symmetrica: 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 structures including:

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 linear groups;

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 symmetric groups.

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 format.
[http://www.mathe2.uni-bayreuth.de/axel/symneu_engl.html]
SYMMLQ: 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.
[http://www.netlib.org/linalg/]
Sympa: A mailing list manager that automates various functions such as subscription, moderation and management of archives. The features include:

compatibility with most SMTP engines;

multilingual capabilities with English and French currently available;

storage of internal data in a RDBMS (with current support for MySQL);

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.

A source code distribution is available which requires Perl 5.003 or greater.
[http://listes.cru.fr/sympa/]
SYMPHONY: 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 mixed-integer programs. 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 compliant compiler.
[http://www.BranchAndCut.org/SYMPHONY/]
Synctree: 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 images. 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 comes from;

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.

[ftp://ftp.math.lsa.umich.edu/pub/Synctree/]
synpic: 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.
[http://www.pcug.org.au/~millerp/isynpic.html]
SYNTAX: 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:

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.

Distributions are available for several systems including Linux Intel. A user's manual written in French is available in PostScript format.
[http://www-rocq.inria.fr/oscar/www/syntax/syntax-eng.htm]
sysdaemon: A system monitor daemon written in Perl 5. This monitors the components comprising a UNIX server, e.g. sendmail, inetd, named and httpd servers. 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.
[http://www.marketrends.net/sysdaemon/]
SYSLINUX/PXELINUX: 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 Environment) specification.
[http://www.kernel.org/pub/linux/utils/boot/syslinux/]
syslog-ng: 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.
[http://www.balabit.hu/en/products/syslog-ng/]
SYSMAN: A Common Lisp library for remote system and network management based on SNMP. This currently (1/99) supports SNMP version 1, i.e. RFC 1157.
[http://www.switch.ch/misc/leinen/snmp/sysman.html]
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 log files;

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 administration; and

XUser, an interface to the shadow password administration files.
SystemC: 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 include:

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 functionality;

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 abstraction levels;

the available of clocks (as special signals) to timekeeping during simulations;

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 abstraction;

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.
[http://www.systemc.org/]
System16: A emulator of the Sega System16 arcade machines.
[http://electron.et.tudelft.nl/~jdegoede/system16.html]
szip: 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 blocksort. A binary version of szip is available for Linux Intel platforms.
[http://www.compressconsult.com/szip/]

[ home / linux ]

Next: Ta-Tm Up: Linux Software Encyclopedia Previous: Sa-Sm Contents

Manbreaker Crag 2001-03-08