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