Next: Sn-Sz Up: Linux Software Encyclopedia Previous: Rn-Rz Contents

Sa-Sm

Last checked or modified: Jan. 9, 2001

SableCC: An object-oriented framework for generating compilers and interpreters in Java. The framework is based on two key design decisions:

it uses object-oriented techniques to automatically build a strictly-typed abstract syntax tree that matches the grammar of the compiler; and

it generates tree-walker classes using an extended version of the visitor design pattern enabling the implementation of actions on the nodes of the abstract syntax tree using inheritance.

These decisions lead to a shorter development cycle for compiler construction. The features of SableCC include:

Deterministic Finite Automaton (DFA) based lexers with full Unicode support and lexical states;

an Extended Backus-Naur Form grammar syntax;

LALR(1)-based parsers;

automatic generation of strictly-typed abstract syntax trees and tree-walker classes; and

uses collections as defined in the Java 1.2 API.

[http://www.sablecc.org/]
SACLIB: The Symbolic Algebra Computation LIBrary is a library of C programs for performing computer algebra. A file containing information on how to compile this on Linux boxes can be found in the subdirectory ``upload.'' See also the PACLIB software in another directory.
[ftp://ftp.risc.uni-linz.ac.at/pub/saclib/]
SAIF: The Spatial Archive and Interchange Format is a language for modeling geographic data and a vendor-neutral format for archiving and distributing such data. SAIF was developed for sharing spatial and spatiotemporal information and designed to facilitate interoperability, particularly in the context of data exchange. It follows a multiple inheritance, object-oriented paradigm. While SAIF is considered a base standard, another version called SAIFLite has been developed to be a functional standard which provides strong guidance as to how SAIF should be employed.
[http://home.gdbc.gov.bc.ca/fmebc/]

FMEBC

A program that supports the translation/transformation to and from the SAIF/ZIP format. The supported formats include MicroStation Design, ESRI ArcView Shape, ESRI Arc Generate, MOEP binary compressed, MapInfo Data Interchange Format, and tabular data in no special format. Distributions of FMEBC are available for several platforms including Linux Intel.
[http://home.gdbc.gov.bc.ca/fmebc/fmebcintro.htm]

SAIFSuite

A suite of utilities for managing data in SAIF/ZIP files. The utilities in the package include:

a CSN to HTML generator for converting a set of data types specified in SAIF CSN and producing an HTML representation;

an OSN pretty printer that prints the contents of an SAIF/ZIP file in prettyprinted ASCII format;

several functions for reporting on data set statistics;

an inheritance hierarchy viewer which displays the inheritance hierarchy as a directory tree;

feature type validation utilities for checking the syntactic correctness of CSN definitions;

an SAIF data set validator that verifies that the data in OSN conforms to the data model in CSN;

a control file generator which automatically generates a control file based on the contents of a user-provided CSN file; and

a control file validator that verifies that the SAIF portion of a correlation table is consistent with the data models.

Distributions of SAIFSuite are available for several platforms including Linux Intel.
[http://home.gdbc.gov.bc.ca/fmebc/saifintro.htm]
SAINT: The Security Administrator's Integrated Network Tool gathers information about remote hosts and networks by examining various network services. The information gathered includes the presence of various network information services as well as potential security flaws, e.g. incorrectly configured network services, well-known bugs, or bad policy decisions. It either directly reports the data gathered or uses a simple rule-based system to investigate potential security problems.
[http://www.wwdsi.com/saint/]
Sajber Jukebox: An MPEG layer 3 audio player with a graphical user interface. The features of Sajber Jukebox include:

support for MPEG layer3 (as well as 1 and 2);

real-time playing of MPEG files on the Web;

functions including forward, rewind, pause and seek;

a mixer control allowing changes in bass, treble, volume and PCM/DSP;

file, standard database, and HTTP browsers;

selecting from any number of browsers and playing with repeat and random;

high configurability and saving of configurations;

real-time threads allowng real-time scheduling;

a Web bookmark system; and

a progression bar and a timer to keep track of songs.

A source code distribution is available. This is built on top of and requires the Qt library.
[http://kewl.campus.luth.se/~wizball/jukebox/index.html]
SAL: A library providing abstractions of various operating system services for making applications more portable. The System Abstraction Library provides abstractions for multitasking, file I/O and socket I/O for various UNIX versions as Windows 95/98/NT. The multitasking abstractions are provided via conditional inheritance with three different implementations provided:

a portable cooperative multitasking implementation based on the C setjmp/longjmp functions;

an implementation based on POSIX threads; and

one for the Windows family based on the Win32 interface.

The SAL abstractions provided for file I/O include:

a standard set of methods for accessing files;

a mapped on memory file abstraction providing direct access to the file data using the virtual memory mechanism; and

an abstraction of files consisting of several physical segments.

An abstract class socket and several derived classes provide system dependent implementations of socket I/O. A source code distribution of SAL is available.
[http://www.ispras.ru/~knizhnik/]
Salamander: A push-based distribution substrate for Internet applications. Application interfaces written in both C and Java are currently (7/98) available for developers.
[http://www.eecs.umich.edu/~rmalan/salamander/]
Sam: Sam is an interactive multi-file text editor intended for bitmap displays. It was developed chiefly by Rob Pike at Bell Labs as part of the Plan9 project to have no explicit limits and to be efficient. It combines cut-and-paste interactive editing with an unusual command language based on the composition of structural regular expressions which makes complex or repetitive editing tasks easy to specify. Sam can edit uninterpreted ASCII text files but has no facilities for multiple fonts, graphics, or tables. Files are treated as transaction databases which implement changes as atomic update, providing an undo mechanism as changes are unwound. Efficiency is achieved by a collection of caches which minimize both disk traffic and data motion.
Sam comprises two programs: sam, which does the command processing and file manipulation; and samterm, which controls the display and interacts with the user. You can run sam on one machine and samterm on another connected via remote execution. The design reflects the functionality of the Plan 9 environment in which Sam was originally developed. This distribution is a version of Sam modified to work in the UNIX environment rather than in Plan 9.
The Sam editor is available in a source code distribution. It is written in ANSI/POSIX-compatible C and requires a compiler which meets those standards. The makefile in this distribution has been slightly modified for compilation on Linux platforms with gcc. The documentation includes a couple of papers describing the original Plan 9 implementation along with several man pages with some updated information about the X11 implementation.
[http://www.ibiblio.org/pub/Linux/apps/editors/X/]
[http://hawkwind.utcs.utoronto.ca:8001/mlists/sam.html]
[http://www.cs.bell-labs.com/sys/doc/]
Samba: A suite of programs which work together to allow Windows 95/NT clients to access a UNIX filespace and printers via a protocol called the SMB (Session Message Block) protocol. The pragmatic upshot is that it allows you to redirect disks and printers to UNIX disks and printers from clients running LAN Manager, Windows for Workgroups, Windows NT and OS/2. A UNIX client program is also supplied that allows UNIX users to use an FTP-like interface to access filespace and printers on other SMB servers.
The components of the Samba program suite include:

smbd, the SMB server that handles actual connections from clients;

nmbd, the Netbios server that helps clients locate servers;

smbclient, the UNIX-hosted client program;

smbrun, a program to help the server run external programs;

testprns, a program to test server access to printers;

testparms, a program to test the configuration file for correctness;

smb.conf, the configuration file; and

smbprint, a sample script showing how to allow a UNIX host to use smbclient to print to an SMB server.

Samba is available only as source code from the given home site (although binaries may be available elsewhere for some platforms, especially Linux). It has been run successfully on many platforms, including SunOS, Linux, SOLARIS, SVR4, Ultrix, OSF1, AIX, BSDI, NetBSD, etc. See the site for many others. The documentation includes man pages for all of the programs, a FAQ, and some Linux HOWO pages on how to set up a Samba Server. There is also a newsgroup called comp.protocols.smb and a couple of mailing lists devoted to discussion of Samba-related matters (with archives of the latter available at the home site). See Eckstein et al. (1999).
[http://samba.anu.edu.au/samba/]

LinNeighborhood

A clone of Microsoft's Network Neighborhood built using GTK+. It runs on top of Samba utilities and smbfs, and can be used to browse an SMB (CIFS) network consisting of Samba, Windows, OS/2, LanManager for DOS, etc. It also has an interface for mounting the found shares.
[http://www.bnro.de/~schmidjo/]

sambaconfig

A tool for reading and changing the smb.conf file in the Samba package via a Web browser. The features include:

grouping shares in different types;

copying, renaming and deleting shares;

adding and removing options from shares; and

changing option values.

[http://www.geocities.com/grymse/sambaconfig/]
SAML: The Simple Algebraic Math Library is a C library for symbolic calculations along with some application programs. It provides an object oriented framework for defining and handling mathematical types and implements the most common data types in computer algebra, e.g. integers, reals, fractions, complex numbers, polynomials, tensors, matrices, etc. The application programs are an interactive symbolic calculator (samuel), a programming language (induce), and a program to factorize integers. A set of Python bindings is included in the distribution. This should compile on any UNIX system with GCC 2.5.0 or later, gdbm, Perl and gmake.
[http://topo.math.u-psud.fr/~bousch/saml-eng.html]
SampLin: Scientific data acquisition, visualization and process control software for Linux and other UNIX platforms. This was originally developed for controlling mass and optical spectrometers but later expanded into a more universal version. The features of SampLin include:

a simple BASIC-like scripting language including widget creation commands;

local or network data acquisition via the RPC protocol;

support for GPIB, SERIAL or generic devices;

a multiple dataseries plotting widget which can export in text and PostScript formats;

a driver for Advantech PCL-818 labcards; and

a driver for Advantech PCL-727 12-channel D/A cards.

A source code distribution of SampLin is available. Installation requires Qt, KDE and the GPIB library.
[http://www.troja.mff.cuni.cz/~kvasnica/samplin.html]
SandiaXTP: A reference implementation of the Xpress Transport Protocol or XTP being developed for the purposes of interoperability testing and protocol procedure analysis. SandiaXTP is implemented with object-oriented techniques, includes full source code, is built on a reusable set of common transport base classes (i.e. MTL), and runs as a user-space daemon.
Sandia is developing this as an alternative to current network technology, which is insufficient for the needs of coupling a large number of processors in a computing cluster. XTP is the current best candidate for optimizing the entire cluster computing stack from wire to protocols to clustering environments to end application since it is easily configured, paradigm independent, and not tied to any single data delivery service. The goal is to have an XTP implementation adaptable over several delivery services including IP, FDDI, Ethernet, ATM, the XUNET gigabit testbed, an emerging LAN interconnections like the Scalable Coherent Interface (SCI) and Myrinet.
A source code distribution of SandiaXTP is available. It can be compiled and used on any compiler/OS compiler on which MTL will work, including Linux Intel systems. A user's guide is included in PostScript format.
[http://www.ca.sandia.gov/xtp/SandiaXTP/]
SANE: Scanner Access Now Easy is a universal scanner interface, i.e. an application programming interface (API) that provides standardized access to any raster image scanner hardware. It allows writing just one driver for each scanner device instead of one drive for each scanner and application. SANE is primarily targeted at UNIX environments, although the standard has been carefully designed to make it possible to implement the API on virtually any hardware or operating system.
The SANE package includes several applications or front-ends:

scan, a simple and versatile command-line interface for acquiring images;

xscan, a graphical interface for acquiring images which is based on GIMP (and can be used either in standalone mode or as a GIMP extension);

xcam, a GTK-based graphical interface for cameras which acquires images continuously; and

saned, the SANE network daemon which can procide network-transparent access to image acquisition devices.

The drivers currently (4/97) included in the distribution are:

hp for HP ScanJet scanners;

mustek for Mustek flatbed scanners;

net, the client side of SANE network support which allows applications to connect to saned daemons running on other hosts;

pint, which provides access to PINT, a kernel driver interface for NetBSD and OpenBSD;

pnm, a pseudo-driver which reads PNM files;

qcam, a driver for Connectix QuickCams; and

umax, a driver for UMAX flatbed scanners.

The SANE source code is available and has been built on Linux (Intel and Alpha) and NetBSD platforms and should be easily portable to other generic UNIX platforms. The SANE standard document is available in several formats, including PostScript. There is also a majordomo mailing list for the purpose of discussing the SANE standard and its implementations. An introduction to SANE can be found in the March 1998 issue of the Linux Journal.
[http://www.mostang.com/sane/]

sanecgi

A Web browser based interface to all scanners compatible with the SANE scanning library. This also requires Perl 5.004 or higher and some other packages.
[http://www.boutell.com:80/sanecgi/]

XSane

A GUI front-end for SANE whose features include:

scanning, photocopying and faxing functionality;

sending scanned images directly to the GIMP as a plug-in;

support for Automatic Document Feeder and multiple image scans;

several 8- and 16-bit output formats;

automatic increase of filename counter;

changes in color enhancement are updated in a preview window without requiring a new preview scan;

color enhancement for scanners/backends that don't support custom gamma;

an autoenhancement function that computes values for gamma, contrast and brightness; and

zoomable previews.

A source code distribution is available.
[http://www.wolfsburg.de/~rauch/sane/sane-xsane.html]
SANTK: The Storage Area Network configuration ToolKit is a toolkit for designing and developing storage area networks (SAN). The user supplies SANTK with inputs such as the number of servers and storage units and mesh characteristics, with which it creates a suggested design for an SAN. The output information includes the number and size of switches, the architecture, and the number of open ports. The SANTK is written in and requires Java 1.3.
[http://www.borg.umn.edu/fc/SANTK/]
SAOimage: A Starlink Project application which is an astronomical image display program for computers with X Window displays. It provides a large selection of image display and manipulation options including scaling, zooming, panning, false color palettes, pixel examination, display blinking, and region specification. The images can be viewed interactively as well as printed to a file in PostScript format. Image files in several formats can be read directly or passed through a named pipe, and image mosaics can be constructed via the use of STSDAS.
The image manipulation and viewing features of SAOimage include:

scaling between limits;

magnifying, zooming, and panning around the image;

performing histogram equalization;

displaying using log and square root scaling;

using false color with built-in or user-specified color tables;

stretching the constrast;

changing the gamma parameter to give nonlinear contrast;

typing text onto an image;

blinking between several images;

flagging specific regions for special processing needs;

tracking pixel coordinates under the mouse; and

displaying IRAF images.

A binary distribution of SAOimage is available for DEC OSF/1, Linux Intel, and Sun Solaris platforms. The program is documented in a user's manual available in PostScript format.
[http://tdc-www.harvard.edu/software/saoimage.html]
saolc: The Structured Audio Orchestra Language is a feature of MPEG-4 which allows you to describe sound using a high-level, sophisticated synthesis language. The synthetic music and sound effects produced with this method are completely device independent. The saolc software creates sound files from input text files written in SAOL.
[http://sound.media.mit.edu/~eds/mpeg4]
SAORD: The SAO R&D software tree contains the sources and auxiliary files for software developed by the SAO software R&D group. It includes the ASSIST graphical user interface (GUI), the SAOtng image display program, and the X Public Access mechanism (XPA).
ASSIST is a graphical user interface to IRAF and other analysis environments under the X Window system. It provides a convenient way to traverse the IRAF package hierarchy and load selected packages, find and access tasks in the IRAF hierarchy using keyword searches, access often-used tasks directly, run tasks, inspect and change task parameters, view task and package help files, try out recipes and tutorials, use a common GUI for IRAF and non-IRAF tasks, and submit comments, questions and bug reports. The most recent release adds support for WWW documents and more generalized support for arbitrary analysis programs and systems, so its use isn't limited to IRAF.
SAOtng, or SAOimage: The Next Generation, is an enhanced version of the SAOimage display program. It supports direct display of IRAF images and FITS images an can easily support other formats. It also has multiple frame buffers, region and cursor manipulation, several scale algorithms, many colormaps, and can easily communicate with external analysis tasks. It is highly configurable and extensible and as such can be modified or extended for almost any sort of task involving image displays. The XPA mechanism is used by both ASSIST and SAOtng to allow external processes to control their functions.
The SAORD package was developed and tested on Sun workstations and ports have been performed for SGI, HP and Alpha platforms. To build and use this software you must be running at least X11R5 and have both the Athena widget set (Xaw) and imake installed on your system, so it doesn't sound like too onerous a task to port it to Linux platforms. The available documentation consists of several papers and technical reports on PostScript format.
[http://hea-www.harvard.edu/RD/HomePage.html]
SAPACLISP: A library of Common Lisp functions for performing various spectral analysis computations. It is a companion package for the book ``Spectral Analysis for Physical Applications: Mulitaper and Conventional Univariate Techniques'' by D. B. Percival and A. T. Walden. At present the best available Common Lisp implementation is CMUCL.
[http://lib.stat.cmu.edu/sapaclisp/]
Sapphire: An acoustic compiler which takes a text file written in the Sapphire programming language and converts it into a sound file. Sapphire has a large range of objects from which sound can be built including envelope shapers, filters, oscillators, sample playback modules, and arithmetic operators. These can be wired together into sounds of arbitrary complexity.
A source code distribution of Sapphire is available. It is written in C and can be compiled and used on most UNIX flavors including Linux. It is documented in a user's manual available in several formats including PostScript.
[http://sunsite.unc.edu/pub/Linux/apps/sound/editors/]
SART: A Guile library for ray tracking and high complexity 3-D modeling. SART can be used to create and render very complex images (e.g. 3-D fractals, CSGs and splines), powerful procedural textures, and even to combine rendering techniques (e.g. using Z buffering, ray tracing and radiosity in a single image). A source code distribution is available which requires Guile for installation and use.
[http://petra.zesoi.fer.hr/~silovic/sart/]
sash: The stand-alone shell is designed for assisting in recovery from certain types of system failures, especially those involving missing shared libraries or important executables. Sash can execute external programs like in any other shell, but it also has built-in versions of many standard system commands. These commands include -chattr, -chgrp, -chmod, -chown, -cmp, -cp, -dd, -echo, -ed, -grep, -file, -find, -gunzip, -gzip, -kill, -ln, -ls, -lsattr, -mkdir, -mknod, -more, -mount, -mv, -printenv, -pwd, -rm, -rmdir, -sum, -sync, -tar, -touch, -umount and -where. The programs are similar to the standard programs with similar names although usually simpler and cruder (i.e. without many of the usual options implemented). Each is also prefaced with a dash to distinguish it from the normal system program of the same name.
[http://www.canb.auug.org.au/~dbell/]
SATAN: The Security Administrator Tool for Analyzing Networks is an easy-to-use and useful tool for probing networks for security vulnerabilities. SATAN sequentially scans networks of computers with the severity of the scan capable of being modified. It can recognize well-known security holes and, upon finding any, reports them but does nothing about them. It even reports how various weaknesses can be exploited. It checks for such things as old or bad versions of sendmail, writeable world-exported NFS filesystems, incorrectly configured TFTP, accessible Yellow Pages password files, and rhosts files. You compile it, run it, read the report it generates, and then do something about the security holes it finds.
A source code version of SATAN is available, and it is recommended that it be compiled by each user since there have been several reports of Trojan horses found in precompiled binaries. Various patches are needed to compile SATAN on Linux systems. The appropriate information and files can be found at the Linux SATAN Site at CEBAF amongst other places. The distribution contains documentation for the package and it is also covered in Garfinkel and Spafford (1996). The two URLs given below are of the creators of SATAN.
[http://www.fish.com/satan/]
[http://wzv.win.tue.nl/satan/]
[http://staff.washington.edu/dittrich/misc/satan/]
[http://www.cs.ruu.nl/cert-uu/satan.html]
Satan Paint (spaint): A game developer's paint program and sprite editor. Features include a script language, unlimited image size and number of images, animation, tiling, morphing, antialiasing, blurring, and 8 bit color editing (but it reads 24 bit formats). It reads PXC, BMP, PIC, LBM, SPE and X Window dumps and writes SPE, PCX and BMP formats. Ports are available for DOS, Sun, SGI, AIX, and Linux.
[http://www.ibiblio.org/pub/Linux/apps/graphics/draw/]
[ftp://ftp.cc.gatech.edu/pub/linux/apps/graphics/]
Sather: An object oriented language designed to be simple, efficient, safe, flexible, and non-proprietary. This is intended to be a simpler version of Eiffel designed for numerical applications. A Linux binary of the compiler is available in addition to the complete distribution. You might want to snag the binary instead of compiling it yourself seeing how the latter feat requires some 46 Mb to accomplish. Questions can be asked and information found on the newsgroup comp.lang.sather. See Stoutamire and Kennel (1995).
[http://www.gnu.org/software/sather/]
[http://www.icsi.berkeley.edu/~sather/]
Sather-K: A modern object-oriented imperative programming language. It originates, like its close cousin Sather, with the Eiffel language, although the design objective was to get rid of all unnecessary constructions in Eiffel. It differs from Sather in that the goals included rapid rather than separate compilation, ease of use as a pedagogical platform for teaching imperative and object oriented programming techniques, and use as a research vehicle for understanding library design. A project is currently underway to combine both strains of Sather.
The source code of Sather-K is available as well as binaries for Linux and SunOS platforms (with binaries for MS/DOS, Sun Solaris, SGI, DEC Ultrix, and HP platforms in the works). The documentation is contained within a 40+ page user's guide in PostScript format.
[http://i44s11.info.uni-karlsruhe.de:80/sather/index_engl.html]
SATLIB: A collection of benchmark problems, solvers and tools used for research into propositional satisfiability or SAT. SATLIB was created to provide a uniform test-bed for SAT solvers as well as a site for collecting SAT problem instances, algorithms and empirical characterizations of the performance of the algorithms.
[http://www.intellektik.informatik.tu-darmstadt.de/SATLIB/]
SAVANT: A project to build an extensible, object-oriented intermediate form (IIR) for the hardware description language VHDL. The project has produced a suite of software to analyze VHDL, build the IIR, and output C++ code suitable for execution with the TyVIS VHDL simulation kernel. The SAVANT software components are:

SCRAM, a VHDL analyzer that checks a VHDL description for syntactic and static semantic correctness and store it in the IIR form;

AIRE, an intermediate form standard that includes definitions of two intermediates, a memory resident data structure called IIR, and a machine-independent file data structure called FIR;

the transmute method, i.e. a collection of derived classes that support the rewriting of the IIR into a reduced form via the implementation of a static model reduction algebra;

publisher classes, i.e. a pair of overloaded methods for regenerating VHDL from the internal IIR and producing C++ simulation code to link with TyVIS; and

a library manager that allows the user to create design libraries and help the parser locate design libraries that are referenced in other VHDL descriptions.

A source code distribution of SAVANT is available. It is written in C++ and has been successfuly compiled on several platforms including Linux.
[http://www.ececs.uc.edu/~paw/savant/]
sB_BLAS: A collection of parallel implementations of the level 3 Basic Linear Algebra Subroutines (BLAS). These were all written using the MPI system.
[http://www.cs.utexas.edu/users/rvdg/sw/sB_BLAS/]
ScaLAPACK: The Scalable LAPACK is a collection of software for performing dense and band linear algebra computations on distributed-memory parallel computers. The ScaLAPACK routines are basically LAPACK routines redesigned for distributed memory computers and, like their predecessors, are based on block-partitioned algorithms to minimize the frequency of data movement between the levels of the memory hierarchy. This library is built on PBLAS and BLACS, with all interprocessor communications handled by these packages.
The routines contained in Version 1.6 (11/97) of ScaLAPACK are divided into three categories. The driver and expert driver routines each call one or more of the more basic computational routines. The driver routines include:

psdbsv, which solves a general band system of linear equations AX=B (with no pivoting);

psdtsv, which solves a general tridiagonal system of linear equations AX=B (with no pivoting);

psgbsv, which solves a general banded system of linear equations AX=B;

psgels, which solves overdetermined or underdetermined linear systems involving a matrix of full rank;

psgesv, which solves a general system of linear equations AX=B;

psgesvd, which computes the SVD of a general matrix and optionally computes the left and/or right singular vectors;

pspbsv, which solves a symmetric positive definite banded system of linear equations AX=B;

psposv, which solves a symmetric positive definite system of linear equations AX=B;

psptsv, which solves a symmetric positive definite tridiagonal system of linear equations AX=B; and

pssyev, which computes selected eigenvalues and eigenvectors of a symmetric matrix.

The expert driver routines are:

psgesvx, which solves a general system of linear equations;

psposvx, which solves a symmetric positive definite system of linear equations;

pssyevx, which computes selected eigenvalues and eigenvectors of a symmetric matrix; and

pssygvx, which computes selected eigenvalues and eigenvectors of a real generalized symmetric-definite eigenproblem.

The computational routines in ScaLAPACK include:

psdbtrf, which computes an LU factorization of a general band matrix with no pivoting;

psdbtrs, which solves a general band system of linear equations using the LU factorization computed by psdbtrf;

psdttrf, which computes an LU factorization of a general tridiagonal matrix with no pivoting;

psdttrs, which solves a general tridiagonal system using the LU factorization computed by psdttrf;

psgbtrf, which computes an LU factorization of a general band matrix using partial pivoting with row interchanges;

psbtrs, which solves a general band system using the factorization computed by psgbtrf;

psgebrd, which reduces a general rectangular matrix to a real bidiagonal form by an orthogonal transformation;

psgecon, which estimates the reciprocal of the condition number of a matrix;

psgeequ, which computes row and column scalings to equilibrate a general rectangular matrix and reduce its condition number;

psgehrd, which reduces a general matrix to upper Hessenberg form by an orthogonal similarity transformation;

psgelqf, which computes an LQ factorization of a general rectangular matrix;

psgeqlf, which computes a QL factorization of a general rectangular matrix;

psgeqpf, which computes a QR factorization with column pivoting of a general rectangular matrix;

psgeqrf, which computes a QR factorization of a general rectangular matrix;

psgerfs, which improves the computed solution to a system of linear equations and provides error bounds and backward error estimates for the solutions;

psgerqf, which computes an RQ factorization of a general rectangular matrix;

psgetrf, which computes an LU factorization of a general matrix using partial pivoting with row interchanges;

psgetri, which computes the inverse of a general matrix using the LU factorization computed by psgetrf;

psgetrs, which solves a general system of linear equations using the LU factorization computed by psgetrf;

psggqrf, which computes a generalized QR factorization;

psggrqf, which computes a generalized RQ factorization;

pslahqr, which computes the Schur decomposition and/or eigenvalues of a matrix already in Hessenberg form;

psorglq, which generates all or part of the orthogonal matrix Q from an LQ factorization determined by psgelqf;

psorggl, which generates all or part of the orthogonal matrix Q from a QL factorization determined by psgeqlf;

psorggr, which generates all or part of the orthogonal matrix Q from a QR factorization determined by psgeqrf;

psorgrq, which generates all or part of the orthogonal matrix Q from an RQ factorization determined by psgerqf;

psormbr, which multiplies a general matrix by one of the orthogonal transformation matrices from a reduction to bidiagonal from determined by psgebrd;

psormhr, which multiplies a general matrix by the orthogonal transformation matrix from a reduction to Hessenberg form determined by psgehrd;

psormlq, which multiplies a general matrix by the orthogonal matrix from an LQ factorization determined by psgelqf;

psormql, which multiplies a general matrix by the orthogonal matrix from a QL factorization determined by psgeqlf;

psormqr, which multiplies a general matrix by the orthogonal matrix from a QR factorization determined by psgeqrf;

psormrq, which multiplies a general matrix by the orthogonal matrix from an RQ factorization determined by psgerqf;

psormrz, which multiplies a general matrix by the orthogonal transformation matrix from a reduction to upper triangular form determined by pstzrzf;

psormtr, which multiplies a general matrix by the orthogonal transformation matrix from a reduction to tridiagonal form determined by pssytrd;

pspbtrf, which computes the Cholesky factorization of a symmetric positive definite banded matrix;

pspbtrs, which solves a symmetric positive definite banded system of linear equations using the Cholesky factorization computed by pspbtrf;

pspocon, which estimates the reciprocal of the condition number of a symmetric positive definite distributed matrix;

pspoequ, which computes row and column scalings to equilibrate a symmetric positive definite matrix and reduce its condition number;

psporfs, which improves the computed solution to a symmetric positive definite system of linear equations and provides forward and backward error bounds for the solution;

pspotrf, which computes the Cholesky factorization of a symmetric positive definite matrix;

pspotri, which computes the inverse of a symmetric positive definite matrix using the Cholesky factorization computed by pspotrf;

pspotrs, which solves a symmetric positive definite system of linear equations using the Cholesky factorization computed by pspotrf;

pspttrf, which computes the Cholesky factorization of a symmetric positive definite tridiagonal matrix;

pspttrs, which solves a symmetric positive definite tridiagonal system of linear equations using the Cholesky factorization computed by pspttrf;

psstebz, the computes the eigenvalues of a symmetric tridiagonal matrix by bisection;

psstein, which computes the eigenvectors of a symmetric tridiagonal matrix using inverse iteration;

pssygst, which computes a symmetric-definite generalized eigenproblem to standard form;

pssytrd, which reduces a symmetric matrix to real symmetric tridiagonal form by an orthogonal similarity transformation;

pstrcon, which estimates the reciprocal of the condition number of a triangular matrix;

pstrrfs, which provides error bounds and backward error estimates for the solution to a system of linear equations with a triangular coefficient matrix;

pstrtri, which computes the inverse of a triangular matrix;

pstrtrs, which solves a triangular system of linear equations;

pstzrzf, which reduces an upper trapezoidal matrix to upper triangular form by means of orthogonal transformations.

These routines are single precision real versions of the ScaLAPACK routines. Almost all are also available in double precision real, single precision complex, and double precision complex versions. For example, the first driver psdbsv is called pddbsv in double precision real, pcdbsv in single precision complex, and pzdbsv in double precision complex.
ScaLAPACK is written to be portable across a wide range of distributed-memory environments such as the Cray T3, IBM SP, Intel series, TM CM-5, clusters of workstations, and any system for which PVM or MPI are available. Prebuilt versions are available for several platforms including Linux Intel. Prebuilt versions of the underlying BLACS are also available for Linux Intel and other platforms. Available documentation includes a comprehensive installation guide and a user's guide. The former is available in PostScript format and the latter online in HTML format as well as in a commercially available version. Several technical reports are also available. The ScaLAPACK library is one part of the ScaLAPACK Project. See Blackford et al. (1997).
[http://www.netlib.org/scalapack/scalapack_home.html]
scanallert: A pair of Perl scripts for detecting and serving notification about port scans.
[http://www.xs4all.nl/~rmeijer/afspraak.htm]
scanlogd: A daemon that detects port scans and writes one line per detected scan via the syslog mechanism. The program obtains a raw socket at startup and processes IP packets sent to the system. If a source address sends multiple packets to different ports in a short time the event will be logged (with compile-time defaults being 10 different ports within 3 seconds for a log entry and 5 scans within 20 seconds to stop logging temporarily).
[http://www.openwall.com/scanlogd/]
SCARAB: This is a package to integrate and plot the Lorenz attractor. Several integration methods are included and the program is written in C.
[http://sunsite.unc.edu/pub/Linux/apps/math/]
[ftp://ftp.cc.gatech.edu/pub/linux/apps/math/]
SCATTERLIB: Note: This has disappeared. If anyone knows where it is or what happened then drop me a line. A library of light-scattering codes mostly written in Fortran. The codes include those for scattering from spheres (Mie scattering), coated and concentric multispheres, spheroids, cylinders slabs, and clusters of spheres and spheroids. Methods include the discrete or coupled dipole approximation (DDA or CDA), the method of moments (MoM), T-matrix, the anomalous diffusion approximation (ADT), the high energy approximation (HEA), and surface patch methods. The applications for which the codes are used include atmospheric radiative transfer, phytoplankton, marine optics, flow cytometry, particle sizing, paints, radar backscatter, and more.
[http://atol.ucsd.edu/~pflatau/scatlib/index.html]
SCC: A precompiler which offers extensions for algebraic programming in C. It is intended to be used in conjunction with a standard C compiler to make possible efficient and convenient computations with algebraic objects other than just floating point numbers or integers. The distribution includes the source code, written in C, and a user's manual in Texinfo format.
[ftp://ftp.ma.utexas.edu/pub/maxima/]
SCCS: The Source Code Control System is a package for managing source files originally introduced by AT&T in the System V version of UNIX. It is currently incorporated into the X/Open standard. A GNU clone of SCCS called, predictably enough, CSSC is available. See Bolinger and Bronson (1995) and Silverberg (1992).
sced: A modeling program that makes use of geometric constraints to edit objects in a virtual world. The scenes created can be exported to a variety of rendering programs including POV-Ray. This chief advantage of sced over other modellers is its constraint based editing capabilities, which gives the user greater control over how objects can be manipulated.
The capabilities of sced include:

creating instances of objects;

creating new base objects;

transforming objects to set their size, orientation and location;

setting attributes for objects that control how it appears when rendered;

aliasing objects such that they are exported as something else;

interactively manipulating the view of a scene in all its parameters;

saving and restoring views of the screen;

specifying the camera location;

creating layers of objects and light sources of various types;

previewing a scene via a separate renderer; and

loading files in a simple description language.

The source code for sced is available and should compile and install on any system with X Windows Release 5 or later. The author developes it on a Linux platforms so it's fairly safe to assume that it will compile on those. A few binary versions are also available, one being for Linux with ELF libraries. Documentation is available in both HTML and PostScript format.
[http://www.cs.wisc.edu/~schenney/sced/sced.html]
SCEDA: The SCene EDitor/Animator is an X11-based, constraint-oriented 3-D wireframe modeler. It provides support for splined keyframe animation with animated objects having their position, rotation and scale smoothly interpolated across multiple keyframes using a modified spline function. The capabilities of SCEDA include:

creating and designing single scenes;

cloning or copying single scenes to create multiple scenes;

viewing and editing each keyframe individually;

controlling the number of interpolated frames between each pair;

performing wireframe animations (i.e. previews) from with SCEDA;

exporting scene description files for all frames to a wide array of formats;

saving and loading keyframe sequences to and from files;

cloning or deleting sets of objects within and across keyframes; and

propagating views and attributes of objects across keyframes.

A source code distribution of SCEDA is available.
[http://members.home.net/mbeast1/]
[http://www.cyberus.ca/~denism/sceda/sceda.html]
Scene: A project to implement an LPGL version of a 3-D graphics API using C++ and based on the Open Inventor API. The planned features include:

Open Inventor 2.0 API;

VRML 1.0/2.0 support;

Xt/Motif components; and

GTK+ components.

A source code distribution of the current (8/99) beta release is available.
[http://scene.netpedia.net/]
SCEPTRE: The System for Circuit Evaluation and Prediction of Transient Radiation Effects is a general purpose circuit analysis program which performs AC, DC, and transient analyses on either linear or nonlinear networks. SCEPTRE employs free form input language and state variable methods to simulate problems of interest to electrical engineers. The features include:

flexible nonlinear input wherein circuit elements can be described as constants, tabular data, or arbitrary functions of other network quantities;

flexible modeling capability which allows any device to be modeled to the required degree of accuracy;

state of the art numerical methods that efficiently simulate networks;

storage of model configurations in a model library;

automatic determination of initial conditions;

automation of multiple case reruns based on a single master run;

specification of additional output parameters;

instruction sequencing to minimize computational delays in transient analyses;

adjustablity of the amount of user control of simulations;

extensibility via user-supplied Fortran subroutines; and

use of one code to run a range of analyses on a single circuit.

Graphical output is handled via an interface to Gnuplot.
A source code distribution of SCEPTRE is available. It is written in Fortran and can be compiled with it g77 or fort77. A user's manual is included in PostScript format. See also Bowers and Sedore (1971).
[ftp://novilux.fh-friedberg.de/pub/sceptre/]
S-Check: A tool for assaying and improving the performance of parallel and networked (i.e. PVM-type) programs. It is a highly automated sensitivity analysis tool that extends benchmarking and conventional profiling. It predicts how refinements in parts of programs are going to affect performance by making local changes in code efficiencies and correlating these with overall program performance. This analysis is a sophisticated comparison that catches interactions arising from shared resources or communication links.
A source code distribution is available which can be used on many platforms including networks of workstations running either PVM or MPI. Documentation includes a user's manual and several technical reports.
[http://www.nist.gov/itl/div895/cmr/scheck/]
Schelab: A numerical analysis library for Scheme. Schelab is an object-oriented library based on Meroon-V3 and is intended to become the kernel of a matrix algebra system. It currently (10/98) includes:

a library for garbage collectable memory chunks;

a library of classes for foreign data types from Fortran and C;

a Foreign Function Interface (FFI) for Fortran that needs no glue code;

a set of overloadable mathematical operations;

a partial interface to BLAS;

classes for complex and real matrices as well as simple operations; and

a timing facility.

A source code distribution of Schelab is available. It can run on top of Guile, MzScheme and Gambit. Documentation is available online.
[http://www.arrakis.es/~worm/schelab.html]
Scheme: A high-level language closely related to LISP. It can be more useful than C for some applications and has a few features lacking in C, e.g. automatic memory management, a richer selection of data types, type-safe primitives, etc. Scheme uses a parenthisized-list Polish notation to describe programs and other data, with the syntax providing for great expressive power largely because of its simplicity.
The significant semantic characteristics of the Scheme language include:

the statical scoping of variables wherein each use of a variable is associated with a lexically apparent binding of that variable;

latent types wherein Scheme associates types with values (or objects) rather than with variables;

objects have unlimited extent which means that no object created during a Scheme computation is ever destroyed (although the garbage collector does reclaim the storage occupied by objects when appropriate);

proper tail recursion wherein iterative computation can occur in constant space;

procedures are objects which means that you can create them dynamically, store them in data structures, etc.;

continuations are explicit rather than behind the scenes so you can use them to implement a variety of advanced control constructs; and

arguments are passed by value which means that Scheme evaluates the argument expressions before the procedure gains control whether or not the procedure needs the result of the evaluations.

Several implementations of Scheme (including both interpreters and compilers) are freely available. The implementations available for Linux platforms include:

Bigloo, an interpreter and compiler;

DrScheme, a development environment with project management and debugging tools;

Elk, an interpreter designed as an embeddable extension language subsystem for applications written in C or C++);

Gambit, a high-performance compiler and interpreter with several extensions;

Kali Scheme, a distributed implementation permitting the efficient transmission of higher-order objects

Kawa, a Scheme interpreter written in Java;

LISC, a lightweight Scheme interpreter written in Java;

MIT Scheme, a compiler which can generate fast code;

MzScheme, a extended Scheme interpreter designed to be embedded in applications;

OpenScheme, and interpreter and compiler;

OScheme, an embeddable Scheme interpreter with various extensions;

RScheme, a well-structured implementation with extensions including an object system and threads;

Scheme48, a bytecode interpreter;

Scheme-to-C, a compiler that compiles Scheme to C;

SCM, an interpreter that provides a machine-independent platform for JACAL;

Scsh, a UNIX shell/systems programming environment;

SIOD, a small interpreter with a database and extensions for UNIX and CGI programming;

Stalin, an optimizing compiler;

uts, a Scheme bytcode interpreter; and

VSCM, a portable implementation with several non-standard features.

See the Scheme FAQ. See the Internet Scheme Repository for lots of code and information about Scheme. See Abelson et al. (1996), Dybvig (1987), Friedman (1996a), Friedman (1996b), Grillmeyer (1997), Pearce (1997) and Springer and Friedman (1989).
[http://www.swiss.ai.mit.edu/projects/scheme/]
[http://www.scheme.org/]
[http://www.schemers.org/]
Scheme 48: A byte-code-interpreter Scheme implementation that can be compiled on any system with a C compiler, including a Linux box with GCC.
[ftp://swiss-ftp.ai.mit.edu/pub/s48/]
Scheme-to-C: An R4RS compliant Scheme system centered around a compiler that compiles Scheme to C. Additional features include expansion passing style macros, a foreign function call capability, records, weak pointers, 3 X11 interfaces, and a garbage collector. These features comprise a system that is portable, efficient, and able to build applications that contain a mix of compiled and interpreted Scheme as well as compiled code from C, C++ and other languages. The current release runs on many systems including Linux platforms. The three interfaces include one to Xlib included in the base system, an alternative Xlib interface called SCIX, and an interactive interface called ezd.
[ftp://gatekeeper.dec.com/pub/DEC/Scheme-to-C/]
Schism: A partial evaluator for a pure (i.e. side-effect free) subset of Scheme. The features include:

polyvariant binding-time analysis;

treatment of higher-order functions and partially static data structures;

color-coded binding-time information via Emacs; and

a binding-time inspector.

A source code distribution is available as well as a user's manual in PostScript format.
[http://www.irisa.fr/lande/schism.html]
ScmOS: An object system for Scheme that provides:

classes with multiple inheritance;

generic procedures;

multimethods, i.e. methods that can specialize on one or more arguments;

:before, :after and :around auxiliary methods in addition to primary methods;

call-next-method and next-method? in primary and :around methods; and

standard method combination similar to the default protocol in CLOS.

[http://www.cs.rice.edu/~dorai/scmos.html]
Schwarz-Christoffel Toolbox: A Matlab toolbox containing programs (m-files) for the interactive computation and visualization of Schwarz-Christoffel conformal maps. The Schwarz-Christoffel formula is a recipe for a conformal map from the upper half-plane to th einterior of a polygon in the complex plane. Some maps can be obtained analytically but more often than not the solution of a system of nonlinear equations is required to obtain a map, a solution which can be obtained with this Toolbox. The Toolbox features:

the graphical input of polygons;

the solution of the parameter problem for half-plane, disk, and exterior mapping;

the computation of forward and inverse maps;

the adaptive plotting of images of orthogonal grids; and

both command line and graphical user interfaces.

The Toolbox can be used with Matlab or with the freely available Octave package which can run most Matlab m-files. It is documented in a 16 page user's guide in PostScript format. This is TOMS algorithm 756 and is documented in Driscoll (1996).
[http://www.math.udel.edu/~driscoll/software/]
[ftp://ftp.mathworks.com/pub/contrib/v4/misc/]
scientific graphics: Packages with which scientific graphics can be produced, or at least those designed for such things, include:

ACEgr, an interactive 2-D plotting package with numerous capabilities;

AGL, a library of graphics routines with C and Fortran interfaces;

Aipsview, a tool for visual astronomical data analysis with which images can be viewed and processed and interactive vector plots can be created;

DATAPLOT, a scientific and mathematical computational environment with 2-D plotting capabilities;

DAVID, an interactive visualization environment with, among many other things, 2-D plotting functionality;

DISLIN, a high-level library of functions for graphical data display;

EDGR, an interactive program for creating, editing, printing and storing graphical data;

EPIC, a sytem for the management, display and analysis of oceanographic data;

ESO-MIDAS, an astronomical data analysis system with 2-D plotting functionality;

GLE, a scientific graphics library;

GLI, a complete graphics system for plotting complex data sets and displaying images;

GMT, a collection of over 50 UNIX tools for manipulating and graphing 2-D data;

GMV, a scientific visualization tool for simulation data from structured and unstructured meshes;

Gnuplot, a command-line driven interactive plotting utility;

GrADS, an interactive tool for the display and analysis of Earth science data;

Gri, a language for drawing scientific graphs;

Hvplot, a scientific plotting package for 2-D plots;

LASSPTools, a collection of utilities for analyzing and graphing data;

LinkWinds, a visual data exploration system that can output geophysical data in several formats;

MAPGEN/PLOTGEN, a collection of programs to create maps of data with geographic coordinates;

Mesh-TV, an interactive tool for visualizing and analyzing data on regular meshes;

PGPerl, a Perl interface to PGPLOT;

PGPLOT, a library of Fortran-callable graphing routines;

PHYSICA, a high-level interactive programming environment with graphics capabilities;

Plotmtv, an interactive 2-D plotting program;

PlotPlus, an interactive, command-driven 2-D scientific graphics package;

plotutils, a collection of programs for plotting 2-D scientific data;

PLplot, a library of C functions for creating 2-D scientific graphs;

PONGO, an application for interactively plotting data which uses PGPLOT;

PSPLOT, a library of Fortran-callable routines for generating 2-D PostScript graphs;

ptcl, a package that registers PGPLOT functions as Tcl commands;

PPGPLOT, a Python interface to PGPLOT;

Robot, a plotting and data analysis program;

STAP, an interactive graphics and data analysis program built on top of PGPLOT;

TIPSY, a tool for displaying and analyzing the results of N-body simulations in astronomy;

VCS, a package for the manipulation and display of scientific data;

Vigie, a system for data visualization;

Vis5D, a package for visualizing output from numerical weather models and similar sources;

WIP, an interactive scientific graphics package built on top of PGPLOT;

xdang, a data visualization and viewing package;

XFarbe, a contouring program for isolines;

Xgraphic, an interactive package for drawing graphs;

Xlisp-Stat, an extensible statistical computing environment with graph creation capabilities;

XmdvTool, a package for visually exploring multivariate data;

XploRe, an interactive statistical computing environment with graph creation capabilities; and

YPLOT, a tool for creating 2-D scientific plots.
Scientific Math Library: An extensive collection of predefined C++ classes and routines covering a wide array of the most widely used mathematical applications. The functions include everything from complex variable analysis to matrix and vector algebra. A source code distribution is available that can be compiled on most platforms including UNIX platforms with G++.
[http://www.pa.msu.edu:80/~volya/cpp/cpp.html]
Scientist's Workbench (SWB): A package whose main functions are to bring together the tools and software required by scientific researchers in a distributed computing environment, to provide a graphical interface to access those tools, and to provide the software necessary to allow researchers to easily build their own graphical interfaces.
The SWB consists of several software components: the X Integrator, the executable widgets, and the global variable manager. The X Integrator (xi) is a standalone pulldown menu program launcher (an X client application) that serves as the SWB presentation layer. Distributed command execution is provided as an integral function in addition to the usual local command execution. It is driven by a user-configurable input file that describes menu layout, defaults, selection titles, and applications to be launched. The executable widgets are a collection of small X clients (C programs) which provide graphical interfaces to common tasks such as displaying and responding to a prompt or specifying a file name. These may be invoked from the command line or in shell shell scripts, enabling users to easily replace text-based interfaces with graphical interfaces. The global variable manager is a UNIX shell script which provides global data sharing between processes both locally and remotely.
The source code for the SWB package is available and requires a UNIX/X11 platform with the Motif library for installation. Documentation for SWB is contained in the distribution package.
[ftp://ftp.tc.cornell.edu/pub/swb/]
Scilab: An interactive scientific software package which, although designed for system control and signal processing applications, is powerful and flexible enough for most general scientific and technical applications. The goals of the Scilab project are to provide a computing environment where data types are varied and flexible, the syntax is natural and easy to use, a reasonable set of primitives are provided to serve as the basis for a wide variety of calculations, an open programming environment allows new primitives to be easily added, and where specialty library development is supported.
Scilab is composed of three distinct parts: an interpreter, libraries of functions (called Scilab procedures), and libraries of Fortran and C routines. The routine libraries are mostly independently created packages available via Netlib and similar repositories which have been slightly modified for compatibility with the interpreter. The Scilab interpreter features a Matlab-like syntax superset which allows it to succinctly and symbolically represent complicated mathematical objects such as transfer functions, linear systems, graphs, polynomials, and polynomial matrices in addition to the usual numerical matrices. There are a variety of powerful primitives available for the analysis of nonlinear systems which allow the explicit and implicit numerical integration of dynamic systems. There are also facilities for nonlinear, quadratic, and linear optimization.
The Scilab programming environment is flexible and extensible in that the creation of functions or function libraries is a well-defined and straightforward procedure in which functions are recognized as data objects and can be manipulated and created just like other types of data objects, e.g. functions can be defined and passed as input or output arguments of other functions. Additionally, a character string data type allows the on-line creation of functions. An easy-to-use interface to Fortran and C subprograms allows libraries of routines previously developed to be used, and a compiler is provided that can transform many Scilab functions into Fortran subroutines (which make use of the supplied Fortran libraries).
Various collections of functions called toolboxes have been developed in the Scilab environment. The Scicos toolbox is a package for the modeling and simulation of dynamical systems based on a general formalism which includes both continuous and discrete systems. It includes a graphical editor which can be used to build complex models by interconnecting blocks representing either predefined or user-defined functions. The LMITOOL package is a tool for solving the linear matrix inequality (LMI) problems which often arise in systems and control. Metanet is a toolbox for computations with graphs and networks. It can handle directed and undirected multigraphs with loops and includes a graphical window in which the graphics can be displayed and modified. The available functions include graph manipulations and transformations as well as graph, network, and miscellaneous computations. GeCI is a communications toolbox which allows the remote execution of programs as well as exchanges of messages between those programs. It enables groups of machines to be combined into a virtual computer across a network. A signal processing toolbox includes many functions for various signal processing tasks including frequency response, sampling, decimation and interpolation, DFTs and FFTs, convolution, the chirp transform, FIR and IIR filters, spectral estimation, filtering and smoothing, optimization in filter design, stochastic realizations, and time-frequency signal analysis.
The source code for Scilab is available along with binaries for Linux, DEC Alpha, HP 9000, IBM RS600, SGI, and Sun platforms. The available documentation (in PostScript format) is extensive and includes an introduction and tutorial, a huge reference manual, an internals manual for developers, and manuals for each of the toolboxes. These are all available in PostScript format (which you may want to modify with psutils since it is in A4 page format).
[http://www-rocq.inria.fr/scilab/]
Scintilla: A source code editing component built using Python that can be used on both UNIX/X11 and Win32 platforms. Scintilla contains the basic features found in standard text editing components as well as additional features useful for editing and debugging source code. These include:

syntax styling;

error indicators;

code completion; and

call tips.

This was originally developed, strangely enough, because of annoyances with the available Python editor on Win32.
[http://www.scintilla.org/]
Scion: The Statistics Collection In Operational Networks software is a package for collecting SNMP data in an organized manner and producing useful statistics from that data. The data can be viewed graphically via a Web interface to the package.
The Scion package consists of several programs including:

scollect, which gathers data from the nodes specified in configuration files and stores it in an rtdata (i.e. real time data) tree;

scook, which processes the raw data collected by

scollect into values which can be graphically displayed;

scserver, an OpStats server which attempts to be compatible with RFC-1856; and

sclient, a graphical, Web-based interface which displays the statistics in a useful format.

The Scion package is available as source code or in binary format for Sun SunOS and Solaris, BSDi, IBM AIX, Windows NT, and Linux Intel platforms. The source is written in C can be fairly easily ported to other generic UNIX platforms. The programs that comprise the package are documented in man pages.
[http://www.merit.edu/~netscarf/]
SciPlot: An Xt widget to display 2-D data in a graph intended to display scientific data. It can format the data in polar or cartesian coordinates, with linear and log axes available for cartesian plots. The features include automatic scaling, legend drawing, noncontinuous (i.e. broken) line segments, real time updates, axis labeling, PostScript output, multiple plot lines, color support, user font specification, dashed lines, symbols drawn at points, and degrees or radians as angles in polar plots.
A source code distribution of SciPlot is available. It is written in ANSI C and requires X11R5 or later. It is subclassed from the Xt Core widget class and thus doesn't depend on any other widget set, although it can be used with many other widget sets.
[http://www.akvo.com/robm/software/unsupported/]
SCIPORT: A portable Fortran emulation of the SCILIB library created by Cray for use with its supercomputers. This package contains single and double precision files, files for testing, and a man page describing the library contents. The library consists of files containing groups of related routines: a version of the BLAS routines, searching and ordering programs, linear recurrence programs, matrix utilities, FFT programs, filter programs, gather/scatter programs, a version of LINPACK, and a version of EISPACK.
[http://www.netlib.org/scilib/index.html]
SciTE: The Scintilla-based Text Editor is a text editor built on top of Scintilla. Both are intended to be useful for building and testing source code on Win32 and X11 platforms.
[http://www.scintilla.org/SciTE.html]
SciTeXt: A word processor for systems with a Java interpreter. It functions as a normal word processor and also has special functions and tools for scientific work, e.g. the creation of TeX source output. No versions of the Java version of this have been released as of 9/97.
[http://www.uni-paderborn.de/~SciTeXt/]
SCL: The NIST STEP Class Library is a set of C++ class libraries capable of representing information conforming to the EXPRESS data specification. STEP is a project to develop a standard for representing product information in a common computer-interoperable format, with the information encompassing all parts of the life cycle including design, manufacture, use, maintenance, and disposal. EXPRESS is the language in which this information is to be represented.
The SCL components include:

fedex_plus, for parsing an EXPRESS file and generating a C++ class library representation based on the STEP Data Access Interface (SDAI) C++ language binding;

fedex_idl, for translating EXPRESS into IDL based on the SDAI IDL language binding;

fedex_os, for parsing an EXPRESS file and generating the C++ code needed to add persistence to the classes output from fedex_plus;

mkProbe, generates a Data Probe editor/schema browser from an EXPRESS file;

the STEP core library providing STEP-related functionality including early- and late-bound attribute access, reading/writing of STEP Part 21 files, implementations of EXPRESS base types, etc.;

a data acces interface library providing a partial implementation of the SDAI Session Schema;

an editor library implementing the functionality associated with an editor for instances of entities defined in EXPRESS;

a utils library providing generic C++ functionality;

an ivfasd library providing general purpose InterViews user interface objects;

a probe-ui library providing InterViews user interface objects for implementing an EXPRESS editor;

fedex, a syntax and semantic checker for EXPRESS; and

exppp, a pretty printer for formatting EXPRESS documents.

Source code distributions of the SCL are available upon completion of an online request form. Documentation includes several technical reports available in PostScript format.
[http://www.mel.nist.gov/msidstaff/sauder/SCL.htm]
SCM: A Scheme interpreter written in C.
[http://ftp-swiss.ai.mit.edu/~jaffer/SCM.html]
SCMS: The SMILE Cluster Management System is an extensible management tool for Beowulf clusters. It provides a large set of tools that allow sysadmins to monitor, submit commands, query system status and maintain system configuration. The system management utilities include those for:

showing the status of nodes;

accessing any node control panel;

showing the disk space of nodes;

FTP and Telnet to nodes;

showing the filesystems of nodes;

showing the process status of nodes;

rebooting nodes;

centralizing package management;

shutting down nodes;

checking users on nodes; and

showing the status of the motherboards on nodes.

Several parallel UNIX commands are also available for performing various tasks:

pcat, for concatenating or viewing files;

pcp, for distributing files to nodes;

pexec, for executing commands on nodes;

pfind, for finding files on nodes;

plps, for finding processes using the process name;

pkill and pkillu, for killing processes by name and user name;

pls, for listing files in clusters;

pload, for reporting loads in clusters;

pmv, for moving files;

ppred, for executing commands on multiple nodes;

pps, for displaying process information on all nodes;

prm, for removing file(s) on cluster nodes; and

ptest, for testing conditions on multiple nodes.

[http://smile.cpe.ku.ac.th/research/]
SCNN: The Simulating system for Cellular Neural Networks is a universal simulating system for analog processing neural networks with regular and local interconnections. CNN are governed by sets of nonlinear ordinary differential equations and realized as VLSI chips which operate at very high speeds. The features of SCNN include:

arbitrary numbers of layers and grid sizes;

discrete time stepping;

several calculating methods including Euler's method, the Runge-Kutta method, and a recursive method;

a choice of output function sincluding piecewise linear, sigmoid, threshold, or user defined;

translation invariant or variant templates;

linear and nonlinear templates;

variable signal delays;

a choice of output file formats; and

a choice of training methods including RBP and RPLA (with variable step size).

Binary versions of SCSS are available for both Intel Linux and IBM AIX platforms. They can be obtained after the completion of an online registration form. A user's manual is available in the distribution.
[http://apx00.physik.uni-frankfurt.de/e_ag_rt/cnn/SCNN/homepage.html]
SCore: A high performance parallel programming environment for workstation and PC clusters. The SCore Cluster System Software consists of the following components:

PM II, a low-level communication library for cluster computing with drivers for Myrinet, Ethernet, UDP and Shmem;

SCore-D, a user-level global operating system for using cluster resources such as processors and networks;

SCASH, a software distributed shared memory (DSM) system that uses PM II and employs the Lazy Release Consistency model with both update and invalidate protocols;

MPICH-SCore, a high performance version of MPI based on the MPICH library using PM II for interprocess communication;

MPC++, a multi-threaded version of C++ using templates that provides synchronous/asynchronous remote function invocation, synchronization structures, global pointers, and other functionality;

SCOUT, a program providing an SIMD-style remote UNIX shell environment.

The features provided by this version of SCore include:

a single system image that makes it transparent to users whether they're on a single machine or a cluster;

support for communications via a variety of network protocols;

a seamless programming environment, e.g. an Hmake command enabling users to compile a program on heterogenous computers;

the MPC++ Multi-Threaded Template Library (MTTL) allows programs to run in a heterogeneous environment without code modications;

multiple parallel programming paradigms including message passing, shared memory, and multi-threaded;

a real-time process activity monitor;

automatic deadlock detection;

automatic attachment of the GDB debugger when an exception signal is detected;

pre-emptive checkpointing;

parallel process migration; and

simultaneous multiplexing of parallel processes in both the space and time domains.

A source code distribution of SCore is available. It runs on several platforms including Linux Intel. Documentation is scattered about in the form of various manuals and technical reports.
[http://pdswww.rwcp.or.jp/]
SCOTCH: A software package for static mapping and graph partitioning. It is the product of the SCOTCH project to study static mapping by the means of graph theory using a divide and conquer approach. It can map any weighted source graph onto any weighted target graph or even onto disconnected subgraphs of a given target graph. Other features include a running time linear in the number of edges of the source graph and logarithmic in the number of vertices of the target graph, easy interface with other programs due to its vertex labeling capabilities, and several tools to build, check and display graphs.
The source code is available and is currently supported on IBM AIX, Linux, SGI and Sun Solaris and SunOS platforms. The documentation is contained within a 33 page user's guide in PostScript format.
[http://dept-info.labri.u-bordeaux.fr/~pelegrin/scotch/]
Scotty: A Tcl/Tk-based package for network management applications, i.e. it allows the implementation of site-specific network management software using high-level, string-based APIs which simplifies the development of portable network management scripts. The distribution contains two main components: the Tnm Tcl extension which provides access to network management information sources; and the Tkined network editor which provides a framework for an extensible network management system.
The network protocols supported by the Tnm extension include:

SNMP (SNMPv1, SNMPv2c, and SNMPv2u including access to MIB definitions);

ICMP (echo, mask, timestamp, and udp/icmp traceroute requests);

DNS (a, ptr, hinfo, mx, and soa record lookups);

HTTP (server and client side);

SUN RPC (portmapper, mount, rstat, etherstat, pcnfs services);

NTP (version 3 mode 6 request); and

UDP (sending and receiving datagrams).

Additional commands supplied to simplify the implementation of network management applications include:

netdb to access to local network databases;

syslog to send messages to the local system logging facility; and

job to simplify the implementation of monitoring and control procedures that need to be scheduled at regular intervals.

The Tkined editor can be used to manage networks by: monitoring the status of computers, hubs and routers; interrogating TCP/IP systems for useful information; and graphically representing networks and nodes via the capabilities of Tk.
The Scotty package is available as source code and requires only a C compiler and Tcl/Tk for installation. It comes with a GNU autoconfig script to ease installation. The primary source of documentation is the man pages provided with the distribution, although HTML versions of these pages are also provided. Some tutorial and report documents are also available in HTML and/or PostScript format.
[http://wwwsnmp.cs.utwente.nl/~schoenw/scotty/]
[ftp://netlab-c.mscs.mu.edu/scotty/]

SNMPD

An SNMP daemon written using Tcl in the Scotty environment.
[http://geekcorp.com/snmpd/]

SNMP Monitor Ex

An extension to Scotty with several additional features.
[http://geekcorp.com/snmpmonitor/]
Scout: A communication-oriented operating system targeted at network appliances (e.g. network-attached devices, set-top boxes, hand-held devices, etc.). Scout runs stand-alone on Alpha and Pentium processors and is hosted from Linux using GNU tools. The characteristics needed for a network appliance OS that require rethinking standard OS concepts include:

I/O handling as the primary function which makes it a good idea to structure the OS around communication-oriented abstractions rather than the usual computation-centric abstractions (e.g. processes, jobs, tasks);

provision of a general framework that can be specialized or configured for particular needs rather than a general purpose OS that doesn't offer exactly the right functionality; and

predictable performance with scarce resources, e.g. the OS must pay attention to the behavior of the system under load in the light of the need to support realtime performance.

Scout addresses these issues by:

being designed around a novel communication-oriented abstraction called a path which is an extension of a network connection into the host OS;

configurability wherein an instance targeted for a particular network appliance is generated from a collection of building-block modules; and

including scheduling and resource allocation mechanisms that offer predictable performance under load.

The path abstraction also plays a role in the other issues. Paths expose global context that various optimization techniques can exploit for specialization, i.e. it achieves specialization through configurability with the resulting modular system optimized on a path-by-path basis. As regards resource management, all scheduling decisions are made on a per-path basis, i.e. Scout allocates to a given path all the resources it needs to provide the same quality of service as is supported by the network connection. Scout also uses small languages to generate diverse collections of specialized network appliances. These are special-purpose languages used to specify some component of Scout from which OS code can be automatically generated. Thus all components need not be implemented from scratch but can be generated according to the specific needs of an appliance.
In addition to the basic OS capabilities, the Scout distribution contains the modules and files needed to build several network appliances including:

NetTV, which decodes and displays MPEG-compressed video streams;

NetCAM, which captures frames from a video source, compresses them, packetizes the frames, and transmits them;

IP Router with QoS Support, which supports IETF-defined Guaranteed and Controlled-Load service classes and includes multiple packet scheduling algorithms;

HTTP Firewall, a firewall specialized for HTTP traffic whose goal is to limit the access of traffic to/from a protected network and limit the data flows within the firewall itself;

Joust, a small and fast JavaOS which includes an efficient Java virtual machine and a JIT compiler;

Test Kernel, which exercises a TCP/IP protocol stack; and

NetBoot, used to boot other kernels on Pentiums.

A source code distribution of the Scout OS is available which requires Toba for the Java components. The supported hardware is listed at the site. The system is documented in various technical reports and papers.
[http://www.cs.arizona.edu/scout/]
SCPACK: The Schwarz-Christoffel PACKage is a Fortran package for the numerical implementation of the Schwarz-Christoffel (S-C) conformal map from the interior of a unit disk in the complex plane. The image polygon may have vertices at infinity so it is really any simply-connected region in the plane whose boundary consists of a finite number of straight lines. The conformal map can be applied to many types of problems involving a polygonal domain, e.g. Laplace's equation with Dirichlet, Neumann, or mixed boundary conditions; solving Poisson's equation; finding eigenvalues of the Laplace operator; hodograph computations for ideal free-streamline flow; and grid generation. SCPACK contains routines to solve the parameter problem associated with the S-C map (SCSOLV), to evaluate the resulting S-C map (WSC), and to evaluate its inverse (ZSC). The S-C approach is good for the conformal mapping of a polygon because it handles the singularities at corners exactly and reduces the map to a finite number of parameters, but it is not recommended for mapping curved domains by means of polygonal approximations since much better methods exist for the latter.
The SCPACK distribution is available as source code. All 19 suboutines are written in Fortran 77 and are documented in an ASCII user's manual as well as in comment statements contained within the source code files. See Trefethen (1980).
[http://www.netlib.org/conformal/]
sC++: A language which enhances C++ with some new keywords which define active objects and synchronization primitives in a way that preserives the philosophy of object oriented programming. An sC++ compiler produces code which is linked with a run-time library to produce multithreaded code running within a UNIX process.
The library consists of several different classes including:

a Collection class;

a CppUtils class containing general classes and templates;

a GUI class which encapsulates a large part of the functionalities

of Motif and X into active objects;

a 2-D geometry library;

a Graph library;

a Matrix library;

a Signal library containing an active object abstraction of the UNIX signal concept; and

a Socket library containing abstracts of UNIX TCP sockets, UDP connection-oriented sockets, and UNIX socket primitives.

Separate distributions of the sC++ package are available for Linux and Sun/DEC machines. There is extensive online documentation for the compiler and libraries as well as several technical reports available in PostScript format.
[http://ltiwww.epfl.ch/sCxx/index.html]
Screamer: An extension of Common Lisp that adds support for nondeterministic programming. It consists of two levels: a basic nondeterministic level which adds support for backtracking and undoable side effects and, on top of this, a nondeterministic substrate. Screamer provides a comprehensive contraint programming language on top of this substrate in which mixed problems of numeric and symbolic constraints can be formulated and solved. This extension provides Common Lisp with most of the functionality of both Prolog and various constraint programming languages.
The source code for Screamer is available. Is is portable across most Common Lisp implementations and is known to run under AKCL and CMUCL. A user's manual and a technical paper describing Screamer are included in the distribution in PostScript format.
[http://www.cis.upenn.edu/~screamer-tools/home.html]
SCRIP: The Spherical Coordinate Remapping and Interpolation Package computes addresses and weights for remapping and interpolating fields between grids in spherical coordinates. It supports four kinds of remappings:

a conservative remapping scheme ideally suited to a coupled model context where the area-integrated field must be conserved;

a basic bilinear interpolation scheme slightly generalized to perform a local bilinear interpolation;

a bicubic interpolation similar to the bilinear method; and

a distance-weighted average of nearest-neighbor points.

The blinear and bicubic schemes can only be used with logically rectangular grids, while the others can be used for any grid in spherical coordinates. The source code is freely available, and requires a Fortran 90 compiler and NetCDF for compilation. A user's guide is available in PostScript format.
[http://www.acl.lanl.gov/climate/software/SCRIP/SCRIPmain.html]
scripting language: Scripting languages are those that are primarily interpreted and which can be directly executed from a text file using the standard #! construct. Scripting languages or packages that contain some form of scripting language include:

ASPy

BeanShell

beast

bigwig

BOIL

Brain

ccscript

ccsh

Cfengine

CH

C-Kermit

CorbaScript

Datapult/PF

DINO

eNITL

EvoScript

Expect

FESI

FPL

Ftwalk

Gawk

GIPSY

Glish

Gorby

Guile

ICI

ICL

Jacl

Lua

Marx

mash

Merle

Meta-HTML

NeoWebScript

NetRexx

Object REXX

Pacco

PDP++

Perl

PHP

Pike

Pnuts

Python

REBOL

ROOT

Ruby

Scheme

SIA

Slang

Small, a simple, typeless, 32-bit extension and scripting language;

SNMX

Socket Script

Spanner

Tcl

WebL

WebScript, for processing web documents.
Scriptum: A graphical-based text editor. The features include visual enhancements to improve source code readability, powerful navigation and browsing commands, edition commands including keyword completion, blocking indenting, scope selection, etc., multi-level undo/redo, a definition browser (for C, C++ and Java at present), a graphical class browser for the same suspects, integration with RCS/SCCS for version management, file locking features, remote editing via the FTP protocol, folding, configurability, and built-in configurations for YACC/Bison, lex, C, C++, Eiffel, Lisp, Scheme, Java, Perl and HTML. The present version (5/96) is free.
[http://www.scriptum.org/]
[http://graficadigital.com/websites/InterSoft/html/products/scriptum.html]
ScriptWriter: A word processor specifically modified for writing scripts in the official formatting style. This is a modified version of AbiWord.
[http://www.freefilm.cx/ScriptWriter/]
SCRUM: The S-Coordinates Rutgers University Model is an ocean circulation model that solves the free surface, hydrostatic, primitive equations over variable topography using stretched terrain-following coordinates in the vertical and orthogonal curvilinear coordinates in the horizontal. The model equations are solved separately for total momentum and vertically integrated momentum and then coupled. The total momentum and tracer equations are discretized in time using a third-order Adams-Bashforth scheme with the vertical viscosity/diffusion terms treated implicitly with a Crank-Nicolson scheme. The free surface and vertically integrated momentum equations are discretized in time with a trapezoidal leapfrog scheme, and the horizontal and vertical derivatives are evaluated with finite differences on a staggered horizontal C-grid and a staggered vertical grid.
The additional features of SCRUM include:

a vertical staggered grid;

optional horizontal and vertical Smolarkiewicz advection;

rotating mixing tensors which mix on constant z-surfaces and constant in-situ density surfaces;

several available vertical turbulence closure schemes;

a coupled bottom boundary layer model;

Lagrangian drifters;

analytical and data driven packages for initial conditions, boundary conditions, and forcing functions;

analytical test examples;

input and output files via NetCDF;

a coupled sea-ice model;

grid generation and land/sea mask packages;

a data assimilation scheme; and

a coupled biological model.

The source code for SCRUM is available. It is written in Fortran 77 and is configured to compile with several Fortran compilers, including g77. Full use of the package also requires that the user have NetCDF, NCAR Graphics, Imake, Perl, MEXCDF, and Matlab, although many parts can be used without all of the above being available. The documentation is scattered about in the code itself and in some manuals in various formats.
[http://marine.rutgers.edu/po/models/scrum.html]
scsh: A broad-spectrum systems-programming environment for UNIX embedded in R4RS Scheme. It can be used as a scripting language via a high-level process notation for doing shell-script like tasks, running programs, etc., as a systems-programming language via low-level access to the operating system (as with C), and as a portable programming environment implemented on top of Scheme 48, which is machine independent across 32-bit processors and can be installed on most generic UNIX platforms, including Linux.
[http://www-swiss.ai.mit.edu/ftpdir/scsh/]
[ftp://swiss-ftp.ai.mit.edu/pub/su/scsh/]
SCWM: The Scheme-Configurable Window Manager is a window manager with a configuration language based on Guile. The features of SCWM include:

full programmability via Guile Scheme;

an optional constraint-based window layout system;

multiple decoration styles including mwm, fvwm and win95;

all configurable quantities can be changed on the fly at runtime;

a powerful external control panel that can be used to execute any window manager command at any time;

an Emacs interaction mode;

support for fvwm2 modules;

multiple disjoint virtual desktops;

animated move and windowshade operations;

loading nearly any image type; and

time, input and new window hooks.

A source code distribution is available.
[http://scwm.mit.edu/]
sd: The Session Directory package is a general manager tool for multimedia sessions held over the Internet. It provides a dynamically updated list of available sessions, an easy way to join any available sessions, and an easy way to create and advertise new sessions.
Sd is based on the RTP Draft Internet Standard where RTP is an application-level protocol implemented entirely within sd, i.e. no special system enhancements are needed to run it. It can be run point-to-point using standard IP addresses, but it is primarily intended to be a multiparty conferencing application. Your system must support IP Multicast to make use of the conferencing capabilities and ideally should be connected to the IP Multicast Backbone, i.e. MBone. Sd is used to direction a multimedia conference with the video handled by vic, the audio by vat, and the white board by sd.
The sd software is available in binary format for DEC OSF and Ultrix, HP-UX, NetBSD, Linux Intel, Sun SunOS and Solaris, and SGI IRIX platforms. It's use is documented in an ASCII file included in the distribution.
[ftp://ftp.ee.lbl.gov/conferencing/sd/]
SDB: The Scientific Data Browser is an HTTP server CGI script which enables a browser that fully supports tables to be used to interactively view files in HDF, FITS, and NetCDF data formats. The use of the program requires the prior installation of HDF 4.0r2 or greater and FITSIO 4.08 or greater.
The source code for SDB is available. It is written in ANSI C and can be compiled and installed on many generic UNIX platforms. It is sparsely documented in an ASCII README file and at the home site. See also JHV.
[http://hdf.ncsa.uiuc.edu/sdb/sdb.html]
SDBI3P/SDSF3P: An algorithm for smooth surface fitting for scattered data which has the accuracy of a cubic polynomial in most cases and is a local, triangle-based algorithm. This is TOMS algorithm 761 and is documented in Akima (1996b).
[http://www.acm.org/calgo/contents/]
sdc: A system which aims to make SGML suitable for easy, day-to-day use. The sdc system makes is simple to write technical documentation, reports, books, letters, man pages, or prepare talks or classes which include text, graphics, and other special data representation formats such as tables. The package comes with some DTDs which enable the writing of simple documents like letters up to things like books using a minimum of markup. The current (5/97) target output formats for sdc include LaTeX, PostScript, HTML, Texinfo, Groff man page, formatted ASCII, and limited RTF. Support for literate programming is also built in.
Some further features of sdc include:

sorted indices and tables of contents automatically created for larger documents; and

support for special formattings, e.g. mixture of LaTeX, Groff, and Lout code within one source file and easy inclusion of encapsulated PostScript and xfig pictures.

The sdc package is written in Scheme. The source code is available and can be compiled using the Bigloo package. The use of sdc also requires sgmls. Additional packages such as Lout and LaTeX are required if they are to be used with sdc. The package is documented in a user's manual available in PostScript format.
[http://www.inf.tu-dresden.de/~jw6/doc/sdc/index.html]
[http://www.red-bean.com/~craig/sgml-scheme/]
[http://www.oasis-open.org/cover/sdc10.html]
sdd: A replacement for the UNIX dd program (for converting a file while copying it) that is much faster in cases where the input block size is not equal to the output block size. Other features include:

more readable statistics than from dd;

a timing option to print transfer speed;

timing and statistics available at any time;

seeking on input and output;

fast null input and output;

reblocking on pipes doesn't fill small input blocks to input block size; and

debug and progress printing.

A source code distribution is available.
[ftp://ftp.fokus.gmd.de/pub/unix/sdd/]
SDDF: The Pablo Self-Defining Data Format is a data description language that specifies both data record structures and data record instances. It is basically a data meta-format since it can describe general data records rather than predefined sets of records. The format supports the definition of records containing scalars and arrays of the base types found in most programming languages. The SDDF format is implemented in a set of C++ classes that provide an API to the data stored in SDDF files, with their classes and methods supporting the full range of operations needed to write files in the SDDF format and to interpret the data stored in SDDF files.
The distribution also contains several programs for manipulating and scrutinizing SDDF data files including:

AdjustTime, adjusts the Timestamp and Seconds fields in a file;

ConvertAIMS, converts AIMS trace files to SDDF files;

ConvertPICL, converts PICL trace files to SDDF files;

ExpandField, expands fields in an SDDF file according to a template file;

ExtractFieldValues, extracts and writes information from an SDDF file;

FileStats, scans an SDDF file and reports statistics;

FindSddfError, locates errors in an SDDF file;

MergePabloTraces, merges arbitrary numbers of SDDF files;

MergeTwoFiles, merges two SDDF files;

SDDFconverter, converts an SDDF file to anoather SDDF format;

SDDFmerge, merges arbitrary numbers of SDDF files;

Sample, creates a sample SDDF file;

SDDFmerger, merges all SDDF files in a directory;

SDDFsplit, splits an SDDF file into multiple files by field value;

SDDFStatistics, gathers statistics about data fields in SDDF files.

Source code and binary distributions are available.
[http://www-pablo.cs.uiuc.edu/Software/Pablo/SDDF/SDDF.htm]
SDF: Simple Document Format is a freely available document development system which generates output in a variety of formats from a single source document. The available output formats include PostScript, PDF, HTML, plain text, POD, man pages, LaTeX, MIF, SGML, Texinfo, Lyx, Windows help, RTF, and MIMS F6 and HTX help. SDF is useful for publishing documents or reports on the Web or in multiple formats, maintaining large documentation suites using rule-based formatting and hypertext generation, and embedding documentation in source code or pretty printing source code.
A source code distribution of SDF is available. It is written in Perl and requires version 5.003 or later. Additional software is required for some output formats, e.g. pod2ps for PostScript, the Acrobat Reader for PDF, and SGML-Tools for Lyx and Texinfo. Documentation is available in the form of user's, reference, and guru guides in PostScript format as well as several other smaller documents.
[http://www.mincom.com/mtr/sdf/]
SDL: The Simple DirectMedia Layer is a cross-platform library for portable, low-level access to the video framebuffer, audio output, mouse and keyboard. It is designed to make it easy to write games that run on Linux, Win32 and BeOS platforms using a single source-code level API. It is loaded as a dynamically linked library on its native platform. The features and functionality include:

a simple interface to the display framebuffer in which it is represented as an offscreen surface which can be directly written to;

handling of six basic event types (i.e. activation, keyboard, mouse motion, mouse button, quit, and window hook) which are filtered and posted to an internal event queue;

support for both 8 and 16 bit signed and unsigned sound samples within the frequency range 11025-44100 Hz (depending on hardware);

audio control of up to 32 local CD-ROM drives at once with support for all of the basic functions of a CD player; and

functions for creating threads and binary semaphores (mutexes).

Source code and binary distributions are available, with the latter available for several platforms and the former released under the LPGL. The distributions contain many example programs and libraries demonstrating, e.g. simple sprite and organic firework animation, play WAV and Mac sound resources, starfield rotation, truetype font rendering, and dynamic image warping.
[http://www.libsdl.org/]

SDL-Perl

A Perl wrapper for the SDL multimedia library.
[http://www.metaverse.fsnet.co.uk/sdlpl/]
SDML: The Signed Document Markup Language is part of the Electronic Check Project and is designed to:

tag the individual text items making up a document;

grouping the text items into document parts which can have business meaning and can be signed individually or together;

allow document parts to be added and deleted without invalidating previous signatures; and

allow signing, co-signing, endorsing, co-endorsing and witnessing operations on documents and document parts.

The signatures become part of the document and can be verified by subsequent recipients.
[http://www.w3.org/TR/1998/NOTE-SDML-19980619/]
[http://www.oasis-open.org/cover/xml.html]
SDMS: The Simple Document Management System allows the storage and retrieval of documents in a database via a web interface. SDMS uses PHP to provide an interface to a MySQL server for storing and retrieving documents and sharing them among many users. The system also provides Access Control Lists (ACLs) to grant access rights on a per-user basis.
[http://sdms.cafuego.net/]
sdoc: A program for documenting other programs which supports the creation and addition of documentation and produces printable output in a variety of formats. In the sdoc system documentation information is added to the source code using the pod (Plain Old Documentation) format which is also used in Perl. The pod documentation options are simple and easy to learn yet powerful enough to create quality output.
Sdoc can be used to document C, C++, Java, Tcl and Perl programs. It uses the information in a source code file to create a pod-document which may in turn be transformed into HTML, LaTeX, PostScript, nroff, or plain text. It has a preview function which lets you interactively create documentation, i.e. add or modify the documentation in the source code file and check the output for correctness. Sdoc also features automated indexing.
A public domain binary version of sdoc can be obtained for Linux, HP-UX and SGI Irix platforms. This includes everything necessary to use it except for Perl. The complete system consists of separate packages containing the base, public, and operating system specific packages. There are also language-specific files containing adaptions and help files for the supported languages (i.e. English and German). Complete documentation and context sensitive help are included in the distribution.
[http://www.cit.nepean.uws.edu.au/~blilburn/sdoc/]
SDPA: The SemiDefinite Programming Algorithm is a package that solves the standard form semidefinite program and its dual. It is based on an interior point algorithm for monotone semidefinite linear complementarity problems. The features include:

a Mehrota-type predictor-corrector step which contributes to reducing the number of iterations as well as increases the numerical stability;

a sparse matrix data structure used to increase computational efficiency and save memory;

a choice of search directions including HRVW/KSH/M, AHO, and NT; and

information on the possible infeasibility of a given problem.

SDPA is written in C++ and uses the Meschach library for matrix computations. It is available in binary form for Sun SunOS and Solaris, SGI IRIX, HP-UX, DEC Alpha, and Linux platforms. The documentation is included in each distribution in the form of a PostScript format user's manual. See also CSDP, INCT, LMITOOL, MAXDET, SDPpack, SDPSOL, and SP.
[ftp://ftp.is.titech.ac.jp/pub/OpRes/software/SDPA/]
SDPGL: A cross-platform, open source static library for tracing OpenGL calls while a program executes. A stack mechanism allows for stopping and starting tracing from within a code, and arbitrary strings can be inserted into the SDPGL output. This is part of the framework for K-3D, and was at one time called KGL.
[http://www.k-3d.com/libraries/sdpgl/]
SDPpack: The SemiDefinite Programming package is a package of Matlab files designed to solve semidefinite programs (SDP), i.e. a generalization of linear programming to the space of block diagonal, symmetric, positive semidefinite matrices. The main routine implements a primal-dual Mehrotra predictor-corrector scheme based on the XZZX search direction. Also provided are certain specialized routines to: solve SDPs with only diagonal constraints; compute the Lováez $\theta$ function of a graph using the XZ search direction; determine whether an SDP is primal or dual degenerate; and compute the condition number of an SDP.
The UNIX distribution contains the Matlab sources and documentation in PostScript format. Binary MEX files are available for some platforms for improved performance (although not for Linux as of 3/97). See also CSDP, INCT, LMITOOL, MAXDET, SDPA, SDPSOL, and SP.
[http://www.cs.nyu.edu/faculty/overton/sdppack/sdppack.html]
SDPSOL: A parser/solver for semidefinite programming (SDP) and determinant maximization (MAXDET) problems with matrix structure. Such problems arise in control theory, statistics, computational geometry, and information and communication theory. SDPSOL automates the task of putting the optmization variables into matrix structure by allowing problems to be specified in a foramt close to its natural mathematical description. It parses the problems expressed in its SDPSOL language and then solves them using an interior point method.
The SDPSOL distribution includes the C source code, Matlab source code that allow it to be used from within that package (although it can also be used in standalone form), and documentation in PostScript format. See also CSDP, INCT, LMITOOL, MAXDET, SDPA, SDPpack, and SP.
[http://www-ISL.Stanford.EDU/people/boyd/SDPSOL.html]
sdr: A session directory tool designed to allow the advertisement and joining of multicast conferences on the MBone. Binary distributions are available for several platforms including Linux Intel.
[http://www-mice.cs.ucl.ac.uk/multimedia/software/sdr/]
SDRIV: A routine for solving ODE IVPs. See CDRIV.
SDSC Image Tools: A suite of portable image manipulation tools coupled with extensive support for a wide range of image file formats. The tool functionality and format support are implemented within a portable, user-callable function library. This features tools that will adjust image colors, desaturate, brighten, etc., concatentate images into multi-image files, cycle a color lookup table, digitally composite images, convert between all supported image formats, copy a portion of an image to a new file, dissolve between two images, display image attributes, fill a region of an image with a color or a gradient, flip an image horizontally or vertically, convert to grayscale, compute an image histogram, chroma key two images together, lighten or darken an image, convert to monochrome, paste an image into another, cycle an image horizontally or vertically, free rotate an image, scale an image up or down, shear an image horizontally or vertically, split apart multi-image files, and build a storyboard grid of images.
Imtools suports the following image file formats: bmp, cur, eps, gif, hdf, ico, icon, iff, jpeg, miff, mpnt, pbm, pcx, pic, pict, pix, ps, ras, rgb, rla, rle, synu, tga, tiff, viff, x, xbm, xpm and xwd. The source code is available as are binaries for a couple of platforms (although not for Linux). The source should compile and install fairly easily on generic UNIX platforms. The documentation includes extensive man pages in both nroff and PostScript formats.
[ftp://ftp.sdsc.edu/pub/sdsc/graphics/imtools]
SDTS: The Spatial Data Transfer Standard is a standard for transferring earth-referenced spatial data between dissimilar computer systems with the potential for no information loss. It is a self-contained transfer method in that spatial data, attributes, georeferencing, data quality reports, data dictionaries, and other supporting metadata are all included in the transfer. The standard is implemented through profiles which allow both encoding and decoding to be feasible and that all meaningful information is transferred. A profile is intended to provide specific rules for apply STDS base specifications to a particular type of spatial data. Specific profiles include the Topological Vector Profile (TVP), the Raster Profile and Extensions (SRPE), the Transportation Network Profile (TNP), and the Point Profile.
[http://mcmcweb.er.usgs.gov/sdts/]
[http://www.ngdc.noaa.gov/seg/tools/sdts/main.html]

STDS++

A C++ toolkit for writing applications that can read and write SDTS datasets.
[http://mcmcweb.er.usgs.gov/sdts/sdtsxx/index.html]
SEA: A 3-D, finite-difference, primitive equation ocean general circulation model based on the classic Bryan-Semtner-Cox formulation. It is designed to give good performance on workstations, workstation clusters, and massively parallel systems using message passing (with both MPI and PVM supported). SEA offers several optional numerical schemes and parameterizations including:

the QUICK tracer advection scheme;

a complete convection scheme;

a Pacanowski and Philander type vertical mixing scheme;

a Kraus and Turner type mixed-layer model;

implicit vertical mixing;

ispycnal tracer mixing; and

parameterization of tracer mixing by eddies.

A source code distribution of this package is available. It is mostly written in Fortran with some C. A user's guide is available in HTML and PostScript formats.
[http://www.mth.uea.ac.uk/ocean/SEA/]
SEAL: The SynthEtic Audio Library is an API that allows applications to play digital audio waveforms and multichannel music module sequences concurrently. The features of SEAL include:

16-bit stereo at 44,100 Hz output;

32 simultaneous digital audio channels;

digital filtering;

smooth pitch, volume and panning controllers;

highly optimized waveform mixing algorithms;

performance-tuned for Pentium processors;

support for RIFF/WAVE waveform files; and

support for MOD/MTM/S3M/XM module files.

A source code distribution of SEAL is available.
[http://www.egerter.com/seal/]
SEALS: The System for Easy Analysis of Lots of Sequences is a set of programs designed to facilitate nucleotide and protein sequence analysis projects involving large amounts of data. SEALS consists of around 50 Perl programs (i.e. commands) for retrieving sequence information, scripting database search tools, viewing and analyzing search outputs, searching in and processing nucleotide and protein sequences using regular expressions, and constructing rational predictions of protein features. features. The system is designed to provide modular elements which can be combined, modified, and integrated with other methods in order to quickly design and execute computer experiments for sequence analysis projects at the scale of whole genomes.
The SEALS system is divided into five packages:

UniPred, a system for rational prediction of protein features;

BLASTMORE, an interactive system for viewing and analyzing BLAST output files;

GREF, a system for performing sophisticated pattern matching and processing in FASTA libraries;

RWidgets, a set of basic command-line tools for manipulating FASTA libraries, GenBank flatfiles, lists of gi numbers, and BLAST outputs; and

SPLAT, a set of tools for scripting BLAST and MoST searches and processing the results.

A source code distribution of SEALS is available. It is written entirely in Perl, although it is built on top of some other packages, the most significant of which is the NCBI Toolkit.
[http://www.ncbi.nlm.nih.gov/Walker/SEALS/index.html]
SEA-MAT: A collaborative effort to organize and distribute Matlab tools for the oceanographic community. The current (5/97) contents include:

Air-Sea, tools to compute surface wind stress and heat flux components from various measurements;

M-Map, tools to draw publication-quality maps in 13 different projections;

RPSstuff, miscellanous time series tools;

Timeplt, tools for creating stacked X-Y and vector stick plots with Gregorian time labeling;

bobstuff, tools for vector correlation, complex correlation, and other statistical tasks; and

STAPLOT, a package for the graphical analysis of hydrographic or other irregularly spaced data.

[http://sea-mat.whoi.edu/]
searching and indexing tools: These include:

AISearch

freeWAIS-sf

GiST

Glimpse

GlimpseGate

Harvest

ht://Dig

htgrep

Isearch

Isite

Namazu

Pluribus

SFgate

Swish

TOOLDIAG

UdmSearch

WebGlimpse

WebLib

xax500

Z39.50
Seawall: An ipchains-based firewall that can be used on a dedicated masquerading firewall machine (including LRP), a multi-function masquerade gateway/server, or on a standalone Linux system. The features include:

customizable via config files and explicit ipchains rules without modification of included scripts;

status monitoring with an optional audible alarm for selected packet types;

support for VPN via ipip tunnels;

support for masqueraded PPTP servers, e.g. PoPToP;

support for masqueraded servers via ipmasqadm;

support for PoPToP on a Linux gateway/firewall;

limited support for a DMZ;

a straightforward installation script;

a fallback script that backs out the installation of the most recent version; and

an uninstall script.

[http://seawall.sourceforge.net/]
SECUDE: The SECUrity Development Environment is a security toolkit incorporating well-known and established symmetric and public-key cryptography. It offers a library of security functions, security APIs, and a number of utilities. Most of the functionality of SECUDE is available through a command-line utility called secude with which it is possible to maintain a Personal Security Environment (PSE) or wrap and unwrap data.
The functionality of SECUDE includes:

basic cryptographic functions like RSA, DSA, DES, IDEA, various hash functions, the RFC-1423 defined algorithm suite, and OIW defined algorithms;

security functions for origin authentication, data integrity, non-repudiation of origin and data confidentiality purposes on the basis of digital signatures and symmetric and asymmetric encryption;

X.509v1 and X.509v3 key certification functions with the handling of certification paths, cross-certification, and certificate revocation;

utilities and functions for the operation of certification authorities (CA) and interaction between certifying CAs and users;

utilities to sign, verify, wrap, unwrap, and hash files;

Internet PEM processing according to RFC-1421 to RFC-1424;

processing of RFC-1422 defined certificate revocation lists;

Generic Security Services - API version 2 (GSS-API) as defined by RFC-1508 and RFC-1509;

Public Key Cryptography Standards (PKCS) numbers 1, 3, 7, 9, and 10;

all necessary ASN.1 encoding and decoding; and

integrity-protected and confidentiality-protected storage of all security relevant information of a user in a PSE.

Two different PSE realizations are provided- a smartcard environment (SC-PSE) and a DES-encrypted directory (SW-PSE)-with both accessible only through the usage of a Personal Identification Number (PIN).
Binary distributions of the SECUDE package are available for a wide range of UNIX platforms. A user's manual is available in HTML format.
[http://www.darmstadt.gmd.de/secude/]
security tools: Several sites are valuable resources for those interested in maintaining security on UNIX systems. These include:

Linux Security Homepage, which concentrates on security issues concerning our favorite OS;

Network Security, a site about how the folks at MIT are making things more secure in their networks;

DEF CON, the home site of the folks who have the most interesting parties/conventions about computer security;

Rootshell, which contains up-to-date code for exploiting various systems (i.e. it's what you don't known that will kill you);

Security Bugware List
Contains accurate descriptions and summaries of attacks with good summaries of the problems and solutions involved.
http://oliver.efri.hr/~crv/security/bugs/list.html

Unix Hacking Resources, because if it's already on the Web then you need to know about it.

Available security tools include:

AIDE, a Tripwire replacement that can be used to check the integrity of files on a system;

Argus, a generic IP network transaction tool that can perform a variety of network management tasks;

ASAX, a package for performing advanced security audit trail analyses;

Autobuse, a daemon for identifying probes in logfiles;

autostatus, a network and server monitoring program;

check-ps, for detecting rootkit versions of ps;

CIPE, a project to build encrypting routers;

COPS, a collection of security tools for finding UNIX system vulnerabilities;

Digital-Phalanx, a UNIX security daemon for restricting users on a machine;

DTK, a toolkit that uses deception to counter various types of attacks on networked computers;

ENskip, a security module for the TCP/IP stack;

exscan, a port scanner that can also identify the OS type;

flc, a filter language compiler for generating rules for several packet filtering packages;

FreeS/WAN Project, a project to guard against passive wiretapping;

fwck, a utility for checking on the .forward files in the home directories of users;

Gabriel, a SATAN detector;

GNUPG, a free replacement for PGP;

icmpinfo, keeps track of ICMP traffic;

ifstatus, checks network interfaces for those in debug or promiscuous mode;

IP Filter, a TCP/IP packet filter for use in firewall environments;

IPFT, a userspace IP stack with a suite of utilities for exploiting TCP protocol stack weaknesses;

IsinGlass, a security configuration script;

John the Ripper, a password cracker;

Kerberos, a network authentication protocol;

KerbNet, a version of Kerberos with enhanced features;

Logcheck, a program that monitors and spots possible problems in system logfiles;

lsof, a program that lists open files on a system;

Merlin, a tool providing a friendly interface to several other popular security tools;

NCSfck, checks for changes in important files by keeping a database;

Nessus, a project to develop a security auditing tool;

NetSaint, a program for monitoring hosts and services on a network;

netwatch, a network connection monitor focusing on Ethernet connections;

NFSwatch, monitors all incoming network traffic to an NFS server;

NID, a network intrusion detector;

nmap, a network mapper for port scanning;

NOCOL, a network monitoring package;

npasswd, a more stringent replacement for the passwd command;

OPIE, an implementation of the OTP protocol;

Osh, a security-enhanced and restricted shell;

OTPW, a one-time password generator package;

packmon, an Ethernet traffic monitor;

Protolog, a set of daemons for logging incoming TCP, UDP and ICMP packets;

RIPEM, a package for email security;

runas, for allowing unprivileged users to run selected commands as root and sysadmins to run processes as any user;

SAINT, a network security tool that gathers information about remote hosts;

SATAN, a security administration tool not without controversy;

SBScan, a security auditing tool;

scanallert, for detecting port scans;

SECUDE, a security toolkit incorporating various types of cryptography;

Sentry, detects and responds to port scans against a target host in real time;

SESAME, a construction kit containing components for adding security to applications;

sidentd, a Perl implementation of the identification protocol;

slocate, a secure way to index and quickly search for files on a system;

SOCKS, a network protocol for performing network proxies;

SPONG, a simple system monitoring package;

SPX, a system providing public key based strong authentication in a distributed environment;

ssh, a secure replacement for the traditional UNIX remote login, shell and copy commands;

SSL, a protocol for implementing security on top of a transport service;

StackGuard, a compiler addition for the automatic detection and prevention of stack overflow attacks;

sudo, for allowing users to run selected programs as root;

Swatch, a system for monitoring events on a large number of machines;

sXid, a suid/sgid monitoring script;

ssyslog, a cryptographically secure system logging tool;

tcpscan, scans a machine for usable TCP ports;

TCP_wrappers, a daemon that adds security features to TCP network services;

TIGER, a set of scripts and programs for performing security audits on UNIX systems;

Trinux, a security-minded Linux distribution;

Tripwire, a program for determining system integrity;

Unix Hacking Tools, a set of tools for exploiting some well-known system weaknesses;

uwatch, a program for indicating when given users log in or out.
sed: The stream editor is an editor which applies a fixed set of editing changes to a file or a sequence of files. It is historically derived from the ed editor and most used for simple changes such as uniform substitutions. GNU has a version of sed although it tends to be slower than other versions, although not noticeably so for occasional applications. Tutorials, scripts, and various other information can be found at the latter two URLs below, while the GNU implementation can be found at the first two. See Dougherty (1992), Dougherty and Robbins (1997) and Robbins (2000).
[http://www.gnu.org/software/sed/sed.html]
[http://www.cornerstonemag.com/sed/]
[http://sunsite.unc.edu/pub/Linux/utils/text/]
[http://mickey.lcsc.edu/~steve/guckes.html]
SEDRIS: The Synthetic Environment Data Representation and Interchange Specification is a standard for describing and interchanging environmental data. SEDRIS is comprised of a data model, a set of APIs for reading and writing data, and a set of standalone software tools. The data model provides a means of defining all the data elements needed to create a synthetic environment as well as a means to describe the relationships between the data elements.
The SEDRIS data model is based on an object-oriented notation consisting of concrete and abstract classes and their relationships and attributes. The primary data model classes include geometry, features, topology, textures and images, property grids plus data tables, and various libraries. An implementation of the APIs and software tools is available which can be compiled on Linux platforms.
[http://www.sedris.org/]
SeeR: A multipurpose C-like scripting library for writing scripts that can be compiled at runtime or precompiled and stored in ready-to-use binary format. A program containing a SeeR script can call any functions exported from the script, and a script can contain its own data as well as exportable and non-exportable functions.
[http://home.elka.pw.edu.pl/~ppodsiad/seer/]
SEISAN: A complete set of programs and a simple database for analyzing analog and digital earthquake data. The programs included in this seismic analysis package include:

HYP, a program for finding hypocenters;

MULPLT, a general plotting, signal analysis and phase picking program;

EPIMAP, for plotting epicenters;

SELECT, for searching the database;

COLLECT, for extracting events from the database;

SPLIT, for splitting up a multiple event S-file in Nordic format;

UPDATE, for updating final locations in the database;

DIRF, for making a numbered list of files;

BUL, for making a bulletin; and

RESP, PR_RESP and PRESP, for creating response files for seismic systems having a standard velocity or acceleration transducer, printing it, and plotting it.

[ftp://ftp.ifjf.uib.no/pub/seismo/]

SEISNET

A package for collecting data from local or regional seismic networks. SEISNET is an automatic event detection and data collection system for detection parameters and waveform data. This is written mainly in the scripting language Expect and is meant to be used in conjunction with the SEISAN package.
[http://www.ifjf.uib.no/seismo/software/seisnet.html]
seismology software: Related packages include:

ANRAY, for the computation of rays, travel times, ray amplitudes, and ray synthetic seismograms in 3-D laterally varying structures;

Coral, a set of Matlab programs designed for analyzing seismic waveform data

fresnel, a Fortran package for computing the Fresnel zone of seismic waves in a spherical Earth

GIANT, an analysis system for the consistent analysis of large, heterogeneous seismological data sets;

neotec, thin-plate and -shell finite element programs designed for neotectonic studies;

paleotec, thin-plate and -shell finite element programs for performing paleotectonic simulations;

PASSCAL, for the field processing of seismic data collected on RefTek data recorders;

Restore, a program that uses various geologic data to compute paleotectonic flow and deformation patterns as well as integrate them backward over time to create palinspastic restorations;

SEISAN, a complete set of programs and a simple database for analyzing analog and digital earthquate data;

SEPlib, a seismic data processing package;

SIA, an integrated package for performing seismic processing and data analysis tasks;

SPHERAY, a Fortran package for computing travel-times in a spherical earth;

SPLIT, a Fortran package for computing synthetic seismograms of shear waves split by travelling through a stack of anisotropic layers;

SU, an environment for seismic research and data processing;

TauP, a toolkit of flexible seismic travel-time and raypath utilities;

3SMAC, an a priori seismological model of the upper mantle based on geophysical modeling;

ZMAP, a set of Matlab scripts for implementing a broad range of traditional and novel techniques for seismicity analysis.

See also the geostatistics section.
Selathco: The Simple Extensible LATeX To HTML COnverter is a Java program for converting LaTeX source files into HTML. This requires JDK 1.1 or greater.
[http://dione.zcu.cz/~toman40/selathco/]
Self: An object-oriented programming language for exploratory programming based on a small number of simple and concrete ideas, i.e. prototypes, slots, and behavior. Prototypes combine inheritance and instantiation to provide a framework that is simpler and more flexible than most object-oriented languages. Slots unite variables and procedures into a single construct which permits the inheritance hierarchy to take over the function of lexical scoping in conventional languages. Self doesn't distinguish state from behavior and thus narrows the gaps between ordinary objects, procedures and closures.
The Self language was originally created at Sun and for a while was only available in versions for Sun machines. A Linux version called tinySelf is available from the Merline Project. This interpreter can be obtained either in source code form (written in C) or as a Linux binary. Lots of documentation about the language can be found at the Self Project pages at Sun.
[http://www.lsi.usp.br/~jecel/tiny.html]
[http://self.sunlabs.com/]
semidefinite programming (SDP): A generalization of linear programming in which a linear function is minimized subject to the constraint that an affine combination of symmetric matrices is positive semidefinite (whence the name) or, in slightly more common terms, a generalization of linear programming to the space of block diagonal, symmetric, positive semidefinite matrices. The main routine implements a primal-dual Mehrotra Thus SDP unifies several standard problems (e.g. linear and quadratic programming) and has many applications in science and engineering. Semidefinite programs are more general than linear programs yet just as easy to solve.
Resources can be found at the SDP pages of Farid Alizadeh, Christoph Helmberg, and the research group of Stephen P. Boyd. Available semidefinite programming packages include CSDP, INCT, LMITOOL, MAXDET, SDPA, SDPpack, SDPSOL, and SP. See Vandenberghe and Boyd (1996) for a review of the method.
SEMO: An object-oriented spectral element solver for the Poisson equation written using Fortran 90. The aim of this program was to set up a programming model for numerical computing while taking benefit of the object-oriented programming features in Fortran 90.
[http://imhefwww.epfl.ch/lmf/software/semo.html]
sendmail: A mail transport agent (MTA) which implements a general purpose internetwork mail routing facility under UNIX. It can handle several transport protocols and can do a limited amount of message header editing to put a message into a format appropriate for the receiving domain. Sendmail is designed to run without the need for monitoring but has a number of features that can be used to monitor or adjust its operation.
The programs comprising the distribution include:

sendmail, the transport agent which sends a message to one or more recipients by routing the message over whatever networks are necessary;

mailq, which prints a summary of the mail messages queued for future delivery;

mail.local, which stores mail in a mailbox;

mailstats, which displays the current mail statistics;

makemap, which creates the database maps used by the keyed map lookups in sendmail;

newaliases, which rebuilds the database for the mail aliases file;

praliases, which displays the current system aliases;

rmail, which interprets incoming mail received via UUCP; and

smrsh, a restricted shell for sendmail intended as a replacement for sh for use in the prog mailer in sendmail configuration files.

The smrsh utility is not an official part of the sendmail distribution.
A source code distribution of sendmail is available as is a Linux ELF binary distribution. This is an extremely difficult program to install and configure and such things should only be attempted by UNIX masters or the criminally insane. An operations guide is included in the distribution as are man pages for each of the programs. See Costales and Allman (1997a) and Costales and Allman (1997b).
[http://www.sendmail.org/]
[http://sunsite.unc.edu/pub/Linux/system/mail/mta/]
[http://www.harker.com/sendmail/sendmail-ref.html]
[http://www.muycool.org/sendmail/]

sendmail-cf

A fully complete, reasonably powerful, and reasonably generic sendmail configuration file whose features include:

compatibility with sendmail 8.7.x and older versions;

full usage of the DNS including handling MX records;

sends mail with the address userdomain rather than with the individual host name to allow a user to move among machines;

configurable to either deliver all mail itself of pass non-local mail to a relay host;

configurable to deliver local UUCP mail itself and to pass non-local mail to an Internet host for delivery;

usage of a pathalias router when delivering UUCP mail to enable maximum reachability;

handling domain changes by replacing all occurrences of the old domain name with the new one; and

handling of BITNET, DEC and UUCP pseudo-domains.

A source code distribution of this is available.
[http://www.harker.com/gen.sendmail.cf/]
Sentry: A security program designed to detect and respond to port scans against a target host in real time. The features of Sentry include:

running on TCP and UDP sockets to detect port scans (and capable of simultaneously running on multiple sockets);

detection of SYN/half-open and FIN stealth scans;

reacting to a port scan attempt by blocking the host in real-time via configured options;

an internal state engine that remembers previously connected hosts which allows the setting of a trigger value to prevent false alarms and detection of random port probing; and

reporting of the details of all violations via email.

A source code version is available which is configured for several systems including Linux.
[http://www.psionic.com/abacus/portsentry/]
SEPlib: The Stanford Exploration Project library is a complete and freely redistributable seismic data processing software package. The package consists of a collection of seismic processing routines, a graphics library called Vplot, and I/O subroutine library, and preprocessors for Fortran code. The entire package has also been created using a data base concept called a data cube where data is assumed to be regularly sampled in all dimensions, although support for irregularly sampled data has also been added.
The source code for the SEPlib package is available. It is written in Fortran and C and has been tested on Sun SunOS and Solaris, HP-UX, SGI IRIX, IBM RS/6000, Linux Intel, and CM-5 platforms. The documentation includes a 40 page tutorial introduction in PostScript format as well as extensive man pages for the 100+ programs that comprise the package.
[http://sepwww.stanford.edu/software/seplib/]
SEPP: A software application installation, sharing and packaging solution for large, decentrally managed UNIX environments. The basic components of SEPP include:

installation of every software package in a separate subdirectory to provide clean encapsulation of all files for a given package;

a special SEPP directory for each package which holds files describing the package and a startup wrapper script;

a wrapper script which prepares the environment for successful execution of the binaries in the package, i.e. the script is executed instead of directly executing the program;

making the binaries available via symbolic links in a /usr/sepp/bin directory;

stub scripts written in Perl to which the /usr/sepp/bin links point, and which in turn use the startup wrapper scripts to actually run the programs;

package names created from the package name, version and a string that is shorthand for the name of the package maintainer.

SEPP user features include:

no changes to user configuration files are necessary;

documentation about all available packages is provided via a local Web site; and

support for the installation of several concurrent versions of the same program.

Features for managers include:

no special daemon processes or root privileges are needed;

a script called seppadm simplifies the maintenance of SEPP packages by setting up skeleton installation trees for new packages, removing old packages, and checking for name clashes;

an automounter that mounts all package directories below /usr/pack so the physical location of the package directory is irrelevant;

a catalog file listing all packages stored locally, their NFS pathname, and a short description;

specifying a list of other packages required for the installation of a new one;

automatic logging of application usage via the wrapper scripts; and

automatic adjustment of configuration files for local environments.

The SEPP distribution consists of a base package and a binary package, the latter of which are available for a wide range of UNIX platforms. A user's guide is available in PDF format.
[http://www.sepp.ee.ethz.ch/]
Sequin: A program designed to aid in the submission of sequences to the GenBank, EMBL, and DDBJ sequence databases. It is capable of handling simple submissions which contain a single short mRNA sequence, and complex submissions containing long sequences, multiple annotations, segmented sets of DNA, or phylogenetic and population studies. General information about the submitters and the sequence is entered into Sequin on a pair of introductory forms. The user is prompted to import the nucleotide and any associated amino acid sequences into the program. From this basic data, Sequin prepares a window containing the initial database record. Many additional forms, which provide space for adding new or modifying existing annotations, are accessible from this window.
Sequin automatically performs a number of functions including obtaining the proper genetic code from the name of the organism, and automatically determines coding region intervals on the nucleotide sequence by back-translation of the protein sequence. A number of powerful sequence annotation tools have been integrated into Sequin including:

a Repeat Finder which searches for repeated sequences, such as Alu sequences, in human DNA sequence submissions;

an ORF Finder identifies open reading frames within the sequence; and

a Sequence Editor, which together with the ORF Finder can annotate new coding sequences on the record and also also allows basic editing and translation of nucleotide sequences.

A source code distribution of Sequin is available as are binaries for several platforms including Linux Intel. Documentation is available as online help when the program is used and also in HTML format.
[http://www.ncbi.nlm.nih.gov/Sequin/]
SESAME: The Secure European System for Applications in a Multi-vendor Environment is a system offering sophisticated single sign-on with added distributed access control features and cryptographic protection of interchanged data. SESAME is a construction kit which is a set of security infrastructure components for product developers. The major functional features are: use of the Generic Security Service API (GSS-API), password authentication, public key authentication, distributed access control using signed Privilege Attribute Certificates (PAC) with optional delegation of access rights, full cryptographic protection of exchanges between users and remote applications, and cryptographic key distribution using both symmetric and asymmetric techniques.
A source code distribution of SESAME is available. An enormous amount of documentation is available in both ASCII and PostScript format. The January 1998 issue of the Linux Journal contains an introductory article about the use of SESAME.
[http://www.esat.kuleuven.ac.be/cosic/sesame]
SETIhome: A program that analyzes data captured by radio telescopes for signs of extraterrestrial intelligence. It runs as a screensaver, starting when you leave your computer and stopping when you return. Various modes that display results while it is running can be selected. The source code for the SETIhome client is available.
[http://setiathome.ssl.berkeley.edu/]
setserial: A program for setting and or reporting the configuration information associated with a serial port. This includes which I/O port and IRQ are being used by a particular serial port as well as whether or not the break key should be interpreted as the Secure Attention key. This is needed to either change COM ports 1 through 4 to a nonstandard configuration or to initialize additional serial ports (since ports 1 through 4 or the only ones initialized during the normal booting process). A source code distribution is available. This can also be obtained as part of the util-linux collection of programs.
[ftp://tsx-11.mit.edu/pub/linux/sources/sbin/]
SEVAS: An efficient Fortran implementation of an algorithm for the eigenvalue allocation (pole placement) problem of single-input linear systems using state feedback. This implementation uses the BLAS subroutines whenever possible. This is TOMS algorithm 718 and is documented in Miminis and Reid (1993).
[http://www.acm.org/calgo/contents/]
[http://www.netlib.org/toms/index.html]
SEW: The System Engineer's Workbench is a distributed real-time analysis tool intended to assist academic researchers in both teaching and algorithm development. It implements a formal framewo.rk for describing real-time computing systems that enables the design and analysis of large-scale, distributed, heterogeneous real-time systems to ensure that all application timing requirements are met. The features of SEW include:

a hierarchical architecture and target platform models;

separation of application from target platform at the architecture and component levels;

separation of application software from target platform (OS) software;

separation of software from hardware, with scaling provided by a hardware-specific sizing function;

a graph-based description of service time including loops and branches contrlled by scenario parameters;

optional statistical service time descriptions;

use of C++ mathematical expressions which are evaluated at run-time;

ASCII file formats and the supplied parser allow hand-generated, UI-generated or otherwise generated input data;

a small library of common OSs with data based on measured phenomena;

a small library of common communication hardware and protocols;

modeling of systems and communications hardware via part definition files describing scheduling phenomena and hardware/software-specific attributes;

a GUI based on Tcl/Tk; and

implementations of busy-period analysis (LSD and HKL), response-time analysis, busy-period and resond-time simulations for stochastic systems, distributed pipeline scheduling, and end-to-end simulation.

A source code distribution of SEW is available. It is based on the STL and uses Tcl/Tk (8.0.5) and Tix (4.1.0) for the GUI. It also uses PCCTS to create its parsers and GTL to implement its underlying graph structures, with the source code both both of these included in the distribution. This was developed under Linux using egcs 1.1.2 and libc5, and should be compilable on those and later versions.
[http://home1.gte.net/kevinb1/SEW/SEW.html]
Seyon: A full-featured telecommunications package for X11 whose features include:

a dialing directory supporting an unlimited number of entries with call progress monitoring, dial timeout, automatic redial, multi-number dialing, and circular radial queue;

configuration of each directory item with its own baud rate, bit mask and script file;

a terminal emulation window supporting the DEC VT02, Tektronix 4014 and ANSI;

availability of all xterm functionality (e.g. a scroll-back buffer, cut and paste, and a visual bell) through the terminal emulation window;

a scripting language similar to sh with a few additions;

an unlimited number of slots for external file transfer protocols;

specification of multiple download directories for the different transfer slots;

support for zmodem auto-download;

several translation modes for user input, e.g. backspace to delete, newline to carriage return and meta-key translation;

interactive setting of program parameters;

software (XONN/XOFF) and hardware (RTS/CTS) flow control;

session capture to a file; and

temporary running of a local shell in the terminal emulation window.

Seyon originated with the xcomm 2.2 program. A source code distribution is available which is documented chiefly in an extensive man page.
[ftp://sipb.mit.edu/pub/seyon/]
SFgate: A gateway between the Web and WAIS written in Perl. This is specially suited to use with freeWAIS-sf since it supports all of its extensions, but it can be used with all servers that use the WAIS protocol. SFgate is a CGI script that can be used with HTTP servers. The features include:

freeWAIS-sf fields as input fields in HTML forms;

parallel querying of any number of WAIS servers;

high efficiency local searches for WAIS databases on the same host;

conversion of results into various formats, e.g. conversion of references into BibTeX format;

support for multiple languages;

configurability of the appearance of search results;

handling of heterogeneous databases; and

parallel processing of search requests on different databases.

A source code distribution of SFgate is available. It is written in Perl and includes a user's guide available in HTML and PostScript format.
[http://ls6-www.cs.uni-dortmund.de/ir/projects/SFgate/]
SFI Director: A system administration tool for distributed, heterogeneous UNIX networks. This GUI menu interface to basic administrative functions embodies a concept for managing systems in concert. The functionality is divided into six key areas:

A system configuration area wherein:

system behavior is defined according to organizational needs;

system files, directories, links, etc. are automatically configured;

standard applications are installed;

various other customizations are performed; and

configurations are updated from a server.

A domain management area wherein:

NIS and NIS+ are managed (with NIS+ used effectively);

adminstration is decentralized;

domains are consolidated;

name services are migrated; and

domains are defined by example.

A system documentation area wherein:

data is collected from various hosts (e.g. NFS mounts, disk capacity, users, security files, etc.);

data is collected from servers;

data in installed applications is checked;

network data is collected;

collected data is presented in dynamically produced HTML; and

the SFI Director system itself is fully documented.

An application distribution area wherein:

which hosts will receive which applications is defined;

applications are automatically installed on the appropriate hosts;

hosts are automatically configured for all applications they will receive;

license servers are installed on appropriate hosts;

automounter maps are automatically generated to dynamically select from redundant servers;

unsuccessful installations are retried; and

HTML documentation is generated about installed applications.

A user management area wherein:

users can be defined in different classes;

home directories are created and corresponding class templates installed;

all needed name service tables are updated; and

the credentials are created when NIS+ is used.

A graphical user interface area wherein:

all importation functions are supported;

the GUI is closely integrated with the shell;

the menu structure is dynamically built;

the GUI is easily extensible; and

the menu structure and all commands have easily accessible and full documentation.

A distribution which will work on nearly all currently available major UNIX platforms is available as Open Source code. There are massive amounts of documentation about all parts of the system available mostly in HTML format.
[http://www.sfi-director.org/]
Sfio: The Safe Fast I/O library is a portable library for performing stream I/O which provides similar functionality to the ANSI C standard I/O functions collectively known as Stdio. Sfio is generally faster and more robust than most Stdio implementations and also introduces a number of new concepts beyond Stdio I/O processing. These concepts include:

automatic stream locking to avoid concurrent accesses to the same stream;

I/O disciplines to pre/post-process read/write data from/to a stream;

stream stacking for recursive processing of nested streams;

stream pooling for automatic stream synchronization when I/O operations are performed on different streams;

buffer reservation for safe access to the internal buffer of all streams;

the safe reading of variable-sized records; and

extensible printf/scanf-like formatting I/O operations.

Sfio provides two Stdio emulation package for backward compatibility, i.e. a stdio.h provided by Sfio and a libstdio.a library which emulates Stdio functions.
The source code for Sfio is available and has been ported to all known UNIX platforms. The package is documented in an extensive man page.
[http://www.research.att.com/sw/tools/sfio/]
SFL: The Standard Function Library is a portable function library for C/C++ programs. SFL was designed for portability (by encapsulating non-portable aspects), building servers (i.e. programs which run in the background for a long time without intervention), and functionality. It provides nearly 250 functions which cover:

compression, encryption and encoding;

datatype conversion and formatting;

dates, times and calendars;

directory and environment access;

user and process groups;

inverted bitmap indices;

symbol tables;

error message and configuration files;

string manipulation and searching;

file and Internet socket access;

Internet programming, e.g. MIME and CGI;

server (i.e. batch) programming; and

program tracing.

A source code distribution of SFL is available. It is written in ANSI C and has been ported to MS-DOS, Windows, and most UNIX systems including Linux. It comes with the complete source code as well as with extensive documentation in HTML format.
[http://www.imatix.com/html/sfl/index.htm]
sfmm: A group of Fortran routines from Forsythe et al. (1993) for performing various common numerical tasks. The routines include:

decomp, which decomposes a matrix using Gaussian elimination and estimates the condition of the matrix;

SOLVE, which solves a linear system Ax = b;

QUANC8, which estimates the integral of a function in a finite interval (with user-supplied tolerance) using an automatic adaptive routine based on the 8-panel Newton-Cotes rule;

RKF45, a Fehlberg fourth-fifth order Runge-Kutta method;

SPLINE, which computes the coefficients for a cubic interpolating spline;

SVD, which determines the singular value decomposition of a real rectangular matrix using Householder bidiagonalization and a variant of the QR algorithm;

FMIN, which determines an approximation to the point where a user function attains a minimum on an interval; and

ZEROIN, which finds a zero of a user function in an interval.

The source code for all of these routines is available. All are written in Fortran 77. They are documented in the indicated book.
[http://www.netlib.org/sfmm/]
sformat: A SCSI disk formatting utility which enables the formatting, partitioning, analysis and repair of SCSI disk drives. The features include:

a surface analyzer that will detect defective blocks,

a program that detects defective bearings,

a utility for easily generating a partition table,

a partition consistency checker, and

a large database of disks.

A source code distribution of sformat is available as is a Linux Intel binary. It is documented in a man page.
[ftp://ftp.fokus.gmd.de/pub/unix/sformat/]
SFS: The Speech Filing System provides a complete environment for conducting research into the nature of speech. It consists of software tools, file and data formats, subroutine libraries, graphics, standards, and special programming languages. It performs standard operations such as acquisition, replay, display, labelling, spectrographic and formant analysis, and fundamental frequency estimation.
SFS includes analysis programs for acquisition and replay, waveform processing, Laryngographic processing, fundamental frequency estimation (from SP or LX), formant frequency estimation, formant synthesis, spectrographic analysis, filterbank analysis and synthesis, resampling,, speed/pitch changing, annotation, spectral cross-sections, waveform envelope, filtering, signal editing, and signal alignment. The subroutine libraries support SFS file I/O and dynamic memory allocation for data sets, device-independent graphics, the standard format display of data sets, and various digital signal processing functions. The special purpose languages are:

Speech Measurement Language (SML), an interpreted language for measuring data in SFS files;

Speech Pascal (SPC), a compiled language for waveform manipulation and analysis; and

C-SPAN, a compiled language for synthetic speech stimuli generation.

A source code distribution of SFS is available. It is written in ANSI C and can be compiled and used on most UNIX flavors including Linux. The package is documented in a series of man pages.
[http://www.phon.ucl.ac.uk/resource/sfs/]
sFTP: A ncurses-based FTP client for Linux 2.0.
[http://enigma.xbill.org/sftp/]
SGF: The Structured Graph Format is an XML format for describing the structure of Web sites. Structured graphs are a mathematical formalism designed to support scalable browsing and the editing of large graphs. A Web site offering metadata in the form of an SGF description lets SGF-enabled clients analyze and process it for any purpose, e.g. a client application can read the metadata and dynamically generate a site map.
[http://www.oasis-open.org/cover/sgf.html]
[http://www.isl.hiroshima-u.ac.jp/projects/SGF/index.html]

SGViewer

A Java program that uses SGF metadata to create interactive site maps.
[http://www.isl.hiroshima-u.ac.jp/projects/SGF/sgviewer.htm]
SGLSS: A Fortran 77 package which solves systems of linear equations which may be overdetermined square and nonsigular or underdetermined. The package contains three routines:

SGLSS, with an easy calling for the general problem;

LLSIA, a more flexible routine for overdetermined systems; and

ULSIA, a more flexible routine for underdetermined systems.

A source code distribution of SGLSS is available. All 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/]
SGML: An international standard for document exchange which is the basis of the HTML Internet standard for Hypertext documents. SGML commands specify the structure rather than the appearance of a document, e.g. there is a command to delineate paragraphs but nothing to indicate the size of the paragraph or the font used to typeset it. A good place to start for information about SGML is A Gentle Introduction to SGML and and links to related software can be found at the Yahoo SGML Page The Oct. 1995 issue of the Linux Journal contains an article about Linuxdoc-SGML by Christian Schwartz (which has had its name changed to SGML-Tools). See Goldfarb (1991) and Maler and Andaloussi (1996).
Other SGML-related entries include:

CoST;

EasyDTD;

GELLMU;

Jade;

perlSGML;

PSGML;

Quilt, for transforming and formatting SGML/XML documents;

QWeb, a native SGML browser;

sdc, a system that aims to make SGML suitable for everyday use;

SGMLSpm, for parsing the output from the nsgmls parser;

SGML-Tools, a text formatting package based on SGML;

sgrep, a structured grep utility for searching text files based on structural criteria;

SP, an SGML parser and various utilities;

STIL, a style sheet language for building structure-controlled applications;

TEItools;

XML;

YASP.
sgmls: This has been superseded by nsgmls which is available as part of the SP package.
SGMLSpm: A Perl 5 class library for parsing the output from nsgmls.
[ftp://ftp.funet.fi/pub/languages/perl/CPAN/modules/by-module/SGMLS/]
SGML-Tools: A documentation system that can produce different formats from a single source. The source document is written in the markup language SGML and is translated, via the the use of a collection of programs, to LaTeX, Groff, texinfo, or (partially) HTML format. This used to be called Linuxdoc-SGML. The available tools include:

sgmlcheck, for checking SGML syntax;

sgml2txt, for creating plain text output;

sgml2latex, for creating LaTeX output;

sgml2html, for producing HTML output;

sgml2info, for creating GNU Texinfo output;

sgml2lyx, for creating Lyx output; and

sgml2rtf, for creating RTF output.

An improved version of this called SGML-PowerTools is available in the same directory.
[http://www.sgmltools.org/]
[http://sunsite.unc.edu/pub/Linux/utils/text/]
SGP: Sensory GraphPlan is a sound, complete planner based on Graphplan. It includes support for conditional effects, universal and existential quantification, uncertainty, sensing actions and uses the PDDL language syntax. A source code version of this Lisp program is available.
[http://www.cs.washington.edu/research/projects/ai/www/sgp.html]
sgrep: A tool for searching files for structured patterns and filtering text streams for structured criteria. It implements a query language based on a form of regular expressions called region expressions. Sgrep can be used to perform such tasks as removing all FONT tags from an HTML document, print out the TITLE elements from a set of HTML documents in which the string SGML is mentioned more than 12 times, extract the names of the senders from a set of mail files, and other reasonably complex operations on text files containing some kind of structured text. It has thus far been tested on SunOS, Linux, HP-UX and OSF1 Alpha platforms.
[http://www.cs.helsinki.fi/~jjaakkol/sgrep.html]
SGS: The Sequentielle Gaussche Simulation package contains programs for performing various geostatistical simulation tasks. It has a command-line interface, uses Gnuplot to display graphics, and is written in standard C. SGS can perform sequential Gauss simulation, simple and ordinary kriging, and kriging with local anisotropy. Other capabilities include computing autocorrelations and autocovariances of semivariograms. A source code distribution is available which can be compiled on most UNIX flavors. The interface and all documentation are written in German.
[http://zappa.mabb.tu-freiberg.de/~tonn/sgs.html]
[http://www.ai-geostats.org/software/Geostats_software/SGS.htm]
sh: The name usually given to the Bourne shell, the precursor to most modern UNIX shells. This was originally written by Steve Bourne at AT&T. It is the only shell guaranteed to be on any UNIX operating system, although on most Linux versions it is a symbolic link to bash, a superset of sh. A hypertext version of Bourne's original shell tutorial can be found as:

An Introduction to the UNIX Shell
[http://www.ling.helsinki.fi/users/reriksso/unix/shell.html]
Shadow: A suite of tools to aid in the implementation of shadow passwords. The available tools include:

chage, to change user password expiration information;

chfn, to change user name and information;

chpasswd, to update a password file in batch;

chsh, to change a login shell;

dpasswd, to change a dialup password;

faillog, to examine the faillog and set login failure limits;

groupadd, to create a new group;

groupdel, to delete a group;

groupmod, to modify a group;

groups, to display current group ID names;

grpck, to verify the integrity of group files;

id, to display current user and group ID names;

lastlog, to examine the lastlog file;

login, to begin a session on the system;

logoutd, to enforce login time restrictions;

mkpasswd, to update passwd and group database files;

newgrp, to change a group ID;

newusers, to update and create new users in batch;

passwd, to change a user password;

pwck, to verify the integrity of password files;

pwconv, to convert and update shadow password files;

pwunconv, to restore an old password file from the shadow password file;

su, to change user ID or become superuser;

sulogin, single user login;

useradd, create a new user or update default new user information;

userdel, delete a user account and related files; and

usermod, modify a user account.

A source code distribution of the Shadow tools is available. They are all written in C and a special makefile for Linux systems is supplied. All the programs are documented in man pages.
[http://sunsite.unc.edu/pub/Linux/system/admin/]
[ftp://ftp.ists.pwr.wroc.pl/pub/linux/shadow/]
Shadow Ina Box: A collection of several popular utilities which have been modified to provide shadow passwords. The utilities included in the package are: wu-ftpd, sudo, Shadow, adduser, CrackLib, xlockmore, xdm, Popper, IMAP, PCNFSD, and BWNFSD.
[http://sunsite.unc.edu/pub/Linux/system/admin/]
Shadow netWorkspace: SNS is a web-based work environment designed and developed specifically for use in K-12 schools to support schools and learning. The goal is to improve education by opening classroom and schoolhouse doors to the advanced information and communication services of the Internet. The SNS server is accessible via any computer with a connection to the Internet, supplying much of the functionality of a PC remotely. The key features of SNS include:

an online file system in which users can create, move and delete folders and files as well as search for files in their private, hierarchical filesystem;

groups that enable distribution, sharing and collaboration of file objects by members of learning communities;

administration features that allow users to change their information, password, school information, news, etc.;

integration of various Internet based applications including an editor, calculator, task manager and telnet;

a homework notifier that allows posting of homework and modification of existing homework;

a calendar for managing time and tasks; and

chat rooms and discussion forums.

This was designed and built on a Red Hat Linux platform using Perl, Apache, MySQL and sendmail.
[http://sns.internetschools.org/]
Shadows: A distributed programming paradigm and a class library which supports that paradigm for C++. The paradigm is one of potentially mobile objects which may belong to large-scale, long-lasting, independent but potentially interacting, applications. It has been designed without any reliance on centralized services on the principle that only those parts of a system which have chosen to be involved in some interaction should suffer the costs. Shadows enables the creation of distributed C++ applications as well as the upgrading of currently non-distributed C++ applications to distributed versions.
Shadows features include:

a flexible naming and lightweight location system;

distributed garbage collection;

the creation of multi-level caching hierarchies with cache consistency requirements specified on a per object basis if required;

support of object persistence (by reachability);

a crash recovery mechanism which allows the restoration of the environment of a distributed application with a minimum of user intervention;

classes which provide in-memory checkpointing and concurrency control; and

the capability of specifically enabling/disabling each feature at run-time.

The Shadows system, written in C++, has been designed to be highly portable and rely upon standard operating system functionality with system specifics hidden behind simple common interfaces. A UNIX-based single-threaded version is currently (4/97) available with a multi-threaded version under development. It has been ported to Sun Solaris and SunOS, and Linux Intel platforms. The software and a user's manual can be obtained via an email request. See Caughey et al. (1993).
[http://arjuna.ncl.ac.uk/Shadows/index.html]
ShadyBox: A drawing program for boxing and shading regular and irregular shaped segments of aligned multiple sequences which was designed for creating PostScript figures for publication.
[ftp://ftp.bio.indiana.edu/molbio/align/]
Shaman: A library providing functions for performing common C programming tasks. The Shaman package is designed to create a programming enviroment that is both portable and convenient to use. It is part of a larger project to build an object-oriented daemon-driven database management system.
Shaman is constructed as a set of packages containing programs for performing similar tasks. The currently (4/98) available packages include:

Foot, containing an absolute minimum of functions needed to abstract from the operating system, i.e. for writing programs without using #ifdef macro commands;

Alib, containing programs for initializing data structures, performing file and string operations, command line processing, and thread operations;

Uls, which provides a portable replacement for what are called resources in the X Window System;

Message, a set of message functions which allow a user to find out what is going on in a program;

Resource, a set of functions for obtaining anything a program can obtain, e.g. a memory chunk, an open file, a dynamically loaded module, a window, a database, etc.;

Shlist, which provides a type similar to Lisp lists;

Cache, a set of functions for maintaining associative arrays; and

Language, a set of functions for providing a uniform interface to whatever language interpreter is being used by the system.

Other packages are being constructed.
A source code distribution of Shaman is available. It is being developed on and works under Linux Intel and should be easily portable to other UNIX platforms. A sketchy user's manual is available.
[http://starling.rinet.ru/shaman/index.html]
Shapelib: A C API for reading and writing ArcView Shapefiles. Several example programs are contained in the distribution including:

dbfcreate, for creating .dbf files;

dbfadd, for adding a record to a .dbf file;

dbfdump, for displaying the contents of a .dbf file;

shpcreate, for creating a new .shp and .shx file;

shpadd, for adding a shape to an existing shape file;

shputils, for clipping and appending shapefiles; and

shptree, a quadtree algorithm for spatial searaches of shapefiles.

[http://gdal.velocet.ca/projects/shapelib/]
ShapeTools: A collection of programs which supports software configuration management in a UNIX environment. It consists of a set of version and attribute control commands and a configuration interpreter and built tool shape. The toolkit is integrated on top of a base abstraction called the Attributed File System (AtFS) which provides uniform access to immutable revisions of files stored in special archive files as well as to mutable regular UNIX files. AtFS supports multiple versions of files and associates an arbitrary number of application-defined attributes for each version. It comes in the form of a library meant to be an extension to the UNIX file system which doesn't require system modification and doesn't impose any restrictions on existing file system applications. The ShapeTools system is upward compatible with make and can handle conventional makefiles as well as its own shapefiles.
The ShapeTools version control system consists of UNIX commands for:

storage and retrieval of multiple versions of files;

a built-in status model for revisions whose states include busy, saved, proposed, published, accessed, and frozen;

documentation of change histories;

synchronization of concurrent updates to a history;

symbolic names as version number aliases;

a flexible version selection mechanism driven by general version binding rules;

a basic network user concept; and

full read and write access to user definable attributes.

The attribute mechanism supports genuine attributes where it is given statically, execution attributes where it is determined dynamically by executing a given program or shell script, file reference attributes where the file contents are taken as an attribute value, and version reference attributes where the value points to another version. The tasks performed by the shape program include identification of system components, component version selection, variant control, driving compilations, and recording configurations for later rebuilds for the software system being built. The package also includes a prototype release managment system which supports:

a fully automatic global release building mechanism with automatic release number generation;

automatic generation of prereleases as systematic preparation of releases;

construction of subsystem releases and prereleases;

system building and installation by either shape or make;

standard version selection rules;

a project-wide unified variant raster; and

built-in standard functions for cleaning up, generating tar or shar files, determining file dependencies, etc.

The ShapeTools system is available as source code. It is written in ANSI C which can be compiled and used on most UNIX variants. It is documented in a user's manual included in the distribution in PostScript format.
[http://swt.cs.tu-berlin.de/~shape/]
SHDOM: A program that computes unpolarized monochromatic or spectral band radiative transfer in 1-, 2-, or 3-D mediums for either collimated solar and/or thermal emission sources of radiation. The properties of the medium, e.g. the extinction, single scattering albedo, Legendre coefficients of the scattering phase function, temperature for a particular wavelength or spectral band, can be specified completely at each input grid point.
The SHDOM source code is written mostly in standard Fortran 77 with some extensions. Documentation is contained within an ASCII file containing details on how to run the model as well as in a PostScript file containing details about the algorithms used.
[http://nit.colorado.edu/~evans/shdom.html]
SHELF: An extension of the ELF programming language for creating visual applications. The features include:

a macro language that is memory safe and portable;

a library of thousands of high- and low-level functions;

a sophisticated graphical design and test facility called Builder that allows applications to be rapidly constructed and debugged;

a drag-and-drop dialog box designer that generates an object-oriented ELF framework for the final application;

extensibility that allolws adding new classes and methods;

a graphical source debugger;

support for multiple user projects;

a Palm Pilot application; and

a StockTracker application.

A source code distribution is available under the GPL.
[http://www.applixware.org/]
shell: A shell is a text-based command interpreter that manages your interaction with the kernel of a UNIX system (although some newer shells are in fact wrapped in GUIs). The shell reads and processes commands entered at the keyboard. It also provides a limited programming language for writing programs called shell scripts or procedures, used mostly for writing short programs that combine often-used commands. It is usually recommended that the use of the shell in such a manner be limited to small- or at most medium-sized programs, with more appropriate and full-featured languages used for larger projects (although as newer shells are created with progressively more features this limitation is waning). The equivalents in the WinDOS world are command processors such as COMMAND.COM or CMD.EXE, although these are usually overlooked in favor of ostensibly easier point-and-click solutions.
Perhaps the most concise and thorough introduction to shells can be found in the preface of Steve Bourne's original tutorial for sh, the precursor to most shells in use today:
The shell is a command programming language that provides an interface to the UNIX operating system. Its features include control-flow primitives, parameter passing, variables and string substition. Constructs such as while, if then else, case and for are available. Two-way communication is possible between the shell and commands. String-valued parameters, typically file names or flags, may be passed to a command. A return code is set by commands that may be used to determine control-flow, and the standard output from a command may be used as shell input.

The shell can modify the environment in which commands run. Input and output can be redirected to files, and processes that communicate through pipes can be invoked. Commands are found by searching directories in the file system in a sequence that can be defined by the user. Commands can be read either from the terminal or from a file, which allows command procedures to be stored for later use.

For further information see Anderson (1986), Arthur (1994), Kochan and Wood (1990), Quigley (1997) and Tansley (2000).
Available shell and related programs include:

ash, a lightweight clone of sh;

bash, the Bourne Again SHell that's the default on most Linux systems;

ccsh, a scripting language designed to be powerful and easy to use for those familiar with C and to run much faster than interpreted shells

clsh, a cluster shell command;

csh, a mostly unrecommended shell designed to have a syntax similar to that of C;

es, an extensible shell combining the capabilities of functional languages with those of shells;

esh, a simple and lightweight shell with a Lisp-like syntax;

Gsh, a graphical shell that behaves like a normal terminal window with some graphics enhancements;

ksh, designed to provide the functionality of csh with sh syntax as well as backward compatibility with the latter;

lsh, a little shell lacking many features of conventional shells but with a reasonably comprehensive set of built-in commands;

NetShell, an interface for handling Web information is a manner similar to how regular shells handle local information;

Osh, a setuid root, security enhanced, restricted shell that allows limiting access to special commands and files to specific users;

Pash, a full-screen shell resembling Norton Commander for DOS;

pdksh, a public domain version of the Korn shell that also includes some bash features;

Perl Shell, merges an interactive shell with the capabilities of Perl;

PUSE, a set of ksh login command scripts and a set of nearly 80 ksh, Perl and Expect scripts for performing various tasks;

rc, the AT&T Plan 9 shell ported to UNIX;

sh, the Bourne shell, i.e. the precursor to most other shells that's found on all UNIX systems;

sqsh, a replacement for the isql program developed by Sybase for working with their SQL databases;

tcsh, an attempt to improve on the flawed sh;

Tksh, an implementation of the Tcl C library on top of ksh93;

tkWorld, a GUI front-end to the UNIX shell written using Tcl/Tk;

zsh, designed for use interactively and as a scripting language, combining features from bash, ksh and tcsh along with several new features.

Useful shell Web sites include:

Shell FAQs
[ftp://rtfm.mit.edu/pub/usenet/news.answers/unix-faq/shell/]

Open Source Shells Webliography
[http://www.softpanorama.org/Links/shells.html]

SHELLdorado
[http://www.oase-shareware.org/shell/]

Shells and Shell Programming
[http://www.pageplus.com/~hsf/libraries/computing/unix/shell.shtml]

Online documentation includes:

UNIX Shell Programming Bourne and Korn Shells
[http://goanna.cs.rmit.edu.au/~steveh/tns/shell/shell.html]

Writing UNIX Scripts
[http://osiris.sund.ac.uk/ahu/comm57/script.html]

UNIX Shell Programming
[http://www.torget.se/users/d/Devlin/shell/intro.html]

UNIX Shell Scripting
[http://linux.ucs.indiana.edu/edcert/session3/shell/]

Shell Script Programming
[http://www.csd.uu.se/~matkin/documents/shell/]

UNIX Shell Patterns
[http://c2.com/cgi/wiki?UnixShellPatterns]

Shell Command Language Index
[http://www.opengroup.org/onlinepubs/7908799/xcu/shellix.html]
sherpa: A system security configuration tool that inventories basic filesystem security (e.g. permissions, file ownership, etc.) and creates a report. It can also be used as a remedial tool for changing file permissions and ownership according to a configuration file. The specific capabilities include:

scanning system configuration files for common problems;

scanning file system permissions and ownership bit including SUID/SGID bits;

inventory of world-writable files and directories;

generation of reports in ASCII or HTML and/or logs of scanning results;

period execution via cron; and

optional automatic fixing of permission or ownership problems.

[http://rcrelia.hypermart.net/sherpa/]
SHIFT: A special-purpose, object-oriented programming language designed to simulate large dynamical systems which bridges the gap between system and control theory, formal methods, and programming languages for a focused yet large class of applications. It is used for describing dynamic networks of hybrid automata which consist of components which can be created, interconnected, and destroyed as the system evolves. Components exhibit hybrid behavior consisting of continuous-time phases separated by discrete-event transitions. They may evolve independently or interact via their inputs, outputs, and exported events, and the interaction network itself may also evolve. This language model was motivated by a need for a tool supporting dynamically reconfigurable hybrid systems such as the specification and analysis of different designs for the automatic control of vehicles and highway systems.
An implementation of the SHIFT language is available in both source code and binary formats, with a binary distribution being available for only Sun Solaris platforms. The distribution contains:

a compiler shic which takes a SHIFT source code file and produces a C code file which can be compiled;

a command line debugger which allows you to inspect the entities in a SHIFT program a run time;

a Tcl/Tk-based graphical environment which makes it easier to run and visualize systems and to debug SHIFT programs;

various accessory libraries and include files; and

extensive documentation.

The documentation includes a user's manual as well as several technical reports in PostScript format. Compilation and use of SHIFT also require the BLT extension library.
[http://www.path.berkeley.edu/shift/]
SHORE: The Sscalable Heterogeneous Object Repository is a project to design, implement, and evaluate a persistent object system which will serve the needs of a wide variety of target database applications including hardware and software CAD systems, persistent programming language, geographic information systems (GIS), satellite data repositories, and multimedia applications. This project expands upon the earlier EXODUS storage manager project by adding support for typed objects, multiple programming languages, a UNIX-like hierarchical name space for named objects, and a UNIX-compatible interface to objects with a text field. This interface is intended to ease the transition of applications from the UNIX file system environment to SHORE since existing tools such as vi will be able to store their data in SHORE objects without modification (i.e. a UNIX file becomes either a single SHORE object or the text field of a more complex object.
The three major goals of SHORE are scalability, support for hardware and language heterogeneity, and support for existing file-based applications. It attains scalability via the use of a symmetric, peer-to-peer distributed architecture in which every participating processor runs a SHORE server process whether or not it has SHORE data disks attached. It can run on a single processor, a network of workstations, or a large parallel processing machine. The notion of a value-added server also aids in this goal by structuring the software that runs in the server with extensibility in mind such that it is relatively easy to build application-specific servers. The second goal is facilitated by the fact that objects in SHORE are typed and it provides a single, language-neutral type system which is used to defined the types of all SHORE objects (called the SHORE Data Language). This simplifies the task of supporting heterogeneous hardware and makes it feasible to support access to persistent objects from multiple programming languages. The provision of a flexible, tree-structured, UNIX-like name space in which all persistent objects are reachable supports the third goal of supporting existing applications. This is also aided by the provision of a standard UNIX-compatible file system interface as well as the capability of designating one SHORE object type as being the object's ``UNIX data.''
The SHORE source code distribution is available and can be compiled and installed with gcc, Perl 5, and Tcl/Tk. A set of Linux patches are available at the SHORE home site. The documentation includes an overview, an installation manual, a language reference manual, a tutorial, and several other documents available in both HTML and PostScript format.
[http://www.cs.wisc.edu/shore/]
[http://www.geog.psu.edu/~qian/shore_linux.html]
shorten: A program for lossless and near-lossless audio compression. A simple predictive model of the waveform is used followed by Huffman coding of the prediction results. This method is fast and near optimal for many commonly occuring waveform signals.
[http://www.softsound.com/Shorten.html]
[http://www.hornig.net/files/shorten/olinux/source/]

shnutils

A set of three Perl scripts for assisting in the process of using shorten to trade digital music. The scripts are:

ripshn, compresses a directory of WAV files, calculates the MD5 hash for each, and writes the *.MD5 file;

md5check, validates the MD5 hash of a directory of *.MD5 files; and

un-shn, extracts a directory of .SHN files and creates the corresponding cdrdao TOC file.

[http://www.cs.orst.edu/~ritchie/shn/]
SHPF: A public domain HPF 2.0 compilation system. The SHPF package contains a translator called ADAPT and a runtime library called ADLIB. ADAPT transforms an HPF program into a Fortran 90 program that runs on each processor of the target computer or computer network. The program generated is standard Fortran 90 and is compiled by a suitable compiler for the target machine. Nonlocal data is accessed by calling communications routines from the ADLIB library. The communications routines are implemented using MPI.
SHPF accepts HPF 2.0 in both free and fixed form, with a few restrictions. It recognizes full HPF including full Fortran 90 and gives error messages when it encounters unsupported features. It was developed to fully implement the data mapping features of HPF, and as such it supports alignments of any complexity, all distribution formats, any number of data and processor array dimensions, multiple processor arrays, distributed data in any context including subscripts, any number of levels of indirect addressing, passing array sections as procedure arguments, and redistribution across procedure boundaries. The ADLIB runtime library is a C++ class library with communications implemented in MPI. In addition to providing HPF runtime support, it can also be used directly for distributed data parallel programming in C++.
A source code distribution of SHPF is available. The requirements for compilation and use are a C compiler for ADAPT, a C++ compiler for ADLIB, a Fortran 90 compiler for the translated programs, and an implementation of MPI for the communications routines. A user's guide and several technical reports are available as documentation.
[http://www.vcpc.univie.ac.at/information/software/shpf/]
shtool: The compilation of several small, stable and portable shell scripts into a single shell tool. It was developed and has been used inside the source tree of Open Source packages, where it accomplishes various tasks related to the building and installation of such packages. The commands provide within shtool include:

echo, a style print command providing special expansion constructs, e.g. terminal bold mode, environment details, date, as well as newline control;

table, pretty prints a field-separated list as a table;

prop, displays a processing indication via a running propellor;

move, for renaming/moving multiple files at once;

install, for installing a program, script or data file in a portable way;

mkdir, provides support for auto-parent-dir creation, directory permission control, and smart skipping when the directory already exists;

mkln, provides automatic calculation of and usage of relative links when possible;

mkshadow, creates a shadow source tree via symbolic links;

fixperm, fixes file permissions inside a source tree by cleaning up the permission bits;

guessos, an operating system and platform architecture guesser for determing the GNU platform-triple style ID string;

arx, an archive wrapper command;

slo, separates linker options by library class;

version, generates and maintains a version information file in either text, C or Perl format; and

path, deals with shell $PATH variables.

[http://www.gnu.org/software/shtool/]
S-HTTP: The Secure HyperText Transfer Protocol is a secure, message-oriented communications protocol designed for use with HTTP in that is can coexist with the latter's messaging model and is easily integrated with existing HTTP application. S-HTTP provides a variety of security mechanisms to HTTP clients and servers to provide the security service options needed for a wide range of uses on the Web.
[http://www.ietf.org/ids.by.wg/wts.html]
sh-utils/shellutils: A collection of small shell programming utilities. The sh-utils collection includes:

basename, to strip directory and suffix from filenames;

date, to print or set the system date and time;

dirname, to strip non-directory suffixes from filenames;

echo, to display a line of text;

env, to run a program in a modified environment;

expr, to evaluate expressions;

false, to do nothing unsuccessfully;

groups, to print the groups a user is in;

hostname, to show or set the system's host name;

id, to print real and effective UIDs and GIDs;

logname, to print a user's login name;

nice, to run a program with a modified scheduling priority;

nohup, to run a command such that it is immune from hangups with output directed to a non-tty device;

pathchk, to check whether filenames are valid or portable;

printenv, to print all or part of the user's environment;

printf, to format and print data;

pwd, to print the name of the current, working directory;

sleep, to delay for a specified amount of time;

stty, to change and print terminal line settings;

tee, to read from standard input and write to standard output and files;

test, to check file types and compare values;

true, to do nothing successfully;

tty, to print the filename of the terminal connected to standard input;

uname, to print system information;

users, to print the user names of users currently logged in to the current host;

who, to show who is logged in;

whoami, to print the effective userid; and

yes, to repeatedly output a string until killed.

The uname, nice, nohup, and stty utilities can only be built and installed on systems which have the features to support them.
A source code distribution of sh-utils is available. The programs are written in portable C and can be compiled and used on most UNIX platforms. The collection is documented in a 43 page manual in Texinfo format as well as in separate man pages. See smallutils for an alternative to a few of these.
[http://sunsite.unc.edu/pub/Linux/system/misc/]
SHYSTER: A case-based legal expert system that provides advice in areas of case law that have been specified by a legal expert using a specially developed specification language. It was implemented in a UNIX environment and the distribution consists of of a dozen modules written in C and a set of test case law specifications. The modules comprising the system are:

Shyster, the top-level module for the whole system;

Statutes, the top-level module for a rule-based system (not yet implemented);

Cases, the top-level module for the case-based system;

Tokenizer, tokenizes a program written in the system's law specification language;

Parser, parses a program written in the law specification language using the tokens generated by Tokenizer;

Dumper, displays the parsed information;

Checker, checks for evidence of dependence between attributes;

Scales, determines the weight of each attribute;

Adjuster, allows a legal expert to adjust those weights;

Consultant, interrogates the user about the attribute values in the instant case;

Odometer, determines the distance between the instant case and each leading case; and

Reporter, writes the legal opinion in LaTeX format.

A source code distribution of the system is available. The code is detailed in a technical report and the system explained in Popple (1996).
[http://cs.anu.edu.au/software/shyster/]
SIA: A integrated package for performing tasks commonly encountered in seismic processing and data analysis. The system includes a unified scripting language, a powerful job monitor, and extensive libraries that make it easy to develop new tools to add to the over 130 specialized data management, processing, and analysis tools already included. The features include:

generic support for complex, structured 2- and 3-D seismic data sets;

great flexibility in data manipulation;

several data types including variable length and sample interval records, relational database tables, several kinds of velocity models, graphical images, and user-specified arbitrary data types;

integration of several types of existing seismic, mapping, modeling, inversion and other software including a GMT interface, tools for use with rayinvr, and an interface to the SU package;

an extensive collectin of original seismic algorithms including multicomponent seismic attribute extraction, high resolution velocity analysis, separation of P and SV waves, statistical coherence measures, velocity and attenuation tomography, sensitivity testing of ray-tracing velocity models, and travel-time inversion using genetic algorithms;

a powerful job description or scripting language; and

diagnostic tools.

A source code version is available via a request to the author. It is written in C and Fortran and set up to be compiled on a Sun platform although I can't see any difficulties in compiling on a Linux box. A user's manual is included with the package. See Morozov and Smithson (1997).
[http://zephyr.rice.edu/department/staff/morozov/sia/]
SIAG: Scheme In A Grid is a spreadsheet written using the X Window System and Scheme. The features of SIAG include:

a form interface for creating dialogs,

embedding documents from one program into another;

support for multiple interpreters including SIOD, Guile, Tcl, and C;

drag and drop as defined by the DND protocol;

support for string handling;

several file formats including native SIAG, comma separated values, plain text, PostScript, and HTML tables;

using external programs to load and store data;

extensive mouse selection functionality;

several ways in which to store cell values including integer, scientific, percent, hex, etc.;

a web server that can serve the current document as an HTML table over the Internet to a browser,

a file manager and a mailer; and

a user management utility.

A source code distribution of SIAG is available. This can be built with varying levels of complexity and functionality. The simplest version uses only SIAG and SIOD, although more functional versions with plotting, previewing, and various other capabilities also require the use of Chimera, Ghostview, and Gnuplot. The basic version uses the vanilla Xaw widget set, although the Xaw3D widgets can be used for a 3-D look. Versions of all of these packages that have been modified by the See also the same author's Pathetic Writer and Egon Animator packages.
[http://siag.nu/siag/]
sidentd: An implementation of the Identification Protocol specified in RFC 1413. This is written in Perl and designed to be small and secure. It can only be used from inetd and users can set a fake ident reply for their UID.
[http://insecurity.net/]
[http://www.cit.nepean.uws.edu.au/pub/unix/security/identd/]
[http://www.ussrback.com/UNIX/utilities/]
sifi: The SInus FIrewall is a TCP/IP packet filter for Linux systems that can be used to, e.g. create and maintain firewalls. The features of sifi include:

filtering of all header fields in the IP, TCP, UDP, ICMP and IGMP packets;

intelligent RIP and FTP support;

easy to understand text-based configuration;

a graphical management interface for configuring several firewalls;

dynamic rules including counters and time-outs;

extensive logging, alerting and counter-intelligence; and

prevention of packet and address spoofing.

A source code distribution of sifi is available which requires a kernel version 2.0.34 or greater, ENskip and JDK 1.1.6 or greater. Documentation includes a FAQ and a user's guide.
[http://www.ifi.unizh.ch/ikm/SINUS/firewall/]
Sift-Mail: A toolkit for e-mailing sifting, i.e. searching, routing, and filtering. It includes an interpreter and an X Window interface for non-expert users. The overall goal of the project is to explore e-mail filtering technology and one of the goals during development was to have the user-interface work drive the overall design. Another goal was to create an architecture which could be used in a POP or IMAP environment. This goal hasn't yet been realized but led to the creation of Sift-Tcl, a set of extensions to Tcl which can be used to express the sifting rules rather than a configuration file. The Sift-Tcl interpreter can be executed on the server and it is also available as a library which can be included in other mail programs.
The Sift-Mail program is available in source code form. It is written in C and Tcl and thus requires the Tcl/Tk distribution for compilation. The programs are documented in man pages and in a technical report available in PostScript format.
[http://www.island-resort.com/sm.htm]
Sig++: A set of C++ classes for creating sound synthesis and filtering programs. The classes are grouped into sublibraries that organize classes with similar functions. These include:

sigBase, generic or common components;

sigSignal, for generation or filtering of floating-point sound signals;

sigControl, classes dealing with human/computer interaction with MIDI, the computer keyboard and monitor, and timing issues;

sigInfo, music information classes to assist in musical data conversion, analysis and performance; and

sigNet, neural network classes for experimentation in real-time human/computer interaction or in sound signal situations.

The package also contains independent library class sets including:

Sig, contains all classes in the library;

Improv, classes for real-time MIDI instrument and computer control; and

Museinfo, classes for musical information.

The latter two are separately available and described elsewhere.
[http://hummer.stanford.edu/sig/]
SILC: Secure Internet Live Conferencing is a protocol and implementation thereof providing secure Internet conferencing services over insecure channels. SILC cosmetically resembles IRC in that it provides conferencing services and has roughly the same command set, but differs tremendously in capabilities and internal details. The features include:

normal conferencing services such as private messages, channels, channel messages, etc., with all secured and authenticated;

no requirement for unique nicknames since unique Client, Server and Channel IDs assure that there are no collisions;

a secure key exchange and authentication protocol based on either passphrase or public key (RSA) authentication;

encryption of all traffic using the best available algorithms;

support for data compression via gzip;

module support for the loading of shared objects at runtime to allow the easy addition of extra features;

a client that can be installed by non-privileged users and which can be configured on a system-wide or user-specific basis.

[http://silc.pspt.fi/]
SILOON: The Scripting Interface Languages for Object-Oriented Numerics gives scientists the ability to rapidly prototype and solve problems on high performance parallel computers. It is an automated generator of glue code for making conventional and object-oriented class libraries available to programmers via popular scripting languages, e.g. Perl and Python. It provides toolkits and runtime support for building external interfaces to existing numerical codes, which enables scientists and other application programmers to easily access existing object-oriented scientific frameworks and numerical libraries written in C++, C and Fortran.
SILOON uses the EDG C++ compiler front-end to parse the C++ code for a library, an IL Converter to convert EDG output into an easily parseable format, and a library for building C++ programs that process C++ code called DUCTAPE. The latter uses the EDG compiler and IL Converter to provide convenient access to information about a C++ program including its types, functions, templates, macros, etc. A library code is parsed using these tools and then a set of C++ glue files is generated containing the function call interface to the library. This glue code is called by another layer of C doe which is called directly by the chosen scripting language. In the final step, the user libraries and SILOON object files are linked into a shared library that can be dynamically linked and used with a scripting language.
A source code distribution of SILOON is available. It has been ported to Linux Intel platforms using the egcs compiler and either Perl or Python as the scripting language. The documentation is a bit sketchy thus far (12/98).
[http://www.acl.lanl.gov/siloon/]
SIMATH: A computer algebra system focusing mainly on algebraic number theory. It consists of an interface, a programming language (C), the basic system (I/O, garbage collection, etc.), a multiple precision arithmetic package, a polynomial package, a matrix-vector package, an elliptic curves package, software libraries for user applications, and an interactive calculator called simcalc. There is also, unsurprisingly, a number theory package, the details of which can be found in the 120+ page user manual. SIMATH is written in C, but all of the library functions can also be used in Fortran programs by means of conversion routines that are part of the system. The source code is available and has been installed on Sun, HP, Apollo, SGI and Linux systems.
[http://emmy.math.uni-sb.de/~simath/]
[http://www.can.nl/SystemsOverview/Special/NumberTheory/SIMATH/]
SimCoupe: An emulator for the SAM Coupe computer for machines running DOS or UNIX/X11. It is written in C and based on a previous Zilog Z80 emulation program. The features include:

memory support for 512K and up to 4 Mb external memory,

graphics modes 1 to 4,

line interrupts with CLUT and VMPR changes supported,

VL-1772 disk controller emulation at the I/O level,

two disk drives supported using image files,

support for reading real SAM disks (under Linux),

SAM mouse support, and

a graphical user interface.

[http://www.inf.upol.cz/~keprta/sam/sim.html]
SIMEX: A collection of over 50 C++ classes which make it easier to build discrete-event micropopulation models. A micropopulation (as opposed to macropopulation) model is one in which a computer program is created based on the rules followed by individuals in a population and then used to simulate a population of many individuals which follow those rules. This contrasts to macropopulation models in which programs are developed based on rules on how entire populations change. SIMEX also provides some support for ODE models.
The C++ classes which comprise SIMEX are divided into six groups:

util, a group which includes basic data structures such as strings, ordered sets, etc.;

random, a group consisting of random number generators which support discrete distributions and in which each generator can be set up to generate from a particular distribution;

parammgr, which provides a barebones user interface for the parameters of a model (which can also be used with Tcl/Tk to provide a graphical interface);

simulation, which contains classes related to simulation scheduling and event management and which requires the separately available QuickThreads package;

statistics, a suite of classes for automatically gathering aggregate statistics during a simulation; and

tcl, which provides Tcl access to the core C++ classes in SIMEX.

The SIMEX source code is available. It is written in C++ using templates and pointers to member functions and thus requires g++ 2.7.0 or later. Compilation requires the QuickThreads package and, if a graphical interface is desired, the Tcl/Tk package. The package is documented in several papers and technical reports available in PostScript format as well as in several HTML documents available online.
[http://www.nmsr.labmed.umn.edu/nmsr/simex/]
SIMH: A package of emulators for the PDP-8, PDP-11, PDP-1, other 18b PDP, Nova, and IBM 1401 machines. A common command interface is used for each of the individual simulation programs. They are written in C and have been tested on VAX VMS, Alpha VMS, Alpha UNIX, FreeBSD Intel, and Linux Intel platforms, with a port to Windows NT/95 in progress. The SIMH package is documented in a text file included in the distribution. Binary versions of the 5th, 6th, and 7th UNIX editions for the PDP-11 are also available at the site as well as some software for the other machines.
[ftp://ftp.digital.com/pub/DEC/sim/sources/]
Similix: An autoproject, i.e. a self--applicable partial evaluator for a large, higher-order subset of Scheme. Similix treats source programs that use a limited class of side-effects and handles partially static data structures. It performs its function automatically and guarantees that the computations are never discarded or duplicated in the residual programs it generates. It is especially well-suited for use with interpreters that use environments represented as functions as well as for those writtein in continuation passing style. This conforms to the IEEE and R4RS Scheme standards and is known to be compatible with SCM. A source code distribution is available as is a user's manual in PostScript format.
[http://www.diku.dk/research-groups/topps/activities/similix.html]
SimOS: A complete machine simulation environment for the efficient and accurate study of uniprocessor and multiprocessor computer systems. SimOS simulates hardware in sufficient detail to boot and run commercial operating systems. It currently (12/98) simulates MIPS R4000/R10000 and Digital Alpha processors as well as caches, multiprocessor memory buses, disk drives, Ethernet, consoles and other devices commonly found on such machines. Operating systems ported to SimOS include IRIX 5.3 and 6.4, Digital UNIX, and (in the works) Alpha Linux.
The nifty features of SimOS include:

support for realistic workloads;

flexibility in the trade-off between the speed and detail of a simulation wherein fast simulation techniques are used to scan over the less interesting and time consuming parts of a workload;

the use of Tcl-based annotations to enhance the visibility and presentation of data; and

completely deterministic simulations wherein the same workloads will always lead to the same results.

Source and binary distributions of SimOS are available for several platforms including Linux Intel. Also available is a modified version of gdb that can communicate with SimOS. Documentation includes installation and user's guides.
[http://simos.stanford.edu/]
SimPack: A collection of C and C++ libraries and executable programs for computer simulation. Several different simulation algorithms are supported including discrete event, continuous, and combined simulation. The purpose of SimPack is to provide a set of utilities which illustrate the basics of building a working simulation from a model description. Special purpose simulation programming languages can be easily constructed using language translation software with the SimPack utilities acting as the assembly language. SimPack is designed to support simulation development of a wide variety of modeling types including: declarative models with an emphasis on state to state changes as found in finite state automata and Markov models; functional models which focus on function or procedure as in queueing networks, block models, and stochastic Petri nets; constraint models defined by differential and difference equations; and multimodels which are conglomerates of the other model types.
A source code distribution of SimPack is available. It is written in C and C++ and is compliant with the gcc compiler, and as such can be compiled and installed on most UNIX platforms with gcc installed. It is documented in a user's manual available in PostScript format. See Fishwick (1995). The is being superseded by MOOSE.
[http://www.cis.ufl.edu/~fishwick/simpack/simpack.html]
SimpleScalar: A tool set consisting of a compiler, assembler, linker, and simulation and visualization tools for the SimpleScalar architecture, which is derived from the MIPS architecture. The semantics of the instruction set are a superset of MIPS. SuperScalar allows the simulation of real programs on a range of modern processors and systems using fast execution-driven simulation. The simulators provided include a fast functional simulator as well as a detailed, out-of-order issue processor that supports non-blocking caches, speculative execution, and state of the art branch prediction. Many of these tools are ports of their GNU counterparts to the SimpleScalar architecture.
SimpleScalar can be easily ported to any 32-bit UNIX flavor, especially those that support POSIX-compliant system calls. It has been installed and built on several platforms including Linux Intel. The package is detailed in a technical report available in PostScript format.
[http://www.cs.wisc.edu/~mscalar/simplescalar.html]
SIMPLEX: A simulation environment containing a Model Description Language (MDL) and a graphical user interface. The site and all of the documentation are in German. Binary versions of this quite large package are available for IBM AIX, DEC Alpha, HP-UX, Sun SunOS and Solaris, and Linux Intel platforms. The compressed Linux package is 7.3 Mb to give some idea of the size of the package.
[http://www.or.uni-passau.de/english/3/simplex.php3]
SIMPRO: A crystallography program used to determine crystal structure from powder diffraction data. This has applications to several areas, especially the determination of the structure of high temperature superconductors. The SIMPRO package obtains structure and profile data from the powder pattern in one step by fitting the whole pattern with a function wherein the lattice constants are parameters for the peak positions, with additional variables being the profile and full width of half maximum parameters. The program can also refine the three components of the wave vector of an incommensurate or commensurate modulation as well as obtain the intensities of each reflection since the Lorentz polarization factors for different X-ray, neutron, and synchrotron powder diffractometers are built-in.
SIMPRO can use several profile shape functions including Gaussian, Lorentzian, the Edgeworth series, pseudo-Voigt, Pearson-VII, and double Gaussian. The built-in Lorentz polarization factors include those for:

a neutron diffractometer (Debye-Scherrer geometry),

Guinier transmission geometry (diffractometer),

Guinier reflection geometry (diffractometer),

Guinier transmission geometry (film),

a Bragg-Brentano diffractometer, and

the 3 axes diffractometer at a synchrotron source.

A source code distribution of SIMPRO is available. It is written in Fortran 77 and can be compiled using g77. The theory behind the program and its use are described in a user's manual available in PostScript format. See also SIMREF.
[http://www.uni-tuebingen.de/uni/pki/simref/simpro.html]
SIMREF: A Fortran program used in crystallography for SIMultaneous structure REFinement with multiple powder diffraction data sets and multiple phases per data set. Diffraction profiles calculated using a structural model are fitted to the corresponding observed diffraction profiles using the method of least squares in a procedure called the Rietveld method. This method enables several new evaluation techniques including:

simultaneously processing data from neutron and X-ray sources such that the advantages of each diffraction technique can be combined;

treating data measured in an experiment with several counters as multiple data sets to exploit the possibly different resolutions of the counters;

performing diffraction experiments at synchrotron sources using different wavelengths; and

performing diffraction experiments with varying time lengths for optimizing the detection of weak superlattice lines in certain small parameter ranges.

SIMREP also has options for calculating powder patterns and structure factors as well as generating reflection lists.
A source code distribution of SIMREF is available. It is written in Fortran 77 and can be compiled with g77. The theory behind the program and its use are described in a user's manual available in PostScript format. See also SIMPRO.
[http://www.uni-tuebingen.de/uni/pki/simref/simref.html]
Simula: The SIMUlation LAnguage is a programming language designed and built by Ole-Johan Dahl and Kristen Nygaard at the Norwegian Computing Center in Oslo between 1962 and 1967. It was originally designed for discrete event simulation but later expanded and reimplemented as a general purpose language. Simula introduced object-oriented concepts like classes and objects, inheritance, and dynamic binding. B. Stroustrop started with Simula as a motivation for C++. The first version of Simula, known as Simula-1, was strictly a simulation language. The next version, called Simula-67, was heavily influenced by Algol-60 and an extension method therein called classes and prefixing (later called objects and inheritance). A final version was created in a standard about 10 years later and called simply Simula, with the major difference from the previous version being the addition of encapsulation. See Dahl and Nygaard (1966), Kirkerud (1989), Nygaard and Dahl (1981), and Pooley (1987). A freely available version of Simula is cim.
[http://www.isima.fr/asu/]
simulation: Other categories with several entries related to simulation include:

computational fluid dynamics, for simulating a wide range of natural flows;

differential equations, used for simulating nearly everything;

ecological simulation, for simulations of real and surreal ecologies;

electronics, including simulators of various electronic hardware;

emulators for various computers and gaming systems;

geostatistics, wherein various geophysical fields are statistically simulated;

meteorology, wherein various models are used to simulate the atmosphere;

molecular dynamics, for simulating organic and inorganic molecules of various types;

oceanography, wherein several models are used to simulate the ocean.

Packages for performing general simulation tasks include:

C++SIM, an object-oriented packge for discrete event process-based simulation;

CASE, a toolkit for visualizing discrete simulation models (i.e. cellular automata) in 2-D;

Cellular, a simulator for cellular automata;

cim, a Simula compiler;

CNCL, a library with a large simulation component including event driven simulations;

dlxlab, a simulation and real-time execution environment for control system experiments;

Drone, a tool for automatically running batch simulation jobs;

Echo, a simulation tool for investigating mechanisms that regulate diversity and information processing in systems comprised of interacting adaptive agents;

EvoX, a complex systems simulator;

Maisie, a simulation language for the sequential and parallel execution of discrete-event models;

MCSim, a modeling and simulation program that can perform standard or Markov chain Monte Carlo simulations;

MOOSE, a general purpose toolkit for discrete-event and continuous simulation;

OMNeT++, an object-oriented modular discrete event simulator;

OmSim, a modeling and simulation environment for continuous and discrete event systems;

PARSEC, a discrete-event simulation language that uses the process interaction approach;

POSES++, a tool for modeling and simulating arbitrary discrete and discontinuous systems;

SHIFT, a language for simulating large dynamical systems;

SimPack, a library supporting discrete event, continuous and combined simulations;

SIMPLEX, a general simulation environment;

SMILE/M, an object-oriented, equation-based generic simulation environment;

Swarm, for the multi-agent simulation of complex systems;

THUD, a simulation environment for cycle-based designs; and

VIS, a system for the formal verification, synthesis and simulation of finite state systems.

Packages for simulating computer networks, protocols, and other computer-related things include:

APRoPS, a simulator for ATM network routing protocols;

ASM Workbench, for designing, validating and simulation Abstract State Machines;

ATM Network Simulator, for simulating the behavior of ATM and HFC networks;

BSVC, a microprocessor simulation framework;

CONICAL, a library for building simulations common in computational science;

DiskSim, a disk system simulator;

Limes, a tool for simulating multiprocessors;

MRT, a routing toolkit for building and simulating networking components;

NachOS, an OS simulator;

NS, a discrete event simulator targeted for networking research;

PAMELA, a simulator for parallel programs running on shared- and distributed-memory machines;

POLIS, a package for the design and simulation of embedded systems;

RAIDframe, a RAID array simulator;

SimOS, a simulation environment for uniprocessor and multiprocessor computer systems;

SMURPH, a system for simulating communication protocols;

Spin, a package for the formal verification of distributed systems that includes simulation capabilities;

TeleSoft, for simulating multimedia network systems; and

TOOPS, a library for process-oriented simulations primarily involving communications protocols.
Singular: A computer algebra system for computing information about singularities for use in algebraic geometry. It is able to work with non-homogeneous and homogeneous input and also to compute in the localization of the polynomial ring in 0.
Binary versions of Singular are available for several platforms, including Linux. The documentation is contained within a user's manual and a tutorial, both of which are available in TeX format.
[ftp://www.mathematik.uni-kl.de/pub/Math/Singular/]
Siod: Scheme In One Defun is a small implementation of Scheme programming language with some database, UNIX programming, and CGI scripting extensions. Siod is a Scheme interpreter with built-in procedures using the Oracle Call Interface (OCI) and Digital RDB SQL Services. It can be used as a flexible databaseloader/unloader with fast binary flat-file data save/restore or to apply symbolic manipulation or artificial intelligence techniques to data sets. The main program can be oriented towards batch, command line, or GUI interfaces. A general purpose UNIX scripting language environment is also supplied.
The source code for Siod is available. It is written in C and Scheme and can be compiled on generic UNIX, VMS, Win32, Mac and Amiga platforms. The system is documented in man pages as well as in a user's manual included in HTML format.
[http://sunsite.unc.edu/pub/Linux/devel/lang/lisp/]
[ftp://ftp.std.com/pub/gjc/]
[http://people.delphi.com/gjc/siod.html]
SIP: A tool for generating bindings for C++ classes so they can be accessed as normal Python classes. This is similar to SWIG although highly specialized for C++ and Python. SIP was originally designed to generate Python bindings for KDE (and as such has explicit support for the signal slot mechanism used by the Qt/KDE class libraries), but can be used to generate Python bindings for any C++ class library. The bindings generated by SIP support access to many C++ and Qt features including:

connecting Qt signals to Python functions and class methods;

connecting Python signals to Qt slots;

overloading virtual member functions with Python class methods;

protected member functions;

abstract classes, enumerated types, global class instances, and static member functions.

The SIP toolkit consists of three main parts:

a SIP binary that generates the C++ code;

header files needed to compile the generated C++ code; and

a run-time library needed by any set of compiled bindings.

[http://www.thekompany.com/projects/pykde/]
SIP: The Session Initiation Protocol is a simple signaling protocl for Internet conferencing and telephony. SIP provides the protocol mechanisms that allow end systems and proxy servers to provide such services as:

call forwarding;

callee and calling number delivery where numbers can be any naming scheme;

the ability to reach a called party at a single, location-independent address even when the user changes terminals;

terminal-type negotation and selection;

terminal capability negotation;

caller and callee authentication;

blind and supervised call transfer; and

invitations to multicast conferences.

SIP is independnet of the packet layer and requires only an unreliable datagram service as it provides its own reliability mechanism. At present (11/98) a couple of implementations are in the works with details available at the site.
[http://www.cs.columbia.edu/~hgs/sip/]
SIS: An interactive program for the synthesis of synchronous and asynchronous sequential circuits. The input can be given in a state table format or as logical equations or as a signal transition graph, with a target technology library given in genlib format. The output is a netlist of gates in the target technology. The capabilities of SIS include:

state minimization and assignment;

optimization for area and delay using retiming;

optimization using standard algebraic and Boolean combinational techniques;

performance optimization using restructuring; and

technology mapping for optimal area and delay.

Formal verification is available for both combinational and sequential circuits, as well as redundancy removal and 100% testability.
[http://www-cad.eecs.berkeley.edu/Respep/Research/sis/abstract.html]
Sisal: The Streams and Iteration in a Single Assignment Language is a project to develop high-performance functional compilers and runtime systems to simplify the process of writing scientific programs on parallel supercomputers and to help programmers develop functional scientific applications. It is claimed that functional languages such a Sisal will provide a lower-cost approach to developing parallel computing applications. This is because such languages isolate the programmer from the complexities of parallel processing, e.g. Sisal exposes implicit parallelism through data independence and guarantees determinate results.
The source code for the Optimizing Sisal Compiler is available and should compile and install on most UNIX-based uniprocessor and shared memory multiprocessor systems, including Linux boxes. There are also versions for Mac and MS-DOS platforms. The documentation is available either online in hypertext format or as printable documents in PostScript format. Documents available include a tutorial and a reference manual.
[http://www.llnl.gov/sisal/SisalHomePage.html]
SITES: A program for the analysis of comparative DNA sequence data which is primarily intended for data sets with multiple closely related sequences. It is especially useful when multiple sequences have been obtained from each of one or several closely related populations or species. The functionality of SITES includes:

identifying polymorphic sites and generating a table summarizing the information;

identifying the boundaries of insertions/deletions (indel) and generating a polymorphism table for indel variation;

condon usage tables;

numbers of synonymous and replacement base positions;

number of pairwise differences among sequences;

GC content for complete sequences and each codon position;

determining the average number of pairwise differences among all pairs of groups as well as the net divergence;

several kinds of polymorphism analysis including generating the two most commonly used estimates of the neutral mutation parameter and determining several measures of non-neutrality in the site frequency distribution;

historical population model fitting using two different models;

several kinds of recombination analysis on each group or the entire data set; and

partitioning the data set in several ways without changing the file.

A source code distribution is available. It is written in C and can be compiled on most platforms.
[ftp://ftp.bio.indiana.edu/molbio/evolve/]
Sitescooper: A Usenet transport toolkit consisting of a toolbox of utilities mostly writtein in Perl5 designed to help in the manipulation of Usenet News traffic in useful ways. The capabilities of SnarfNews include:

fetching articles by newsgroup from multiple NNTP servers and injecting them into a local news spool;

topping off a main newsfeed with articles from groups normally not obtained for, e.g. receiving local or national groups with poor propagation;

moving articles from a local NNTP server to a remote server;

gating email lists into newsgroups and vice-versa;

automatic emailing of articles in specific newsgroups on an NNTP server;

automatically saving to disk articles posted to a list of newsgroups on a server for archiving or offline reading;

transparently reposting articles from one newsgroup on one server to another group on another server;

collecting articles from a server, batching and compressing them, and emailing them to a remote server for unbatching and injection into another newsfeed;

implementing encrypted newsfeeds via batching and email;

sanitizing batched newsfeeds via removal of excessively cross-posted or large articles or SPAM articles;

injecting traditional rnews batches into NNTP-only news servers;

pulling/pushing news through a SOCKS firewall; and

automatic fallback into standard NNTP if extensions used for speed fail.

A source code distribution of this mostly Perl package is available.
[http://sitescooper.org/]
SIZE: A package for computing size functions, i.e. a kind of mathematical transform for studying the shapes of curves or any other topological space, e.g. pictures, sound waves, etc. They have been used to recognize hand-drawn sketches, tree leaves, handwritten numerals, letters in the sign language, toy cars, white blood cells, and of characters and writers in online handwriting. This package implements algorithms to compute size functions with respect to eight measuring functions.
[http://vis.dm.unibo.it/sizefcts/sf.htm]
sjyLX: A package for operating a Jorway Model 411S SCSI Bus CAMAC Highway Driver and the Jorway Model 73A SCSI Bus CAMAC Crate Controller. This includes a library of the standard calls as well as examples and test code. A source code distribution for Linux systems is available.
[http://www.fnal.gov/fermitools/abstracts/camac/abstract.html]
Sketch: An interactive drawing program similar to Xfig and tgif with an interface similar to those found in Corel Draw or Adobe Illustrator. This is still (11/98) in beta distribution. The features of Sketch include:

the usual drawing primitives, e.g. rectangles, ellipses, various types of curves, external images and text;

affine transformations of objects, i.e. rotating, scaling, etc.;

various fill properties, e.g. solid colors, gradients, etc.;

various line properties, e.g. color, width, dashes, etc.;

special effects including blend groups, conversion of text into Bezier objects, and text along a path;

plugin mechanisms including import and export filters for different file formats; and

exportation of EPS.

A source code distribution is available which requires Python and Tk for compilation and use.
[http://sketch.sourceforge.net/]
SKID: An astrophysical analysis program which finds gravitationally bound groups in N-body simulations. SKID finds groups by: deciding which types of particles are to be grouped, calculating the densities of the grouped particles and keeping the particles called moving particles which satisfy an established criterion; sliding the moving particles along the initial density gradient toward higher densities until all particles stop moving; group the particles thus localized using the friends-of-friends method; rejecting groups with less than a specified minimum number of particles; removing particles not bound to any group; performing one more rejection of groups on a minimum members basis. SKID is used to process output files from the TIPSY package but has wider applicability.
The source code for SKID is available. It is written in ANSI C and should compile on generic UNIX platforms. It comes with an example which worked with no problems on my Linux box. The program is documented in a man page as well as at the home site. SKID is part of the HPCCSOFT Tools suite.
[http://www-hpcc.astro.washington.edu/tools/SKID/]
SKIP: Simple Key management for Internet Protocols secures networks at the IP level. It was designed for datagram-oriented protocols like IP and requires no prior communication to establish and change traffic encryption keys.
[http://www.skip.org/]
SkyCat: A tool for image visualization and accessing astronomy archive catalogs. The functionality of SkyCat includes:

viewing FITS images including support for the World Coordinate System (WCS);

overlaying and editing color graphics objects on the image;

displaying a world coordinate based grid over an image;

displaying a compass on an image;

color PostScript output of the display;

access and loading of images from a Digitized Sky Survey server;

accessing information from astronomical catalogs, e.g. HST Guide Star Catalog;

accessing local catalogs and saving remote catalog data locally;

overlaying catalog sources on images;

accessing data from the NTT, HST and CFHT Science Archives;

access to SIMBAD and NED both as name resolvers and for information on known objects;

plotting tabular data in 2-D graphs;

calculating, displaying and plotting the center position, FWHM, angle and other information for selected objects;

accessing SkyCat from a remote process via a socket interface; and

interaction with WWW browser to access catalog documentation.

Binary distributions are available for several platforms including Linux Intel.
[http://arch-http.hq.eso.org/skycat/]
SkySOUND: A project to build a stream-oriented audio library whose features include:

partially assembly-optimized MPEG audio decoding;

portable and easy-to-use audio streaming;

simple driver interfaces for easing the coding of drivers;

compatibility with external audio libraries;

support for several audio stream formats; and

portable module players.

[http://tuo.planet-d.net/skysound/]
SkyVIDEO: A video-oriented portable library designed to allow developers write programs portable across DOS, Windows and Linux/X11 platforms.
[http://tuo.skytech.org/skyvideo/]
SLab: A suite of applications for direct-to-disk digital audio recording, mixing and signal manipulation. SLab consists of a several programs which themselves can consists of several programs or processes. The user interface was developed with Tcl/Tk with some extension widgets for potmeters, VU meters and wave editors.
The applications that comprise SLab are:

MixSLab, a launchpad for all of the other applications;

StudioSLab, a mixer that supports 8 completely independent full stereo mixes;

EffectSLab, a set of DSP algorithms running as modules;

WaveSLab, a visual wave/sample editor;

TapeSLab, for taping audio mixes; and

DeviceSLab, which manages all the options of OSS devices.

A source code distribution of SLab is available. Compilation requires a 2.0 kernel with OSS 3.5.x or, for full duplex, a 2.1.24 kernel and OSS 3.8-beta2. Documentation is scattered about and a bit sketchy.
[http://slabexchange.org/]
SLAM: A package for working with appearance learning and matching problems in computational vision. Appearance learning uses principal component analysis to compression a large image to a compact, low-dimensional subspace called an eigenspace in which the images reside as parameterized manifolds. SLAM can be used to obtained this parameterized representation via modules for eigenspace computation, project of images to eigenspace, and interpolation of multivariate manifolds through the projections. The appearance matching is done by searching for a projection in eigenspace closest to a novel input projection.
The functionality of SLAM is available through a set of command-line programs, a GUI to those programs, and a C++ class library. The command line programs include:

eigen, commputes eigenvectors from a vector set;

fitbspl, fits a quadratic B-spline to a set of points;

mkbinarysrch, constructs an object which can be used to search for the closest point in eigenspace;

mkexhaustivesrch, constructs an object which can be used for an exhaustive search for a closest point in eigenspace;

mkheuristicsrch, constructs an object which can be used to search for the closest point in eigenspace;

project, projects vector sets into a given eigenspace; and

sample, samples an interpolation to create discrete points.

A source code distribution is available. Makefiles are included for several UNIX platforms. Although one is not included for Linux, it's not too difficult to modify one of the others. A user's manual is included in PostScript format.
[http://www.cs.columbia.edu/CAVE/research/softlib/slam.html]
Slang: A multi-platform C programmer's library available for UNIX, VMS, OS/2, MS-DOS, and WIN16 and 32 systems. Slang includes routines for screen management, terminal/keyboard I/O, keymaps, and more. It also contains a sophisticated interpreter that uses a C-like syntax which supports user-defined functions, variables, structures, arrays, applications data types, and can be easily embedded into an application to make it extensible.
The Slang library includes many useful functions including:

low-level tty input routines for reading single characters;

keymap routines for defining keys and manipulating multiple keymaps;

SLkp, a high-level keyprocessing interface called for handling function and arrow keys;

SLsmg, high-level screen management routines for manipulating both monochrome and color terminals;

SLtt, low-level terminal-independent routines for manipulating the display of a terminal;

SLrline, routines for reading single line input with line editing and recall capabilities;

SLsearch, searching functions for ordinary and regular expression searches; and

an embedded stack-based language interpreter.

The library contains 90 intrinsic functions and 128 C library functions.
A source code distributio of Slang is available and can be compiled on all of the abovementioned platforms. It is documented in separate manuals for the language, the library, the intrinsic functions, and the C library. All documents are available in various popular formats.
[http://www.s-lang.org/]
SLAP: The Sparse Linear Algebra Package contains Fortran 77 routines for solving large, sparse, symmetric and nonsymmetric positive definite linear systems using preconditioned iterative methods. SLAP contains core routines to perform iterative refinement using Jacobi's method, conjugate gradient (CG), CG on the normal equations, biconjugate gradient (BCG), BCG squared, and orthomin and generalized minimum residual iteration. These routines do not require any fixed data structure at the cost of the user having to supply two routines to: (1) calculate y = Ax given x and the user's data structure for A, and (2) solve r = Mz for z given r and the user's data structure for M. A few of the core routines also require that the user supply a matrix transpose time vector routine and a routine that solves the transpose of the preconditioning step. For each core routine there are several drivers and support routines which allow the user to utilize diagonal scaling adn incomplete Cholesky or incomplete LU factorization as preconditioners with no coding, although a specific matrix data structure must be used with these.
A source code distribution of SLAP is available. It is written in Fortran 77 and I've successfully compiled it and run the test program using g77. Using SLAP also requires the compilation and linking of three additional programs with the library. These are: xersla, the error handling routines from SLATEC; blas, the generic BLAS package from LINPACK; and mach, which contains machine dependent constants for various machines. The program is documented in ASCII files in the distribution.
[http://www.netlib.org/slap/]
SLATEC: The Sandia, Los Alamos, Air Force Weapons Laboratory Technical Exchange Committee library is a collection of over 1400 general purpose mathematical and statistical programs written in Fortran. The routines in SLATEC can be divided into several major categories based on functionality: arithmetic and error analysis, elementary and special functions, linear algebra, interpolation, solution of nonlinear equations, optimization, differentiation and integration, differential and integral equations, integral transforms, approximation, statistics and probability, data handling, service routines, and miscellaneous routines.
A source code distribution of the SLATEC library is available. All of the routines are written in Fortran and portability is facilitated by the use of the d1mach, i1mach, and r1mach routines from the PORT library. The overall library structure is documented in several ASCII files, and each routine is documented via comment statements within the routine.
[http://www.netlib.org/slatec/]
SLEIGN2: A set of Fortran 77 codes to compute eigenvalues, eigenfunctions, and to approximate the continuous spectrum of regular and singular Sturm-Liouville problems. The original version of SLEIGN2 called SLEIGN was TOMS algorithm 700 and is documented in Bailey and Zettl (1991b) and Bailey and Zettl (1991a).
[http://www.math.niu.edu/~zettl/SL2/]
[http://www.acm.org/calgo/contents/]
[http://www.acm.org/toms/V17.html]
[http://www.netlib.org/toms/index.html]
SLEUTH: A code for the numerical solution of regular two-point fourth-order Sturm-Liouville eigenvalue problems. Eigenvalues are computed according to index, i.e. the user specifies an integer and the code computes an approximation to the kth eigenvalue. Eigenfunctions are calculated via an auxiliary routine. A source code distribution of this Fortran routine is available. This is TOMS algorithm 775 and is documented in Greenberg and Marletta (1997).
[http://www.acm.org/calgo/contents/]
SLFFEA: San Le's Free Finite Element Analysis package contains software and GUIs for finite element analysis. The contents and capabilities of SLFFEA include:

six basic FE types including a 3-D 2 node beam, an 8 node brick, a 4 node plate, a 4 node quad (for plane stress and strain), a 4 node doubly curved shell, and a 3-D 2 node truss;

an 8 node brick nonlinear large deformation element; and

a GUI for each element type.

A source code distribution is available. This is written in C and also requires Mesa.
[http://www.geocities.com/Athens/2099/slffea.html]
SLIB: This is a portable Scheme library that works with many of the available Scheme implementations.
[http://ftp-swiss.ai.mit.edu/~jaffer/SLIB.html]
SLICOT: A general purpose basic control library for control theoretical computations. It provides tools to perform basic system analysis and synthesis tasks, with the main emphasis being on the numerical reliability of implemented algorithms and the numerical robustness and efficiency of routines. Special emphasis is put on providing maximal algorithmic flexibility for users and on the use of rigorous implementation and documentation standards. Until late 1996 SLICOT was a proprietary package sold by NAG, but a decision was made to turn it into copyrighted freeware. This entailed replacing the NAG routines used in SLICOT with LAPACK and BLAS based routines. Several new routines are also planned as additions to the package as well as a collection of benchmark examples.
The SLICOT library is organized into several sections including:

analysis routines including state-space analysis routines for canonical and quasi-canonical forms, continuous/discrete time transformations, interconnections of subsystems, controllability and observability, inverse and dual systems, model reduction, system norms, and poles, zeros and gain;

benchmark and test problems;

adaptive control;

data analysis programs including those for covariances, spectra, discrete Fourier transforms and windowing;

filtering including Kalman filters;

identification;

mathematical routines including those for linear algebra and polynomial and rational function manipulation;

nonlinear systems;

synthesis routines including state space synthesis routines for eigenvalue/eigenvector assignment, Riccati equations, Lyapunov equations, Sylvester equations, deadbeat control, transfer matrix factorization, and realization methods;

transformation routines for state-space transformations, polynomial matrix transformations, rational matrices and time response; and

utility routines for numerical data handling.

The SLICOT library is written in Fortran 77 and is available in single and double precision forms. The freeware version is being released gradually and hasn't yet been completely released (5/97).
[http://www.win.tue.nl/wgs/slicot.html]
Slidedraw: A slide creation and presentation program written using Tcl/Tk. There's not much in the way of documentation for this yet (8/98) but the sample images look pretty spiffy.
[http://www.ibiblio.org/pub/Linux/apps/graphics/]
[http://fantasia.usc.es/~akira/slidedraw/]
[http://web.usc.es/~fafefito/slidedraw/]
SLIP: The Serial Line Internet Protocol is a packet framing protocol defining a sequence of characters that frame IP packets on a serial line. Significant is what it does not provide, e.g. addressing, packet type identification, error detection/correction, and compression mechanisms. SLIP is most commonly used on dedicated serial links and dialup modem connections, although PPP seems to have supplanted it on the latter.
[http://www.faqs.org/rfcs/rfc1055.html]
SLiRP: A program that emulates a SLIP or PPP connection over a shell dial-up connection, i.e. a PPP driver that runs entirely as a user process.
[http://slirp.sourceforge.net/]
[http://blitzen.canberra.edu.au/slirp/]
SL11F/SL12F: A set of Fortran 77 subroutines to find a specified eigenvalue of a differential equation eigenvalue problem posed in the form of an eigen-parameter dependent Hamiltonian system with suitable separated boundary conditions. Both routines use a shooting method based on matrix oscillation theory, with the second also using coefficient approximation. The source code for both routines is available. It is written in Fortran 77 and each routine is documented in a separate user's guide in LaTeX format.
[http://www.netlib.org/aicm/index.html]
slocate: The secure locate program provides a secure way to index and quickly search for files on a system. It uses incremental encoding like GNU locate for compressing the database to make searching faster. It additionally checks file permissions and ownership so users will not see files to which they don't have access. A source code distribution is available.
[http://rpmfind.net/linux/RPM/slocate.html]
sl++: The Scientific Library is a project to build a C++ object-oriented library to satisfy the demand for a free, fast, easy to use and powerful numerical library. It is composed of various modules for specialized areas in numerical computations. The modules (not all of which are finished as of 1/99) are:

algebra, advanced matrix operators and structures;

complex, full arithmetic on complex numbers;

filter, various kinds of adaptive filters;

fixed, fixed point arithmetic;

matrix, basic matrix operators;

banded, banded matrix structure;

colmajor, dense column major matrix structure;

constant, constant matrix structure;

diagonal, diagonal matrix structure;

rowmajor, dense row major matrix structure;

sss, sparse symmetric skyline matrix structure;

symmetric, dense symmetric matrix structure;

tensor3, 3-D dense matrix structure;

triang, dense lower and upper triangular matrix structure;

tvector, dense vector matrix structure;

noise, various kinds of noise generators;

plot, features for plotting matrices via Gnuplot;

quaternion, full arithmetic on quaternions; and

spectral, discrete Fourier transform and related operators via FFTW.

A copy of the current development tree is available under the GPL. A first beta release awaits the full support of template specialization by egcs. A documentation package is also available.
[http://home.cern.ch/~ldeniau/html/sl++.html]
slrn: An NNTP based Usenet news reader. The features include MIME support, true reference-based threading, score (kill) file support, a colored thread tree, multiple server support, multiple windows, customizable, smart screen updating, automatic reconnect, fast on slow modem connections, X mouse support, easy uudecoding, and more. This will compile on generic UNIX/X11 systems including Linux.
[http://space.mit.edu/~davis/slrn.html]
[http://sunsite.unc.edu/pub/Linux/system/news/readers/]
SLRPACK: A collection of Fortran 77 programs for performing simple linear regression tasks. The programs in SLRPACK include:

RGM, which computes estimates of simple linear regression parameters for a geometric mean regression;

RWILL, which estimates simple linear regression coefficients when both variables are subject to errors which are not necessarily homogeneous in variance;

RYORK, which estimates simple linear regression coefficients when both variables are subject to errors which are not necessarily homogenous in variance (a different method than RWILL);

LINFS, which solves the model y = b1 + b2*x under the Chebyshev norm criterion; and

DLINFS, a double precision version of LINFS.

A source code distribution of SLRPACK is available. It is 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/]
SLS: A Matlab toolbox for Sparse Least Squares problems. The SLS routines are for solving sparse least squares problems, the constrained least squares problem with nonnegativity constraints, and problems with box constraints. The routines include:

sqr and sqr2, for sparse multifrontal QR factorization;

csne, solves the sparse linear least squares problem by the corrected semi-normal equations;

qls, solves the problem by QR factorization;

sbls, solves the problem with box constraints by an interior point method;

sbls2, solves the problem with box constraints by an active set method;

snnls, solves the problem with nonnegativity constraints by an active set method;

sblsgen, generates random sparse least square test problems with box constraints; and

quadres, calculates a residual using quadruple precision.

[http://www.math.liu.se/~milun/sls/]
SLVBLK: A Fortran 77 program to solve a linear system with a coefficient matrix in almost block diagonal form. Such matrices arise often in piecewise polynomial interpolation or approximation and in finite element methods for two-point boundary value problems. The PLU factorization method is used to take advantage of the special structure and to save computer time and storage requirements.
A source code distribution of SLVBLK 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/]
smail: A router and a mail transfer agent (MTA) which receives mail messages and recipient addresses from local users and remote hosts, routes mail destined for remote hosts, performs alias and forwarding transformations on local addresses, and performs delivery. It is compatible with the external interface of sendmail. Smail was design to provide extensibility in the methods employed for resolving local and remote addresses and in the methods used for performing mail delivery. It was also designed to be tolerant of system crashes and to be capable of recovering from configuration errors. Smail can be used in any networking environment which expects mail to conform to the DDN mail format standards, e.g. ARPAnet, CS-Net, and the UUCP network. It can be used to route mail between any number of conforming networks and uses a variety of methods for determining the namespace on the networks and performing delivery. The orthogonal operations of aliasing, host routing, and transport are all handled in a consistent manner with consistent configuration file formats and C language drivers to implement the basic capabilities. The distribution also contains a number of tools useful for building, maintaining, and displaying databases.
The utility programs in smail include:

mkline, which takes an alias or path file and strips comments and unnecessary white space and joins continuation lines so programs which create databases can read single line records;

mksort, which creates sorted databases;

mkdbm, which creates DBM databases;

mkaliases, which uses a configuration file to build an alias file;

pathalias, which processes map data to produce paths;

mkpath, which is used to organize the path building process;

uuwho, which is used to get a listing of the map entry for a known site;

mkuuwho, which produces a database which associates each site name with the location of its map entry;

getmap, which is used to extract map entries from the maps published in comp.mail.maps;

checkerr, which checks for processing errors;

savelog, which performs log truncation and compression; and

bsearch and dbm, a couple of file lookup methods.

A source code distribution of smail is available as is a binary version for Linux Intel platforms. The source version can be compiled and installed on most UNIX flavors. The package is documented in a series of detailed man pages.
[http://sunsite.unc.edu/pub/Linux/system/mail/mta/]
SMake: Skeleton Make is a powerful mechanism for generating standard makefiles out of skeleton makefiles which only provide the essential parts. The missing syntax is automatically supplied by shared include files. SMake generates makefiles which are then evaluated by the standard make tools. SMake can be used to create a huge makefile hierarchy and keep it consistent throughout a development phase and after. It merges the skeleton and the templates (or include files) in a priority driven way, i.e. defines and targets can be overwritten. This is similar to Imake but the goal here is not inherited system dependence for the makefiles but rather consistency and power without having to manually maintain a makefile hierarchy consisting of plain makefiles.
The features of SMake include:

include statements can be used to integrate an external file at that position;

an option directive can be used to set any options which are to overwrite those given on the command line; and

a priority directive can be used to set current processing priority.

These three directives allow very short smakefiles to be created which will be automatically complete by SMake.
A source code distribution of SMake is available. It is written in Perl and can be used on any platform to which that has been ported. It is documented in a man page.
[http://www.engelschall.com/sw/smake/]
Small: A simple, typeless, 32-bit extension and scripting language with a C-like syntax. A compiler outputs bytecode that subsequently runs on an abstract machine for optimal execution speed. Small was implemented to provide a language toolkit whose executable code can be embedded in resource files or animation file formats with little added overhead to the main application. The features include:

a design that attempts to avoid or circumvent the mistakes that novice C programmers most frequently make;

an implementation of an abstract machine in portable C, i.e. a set of C functions that can be easily linked to an application or function library;

pass-by-value (like C) and pass-by-reference for function arguments;

sdefault function arguments for arrays and simple variables;

named parameters along with conventional positional parameters;

extension of arrays to mimic lightweight structures with arrays;

symbolic constants, conditional compilation and assertions in lieu of a preprocessor;

packed and unpacked strings for bridging ASCII and Unicode subsytems;

variable declarations that may occur in any position where a statement is valid (as in C++);

well-defined integer division and modulus operators for negative operands;

a debugger modeled after gdb;

an interface to native functions in C/C++; and

written in ANSI C as much as possible for maximum portability.

A manual is available in ASCII and PDF formats.
[http://www.compuphase.com/small.htm]
Small Eiffel: A free Eiffel compiler intended to be a complete, small and very fast. This package will convert Eiffel into either C code or Java bytecode. It also includes a version of the Standard Eiffel library, a random number generator library, and a set of test and demonstration programs. The target code is ANSI C but the compiler is written in Eiffel (bootstrapped).
The programs in the SmallEiffel distribution include:

compile, takes an Eiffel program and generates a C program and then an executable;

compile_to_c, the Eiffel to C compiler;

compile_to_jvm, the Eiffel to Java bytecode compiler;

short, an Eiffel interface extraction tool that can generate documentation in different formats;

pretty, a prettyprinter;

finder, finds Eiffel sources files;

clean, cleans up project directories; and

print_java_class, a Java bytecode disassembler and prettyprinter.

The source code is available and has been ported to most available platforms. Documentation is a bit sparse and scattered about the home site.
[http://www.loria.fr/projets/SmallEiffel/]
[http://SmallEiffel.loria.fr/index.html]
Smalltalk: Non-commercial distributions of Smalltalk include Smalltalk/X and the Smalltalk-like Squeak. See the Smalltalk Archive. Smalltalk texts include Goldberg and Robson (1983).
Smalltalk/X: A version of the Smalltalk/X system for non-commercial use on Linux systems.
[http://sunsite.unc.edu/pub/Linux/devel/lang/smalltalkx/]
smallutils: A collection of a few small standard yet essential utilities. The collection includes:

true/false, which exits with a return code of 0/1 and is usually used to act as a constant condition in shell scripts;

link/sln/unlink, statically linked file utilities which, respectively, creates a new hard link to an existing file, calls symlink to create a symbolic or soft link, and removes a link to a file;

pwd, which prints the name of the current directory;

sync, which instructs the kernel to write dirty buffers back to the file system (and is traditionally used as part of a method for shutting down a system); and

uname, which prints various information about the system.

The smallutils are available as source code written in portable C and also in assembler form for both a.out and ELF formats. Each is documented in a man page.
[http://sunsite.unc.edu/pub/Linux/system/misc/]
SMART: An implementation of a vector-space model of information retrieval whose primary purpose is to provide a framework in which information retrieval research can be conducted. As such, SMART provides standard versions of indexing, retrieval and evaluation.
The SMART system is composed of four levels of programs and procedures. The highest level is the request level in which a user submits some sort of request, e.g. adding documents to or retrieving documents from the collection, after which the system decides which procedures are appropriate to invoke. At the task implementation level procedures are each responsible for performing one task, with each task phrased in the form of converting one type of information into another type. Collection data can be accessed via relational file objects. The object task level consists of the procedures for accessing relational file objects and the procedures for reading specification files. The database access level is the lowest logical level and completely unknown to the top two levels.
The SMART system source code is available. It is written in C and should compile on most generic UNIX systems. The documentation is a bit sketchy and scattered through a series of ASCII files.
[ftp://ftp.cs.cornell.edu/pub/smart/]
SMARTALLOC: A package implementing smart memory allocation with orphaned buffer detection. This replaces the standard C library memory allocation functions with versions that keep track of buffer allocations and release and report all orphaned buffers at the end of program execution. A source code distribution of SMARTALLOC is available.
[http://www.fourmilab.ch/smartall/]
Smart Boot Manager: An OS-independent boot manager intended as an open source replacement for System Commander and other commercial offerings. The features of SBM include:

a size small enough to fit into the first (i.e. hidden) track of the hard disk;

absolute OS independence since it doesn't need any partitions;

a window-like interface and online help with no configuration file needed;

automatic searching for all the drivers and partitions that can be booted;

two types of password modes and three security modes for flexible security configuration;

automatic boot after chosen delay time;

boot scheduling to boot different drivers or partitions depending on time of day;

booting DOS/Win variants and some other OS types from the primary partitions in any hard disk rather than just the first;

preloading of keystrokes to send to the OS being booted; and

a customizable theme file.

[http://master.chinaren.net/~suzhe/]
SmartHTML: Yet another markup language for Web pages whose syntax sort of resembles that of Texinfo. The features include:

treating two or more consecutive newlines as <PP>;

automatically escaping all special characters;

macro capabilities;

easy creation of URLs;

automatic table of contents generation; and

centralized control of global style.

A source code distribution of this Perl program is in the public domain.
[http://www.andreasen.org/smart/]
SmartGDB: A set of modifications made to the GNU debugger GDB. SmartGDB merges the commands offered by GDB with the Tcl/Tk scripting language to offer an expanded set of commands for control flow and data modeling. It also contains support for debugging applications which use threads.
Source and binary distributions of SmartGDB are available, with the latter available for Linux Intel and Digital UNIX platforms. Various documentation is available online.
[http://hegel.ittc.ukans.edu/projects/smartgdb/]
SmartList: A mailing list package built on top of the procmail package. The capabilities of SmartList include:

overseeable management of an arbitrary number of mailing lists;

simple creation of new mailing lists and removal of existing mailing lists;

fully automated subscription, unsubscription, and help/request processing;

enough intelligence to overcome the ignorance of some subscribers (e.g. redirection of subscribe requests away from the regular list);

no hardwired format for subscribe or unsubscribe requests;

intelligent autoremoval of addresses that cause too many bounces from the list;

limitation of submissions to those on an accept list;

a fully automated reject list for unwanted subscribers and a general address screening mechanism which allows control over who can subscribe;

optional implicit subscription upon first list submission;

MIME-compliant automatic digest generation;

remote maintenance of any mailing list;

an integrated archiving service;

moderated mailing lists with an arbitrary number of moderators;

automatic elimination of duplicate submissions; and

extended MIME support.

A source code distribution of SmartList is available. It comes in the form of a difference file that is unpacked on top of the procmail sources, with the two then being jointly compiled and installed.
[ftp://ftp.informatik.rwth-aachen.de/pub/packages/procmail/]
[http://www.procmail.org/]
SMARTS: The Shared Memory Asynchronous Runtime System supports integrated task and data parallelism for MIMD architectures with deep memory hierarchies. It is intended as either a target for another software layer above, e.g. POOMA, or as a library tool for an end-user. Task parallelism is supported by providing user-level threads that allow lightweight virtual processors natural to the algorithm being implemented to be developed. SMARTS uses a subset of Pthreads for this purpose. It also supplies a native API that implements a coarse grained macro dataflow approach, i.e. an asynchronous model allowing the system to interleave the execution and data-parallel statements for maximum parallelism. This is a producer-consumer model in which blocks of loop iterations called Iterates execute when the required data is available, i.e. when the data dependencies are satisfied.
SMARTS uses different units of concurrencies with different functionalities and costs to exploit various types of parallelism. The coarsest granularity is a kernel level process, i.e. is an abstraction of a hardware processor. Such kernel level processors are also called workers since their function is to obtain work units from work queues and execute them. An affinity scheduler is used in which each worker looks for work in its own queue and, if none is available, obtains work from other workers. Three types of work units are available:

thread objects, i.e. stateful units of concurrency that allow the system to block the thread and run a different one until some event has occurred or some condition satisfied, whereupon the original thread is resumed;

function objects, i.e. a lightweight, run-to-completion unit of concurrency whose overhead is comparable to that of a function call and which is used, e.g. for concurrent objects that will never block;

iterate objects, i.e. even lighter weight function objects used for data- or loop-level parallelism.

A source code distribution of SMARTS is available. It has been ported to Linux Intel with the commercial KCC compiler, although it will probably eventually work with egcs. The available documention is a bit sketchy thus far (12/98).
[http://www.acl.lanl.gov/smarts/]
smart2: A Linux driver for Compaq Smart-2 (or better) disk array controllers. The package includes the driver as well as several utilities for working with it.
[http://www.insync.net/~frantzc/cpqarray.html]
Smart UPS Tools: A set of utilities for using APC SmartUPS models with UNIX systems. This set of programs allows multiple systems to monitor a single APC SmartUPS and shut down when conditions warrant it. System data can also be viewed with a browser using CGI programs supplied with the package. The programs in the package include:

upsd, a daemon that talks to the UPS via a serial line and answers UDP queries from clients that arrive via the network;

upsmon, a daemon that talks to upsd and shuts machines down when the battery is low and the line power is gone;

upsstats, a CGI program to generate the main status page;

upsimage,, a CGI program for creating images used by the main status page;

multimon, a CGI program that monitors multiple instances of upsd on one page; and

upslog, a daemon that logs values from a UPS at a specified interval.

[http://www.exploits.org/nut/]
SmartWorker: A platform for web application development consisting of a set of application framework classes written in Perl. These classes use any SQL database via DBI for backend data storage, and Apache with mod_perl for front-end client access. SmartWorker is based on an event-driven, persistent, application framework model similar to that of GTK and Java Foundation Classes (JFC) as opposed to the transaction-based model of, e.g. CGI or ASP. This serves to insulate the application programmer from the detailed workings of the Web.
The features and functionality of SmartWorker include:

users and groups automatically built into the system so, e.g. an application runs with the permissions of the user running it;

automatic handling of persistence and session management;

automatic handling of the database backend, data storage and retrieval, user authentication, etc. by framework classes such that the developer doesn't have to handle the gory details;

building of applications with widgets and objects rather than by embedding code in HTML templates;

an app rendering architecture that detects the browser being used and adapts accordingly; and

anticipation of and support for multi-lingualism.

A source code distribution is freely available under fairly unrestrictive conditions.
[http://www.smartworker.org/]
SMB: The Server Message Block is a protocol for sharing files, printers, serial ports, and various communications abstractions such as named pipes and mail slots between computers. It was first defined in a joint Microshaft/Intel document in 1987 and subsequently developed by both Microshaft and others. SMB is a client/server, request-response protocol that can run over multiple protocols including TCP/IP, NetBEUI, and IPX/SPX (with the NetBIOS API used for all but the latter). Several protocol variants have been developed since the inception of SMB, including that of the freely available Samba pacakge. An enhanced version of SMB called CIFS is currently (9/97) under development. Samba is the only freely available SMB server currently available, although several clients are available including smbfs, rumba, the smbclient program from Samba, and SMBlib.
[http://samba.anu.edu.au/cifs/docs/what-is-smb.html]
smbfs: An SMB client which allows you to mount drives exported by Windows for Workgroups, Lan Manager, Windows NT and other compatible systems running TCP/IP. This is a Linux kernel option. The newer rumba is based on this.
[http://sunsite.unc.edu/pub/Linux/system/filesystems/smbfs/]
[http://samba.SerNet.DE/linux-lan/]
[http://us5.samba.org/samba/smbfs/]
SMBlib: An SMB client library. SMBlib consists of SMBlib code and NetBIOS over TCP/IP code (called RFCNB) implemented per RFC-1002. It includes simple test programs that test the functionality. RFCNB can currently get a connection to a server and send and receive messages. A source code distribution of this library is available.
[ftp://ftp.samba.org/pub/samba/smblib/]
SME: The Spatial Modeling Environment is an integrated environment for high performance spatial modeling. SME transparently links icon-based modeling environments with advanced computing resources, allowing simulations to be developed in a graphical environment. Automatic code generators construct spatial simulations and enable distributed processing over a network. The environment imposes the constraints of modularity and hierarchy in model design, and supports the archiving of reusable model components as defined in a Modular Modeling Langauge (MML).
The components of SME include:

a View component used to graphically construct, calibrate and test biological/ecological modules;

a Module Constructor that translates the View component modules into Module objects defined in MML;

a Code Generator that converts an MML object hierarchy into a C++ object hierarchy which is incorporated into the simulation driver application to create a spatial simulation;

a PointGrid Library (PGL) consisting of a set of C++ distributed objects designed to support computation on irregular, distributed networks and grids; and

the Driver, a distributed, object-oriented simulation environment implemented as a set of distributed C++ objects linked by message passing.

[http://iee.umces.edu/SME3/]
SMEED: Sakata's Maximum Entropy Electron Density analysis program is a modified version of the original MEED program and Kumazawa and Kubota, which was a program for performing maximum entropy electron density analysis on X-ray powder diffraction data. The maximum entropy method (MEM) is an alternative to the FFT for finding estimates of power spectra which can be better at isolating narrow peaks in the power spectrum. SMEED and MEED apply the MEM to the crystallography field.
The SMEED package contains three main programs (and several subprograms) written in Fortran 77: SMEED, for calculating the strictly positive maximum entropy density of an asymmetric unit of a crystal sample (and a variant called SMEEDC for non-centrosymmetric samples); MECO, for reconstructing the whole crystal cell density from SMEED output files as well as extracting sections and projections and saving them as new files; and FOURIER, for performing a standard FFT spectral analysis as a complement or check to the results found using SMEED.
A source code distribution of the SMEED package is available. All programs are written in Fortran 77 and can be compiled using g77 with little or no modification. The package is documented in a user's manual supplied in both PostScript and LaTeX formats.
[http://www.uni-tuebingen.de/uni/pki/maxent/maxent.html]
SMIL: The Synchronized Multimedia Integration Language is a set of specifications for choreographing interactive multimedia content for the Web. It is a layout language allowing the easy creation of multimedia presentations consisting of multiple elements of music, voice, images, text, video and graphics in a common, synchronized timeline.
[http://smw.internet.com/smil/smilhome.html]
[http://www.oasis-open.org/cover/xml.html]
[http://www.w3.org/TR/REC-smil/]

S2M2

Streaming Synchronization MultiMedia is an experimental prototype player implementing many of the features of SMIL.
[http://smil.nist.gov/player/S2M2.html]
SMILE/M: A prototypical, object-oriented, equation-based, generic simulation environment that automatically generates simulators from high-level model specifications in which data structure declarations, differential/algebraic equations and component connections can be naturally structured using object-oriented concepts from a general purpose OO programming language.
[http://www.first.gmd.de/smile/smileM.html]
smix: A sound mixing tool with several features including:

autodetection of supported channels/devices;

active real-time updating;

balance sliders for all stereo channels;

an overall balance slider;

record, mute, lock and solo buttons;

high configurability with settings saved in a config file; and

command line sound control.

This is available either in source code form or as a binary dynamically or statically linked to the Xforms library.
[http://brahms.fmi.uni-passau.de/~anderss/smix/]
SMJPEG: The SDL Motion JPEG library is based on a modified version of the Independent JPEG Group's library for image manipulation and additional code for ADPCM audio compression. It can create and display motion JPEG files in a custom and open format. The additional features of SMJPEG include:

arbitrary video sizes and frame-rate;

user-tunable compression level;

easier to skip frames and keep timesync;

easy to seek within the video stream; and

no patent problems.

The drawbacks include poorer quality that MPEG at the same file size and slower than MPEG at the same framerate. This is also not designed for Internet streaming. A source code distribution is available under an Open Source license. An exporting version of xanim including SMJPEG is also available at the site.
[http://www.lokigames.com/development/smjpeg.php3]
SMLIB: A Fortran 90 library for performing sparse matrix calculations. The library contains routines divided into five main sections:

Miscellanous - various useful routines and definitions including the definition of the numerical precision for the rest of the library;

Matrices - data structures for several sparse matrix and sparse matrix factorization storage schemes along with routines to operate on the data structures;

Incomplete factorizations - routines for performing incomplete factorizations for sparse matrices;

Iterative solvers - iterative methods for the solution of large sparse linear systems of equations; and

Direct solvers - a Fortran 90 interface to the LAPACK subroutines for band matrix Gaussian elimination.

[ftp://ftp.ntnu.no/pub/smlib/]
SML/NJ: Standard ML of New Jersey is a compiler and programming environment for the Standard ML programming language. The distribution includes a source-level debugger, a profiler, an Emacs interface, ML implementations of LEX, YACC, and Twig, separate compilation facilities, Concurrent ML, the eXene X Window library, and the SML/NJ library. Nonstandard extensions to ML include typed first-class continuations, UNIX signal handling, and higher-order functors.
A source code distribution of SML/NJ is available as are binaries for several platforms. There is extensive documentation available in PostScript format.
[http://cm.bell-labs.com/cm/cs/what/smlnj/]
SMMP: The Sparse Matrix Multiplication Package is package of routines callable from both Fortran and C which implement matrix-matrix multiplication and transposition for a variety of sparse matrix formats. They also perform format conversions among the old and new Yale sparse matrix package (YSMP) formats and a more efficient format for square matrices. The most probable use for these routines will be in implementing parallel computation algorithms such as parallel multigrid programs.
A source code distribution of SMMP is available. It is written in Fortran 77 and documented in a user's guide available in LaTeX format.
[http://www.netlib.org/aicm/index.html]
SMMS: The Sparse Matrix Manipulation System is a collection of executable commands to process sparse matrices. It includes routines for ordering, LDU factorization, visualization, orthogonal factorization, repeat solution, sparse vector methods, symbolic computation, sparse inversion, augmented matrix methods and much more. These routines complement and are able to work with other well known packages such as the Harwell routines, SparsKit, and Matlab. New routines may be easily added in almost any language following the basic rules in the manual.
SMMS is built around four main concepts: sparse matrices, permutation vectors, partition vectors, and node set lists, with each of these concepts implemented as a stream of ASCII data which is operated on by filters that process one or more items. Permutation vectors are commonly applied to a matrix to permute its rows, columns, or both. A partition vector is a collection of ordered integers which usual denote positions within a matrix. Node set lists are sets of groups of nodes (rows and columns) of a matrix of intereest, e.g. for finite element applications. All of these concepts are applied using state-of-the-art algorithms to manipulate and use sparse matrix systems.
The source code, written in C, is available and should compile and install on generic UNIX systems. The documentation is in a 100+ page manual in LaTeX format.
[ftp;//eceserv0.ece.wisc.edu/pub/smms93/]
[http://peru.ece.wisc.edu/alvarado/]
SMOOTH: An astrophysical program which calculates several mean quantities for all particles in an N-body simulation output file. It can calculate the density, mean velocity, mean speed, velocity dispersion, mach number, and phase density. The input files are read and the output files produced in the TIPSY array format.
The source code for SMOOTH is available. It is written in C and can be compiled on generic UNIX systems. It is documented in a man page included in the distribution. SMOOTH is part of the HPCCSOFT Tools suite.
[http://www-hpcc.astro.washington.edu/tools/SMOOTH/]
Smoothing Toolbox: A Matlab toolbox with programs for nonparametric regressiona nd smoothing. The capabilities include local polynomial techniques such as ridging and binning, smoothing splines, and density estimation. The routines in the toolbox include:

FavorsSmoothing, estimates a regression function using a variable adaptive-order locally weighted polynomial least-squares regression procedure;

GCVsm, for natural B-spline data smoothing using generalized cross-validation and mean-squared prediction error criteria;

KernelSmoothing, estimates a regression function using a variable bandwidth and locally weighted polynomial least squares regression;

density, performs density estimation by the FFT method of Silverman with a Gaussian kernel;

fastbinsmooth, implements the fast binning method for calculating kernel density estimates, a Naraya-Watson kernel estimate, and a local linear regression smoother; and

lpridgesm, performs local polynomial kernel smoothing with ridging.

The distributions also contains several programs written in Fortran and C that can be compiled and included to speed up the Matlab programs. Documentation is included in TeX format.
[http://www.unizh.ch/biostat/software.html]
SMP: Symmetric Multi-Processing is processing on shared memory multiprocessor machines, e.g. a Linux box with a couple of Intel processors. Currently (7/97) the Linux 2.0 kernel contains basic SMP support for Intel and Sun hardware.
[http://www.linux.org.uk/SMP/title.html]
SMPEG: The SDL MPEG player library is an Open Source project to create a general purpose MP3 audio, MPEG-1 video, and MPEG system stream player for Linux. This is available under the LPGL and based on mpeg_play.
[http://www.lokigames.com/development/smpeg.php3]
SMT: The Simple Multi-Threading kernel is an add-on to the Libero programming tool that lets you write portable high-performance multithreaded programs based on Libero's finite-state machine (FSM) design method. SMT is built on an event-based kernel that integrates smoothly into the event-driven state machine inside each program and uses Libero to abstract the multithreading logic. It can be oriented towards socket I/O, towards Window event handling, or towards any other event source. It differs from classic multithreading paradigms in that it works at the user rather than the kernel level in a process called either internal or pseudo multithreading which is transparent to the operating system. The threads communicate with events as well as with semaphores which allows the design of object-oriented applications. It also uses asynchronous or non-blocking I/O as much as possible to allow the development of efficient applications which can handle large numbers of connections with a low overhead per connection (e.g. the Xitami server).
SMT can be used for Internet programming where each connection is handled by one thread (see Xitami), real-time programming where multilevel finite-state machines work cooperatively, and GUI development where events are collected from the GUI and passed to threads for processing. SMT currently (8/97) currently supports C and C++. The SMT kernel features include:

strong object orientation,

support for multiple FSM programs within one application,

support for multiple threads within one FSM program,

support for Internet protocols (e.g. TCP/IP, UDP/IP),

standard agents (e.g. HTTP, file transfer, authorization, logging, console, timing, socket I/O), and

an unrestricted number of threads and queue sizes.

A source code distribution of SMT is available. It is written in ANSI C and has been ported to MS-DOS, Windows, and most UNIX systems including Linux. Additional required software packages are SFL and Libero, and the package includes the Xitami web server. A user's guide is available in HTML format.
[http://www.imatix.com/html/smt/index.htm]
SMT (daemon): The Service Monitoring Tool is a daemon designed to execute arbitrary test programs and send a notification when the test programs fail. The features include:

a simple command-line interface;

tests for common services, e.g. DNS, HTTP, IMAP, POP3 and SMTP servers;

configurable notification;

concurrent execution of tests; and

intelligent maintenance of state information.

[http://www.doodlabs.com/smt/]
SMTP: The Simple Mail Transport Protocol is the fundamental protocol for handling Internet mail. The protocol was first officially documented in in RFC 821 and later modified in RFCs 1869, 1891 and 1985 along with several others. See Johnson (2000).
[http://www.dns.net/smtprd/]
SMURPH: A System for Modeling Unslotted Real-time PHenomena is a package for simulating communication protocols at the medium access control (MAC) level. It can be thought of as a combination of a protocol specification language based on C++ and an event-driven, discrete-time simulator that provides a virtual and controlled environment for protocol execution. It can be used for designing or prototyping low-level communication protocols and investigating their qualitative and quantitative properties.
A SMURPH program is written consisting of the protocol source code, a network description, and traffic specification. It is translated into C++ which is then compiled and linked with the SMURPH library to create an executable which simulates the system described in the source code. The binary can be run directly or executed under the control of a program called SERDEL (a Supervisor for Executing Remote Distributed Experiments on an LAN) which provides support for coordinating multiple simulation experiments executed in the environment of a local network of computers. SERDEL moves experiments from busy to idle machines, starts new experiments, performs checkpointing, detects failures, and restarts experiments from checkpoint files.
A source code distribution of SMURPH is available. It is written in C++ and has been compiled using both g++ and cfront. It is documented in several reports available in PostScript format, including a 190 page user's manual.
[http://www.cs.ualberta.ca/~pawel/SMURPH/smurph.html]
SMV: The Symbolic Model Verifier is a tool for checking finite state systems against specifications in the temporal logic CTL (computational tree logic). The input language is designed to allow the description of finite state systems ranging from completely synchronous to completely asynchronous as well as from the detailed to the abstract, e.g. a system can be specified as a synchronous Mealy machine or an asychronous network of abstract, nondeterministic processes. The language provides for modular, hierarchical descriptions and for the definition of reusable components. The logic CTL includes a large class of temporal properties including safety, liveness, fairness and deadlock freedom to be specified in concise syntax. SMV uses the OBDD-based symbolic model checking algorithm to efficiently determine whether specifications expressed in CTL are satisfied.
Source and binary distributions of SMV are available, with the latter including one for Linux Intel platforms. A user's manual is available in PostScript format.
[http://www.cs.cmu.edu/~modelcheck/smv.html]

Next: Sn-Sz Up: Linux Software Encyclopedia Previous: Rn-Rz Contents

Manbreaker Crag 2001-03-08