next up previous contents
Next: Sn-Sz Up: Linux Software Encyclopedia Previous: Rn-Rz

Sa-Sm

A / B / C / D / E / F / G / H / I / J / K / L / M / N / O / P / Q / R / S / T / U / V / W / X / Y / Z  

Last checked or modified: Oct. 17, 1997

[home / linux ]

 
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://www.env.gov.bc.ca/~srmb/fmebc/SAIF_FMEBC.htm]

 
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://www.env.gov.bc.ca/~srmb/fmebc/software.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://www.env.gov.bc.ca/~srmb/fmebc/softsuit.htm]

 

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://sunsite.unc.edu/pub/Linux/apps/editors/X/]

 

Samba
A suite of programs which work together to allow 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:

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

[http://samba.anu.edu.au/samba/]

 

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 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/]

 

SANTIS
This is a tool for Signal ANalysis and TIme Series processing, designed for the analysis of signals and time series data of any kind, and in particular for scientific purposes. It was designed to provide an easy-to-use graphical user interface, a high level of integration of a wide variety of signal processing functions in a common interface, state-of-the-art functionality for modern systems analysis, and to support standard hardware and software platforms. The specific features include signal handling (mouse supported clipping, signal property editing), histogram plots and 2- or 3-D phase plots of multiple signals, computation of signal statistics (mean, max, etc.), signal manipulation (subsampling, DC removal, etc.), generation of surrogate data and white noise signals, arithmetic operations (adding constants, rescaling, etc.), analytical operations (time derivatives, autocorrelation, etc.), Fourier transform (amplitude, power spectrum, etc.), linear filters (low, high and band pass, Gauss, and notch filters), wavelet transforms (decomposition, reconstruction, etc.), nonlinear dynamics methods (recurrence plots, correlation dimension, Lyapunov exponents, etc.) and advanced noise reduction methods (wavelet shrinking methods, nonlinear methods).

SANTIS is free for non-commercial users and versions are currently (4/96) available for PC (Windows 3.11, Windows NT and 95), Linux, Sun Solaris and SGI IRIS platforms. The documentation is contained in a 50+ page user's manual in PostScript format.

[http://www.physiology.rwth-aachen.de/bs/signal/santis/]

 

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; change 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; displaying IRAF images; and more.

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. [ftp://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/]

 

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/ ]

 

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://sunsite.unc.edu/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.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]

 

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/]

 

SBFOR
A Fortran package containing the most common spectral transformations based upon fast Fourier transforms. This package should be used for programming spectral methods when solving partial differential equations. It contains spectral interfaces which transform real or complex fields between the spectral and the physical spaces in various situations : e.g. Fourier2 transform of a real 2D field, Fourier2 x Chebyshev transform of a real 3D field or Fourier3 transform of a complex 3D field. This package is structured into three levels: (1) the code level at which the user needs to know only a few convivial subroutine calls; (2) the interface level which treats the successive directions of the field to be transformed by organizing calls to universal basic algorithms; and (3) the basic level which provides those universal algorithms by transforming machine dependent subroutines into a variety of basic subroutines with standard argument calls. The source code and a test program are available as is documentation in TeX format.

[ftp://ftp.cerfacs.fr/pub/Net-Sys/softs/fft/]

 

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: The expert driver routines are:

The computational routines in ScaLAPACK include:

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]

 

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
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/]

 

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://http.cs.berkeley.edu/~schenney/sced/sced.html]

 

Sceda
This is an X Window-based, constraint-oriented 3D modeler. It also provides support for splined keyframe animation where animated objects have their position, rotation and scale smoothly interpolated across multiple keyframes via a modified spline function. This is basically the sced package with added animation capabilities. It requires a UNIX/X Windows environment and was developed on a Linux box. The software is currently in the beta stage. [http://www.cyberus.ca/~denism/sceda/sceda.html]

 

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_linux/]

 

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 which means that each use of a variable is associated with a lexically apparent binding of that variable; latent types which means that 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 which means that 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:

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 (1996), Friedman (1996), and Springer and Friedman (1989). [http://www-swiss.ai.mit.edu/scheme-home.html]

 

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/]  
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. [ftp://ftp.mathworks.com/pub/contrib/v4/misc/]

 

Sciddle
A communication environment for distributed computing which enables an application to use remote procedure calls (RPCs within the PVM environment with parallelism achieved via asynchronous RPCs. No explicit message passing is needed since all data transfers occur within the RPCs. A Sciddle application can be decomposed into a client process and an arbitrary number of server processes, of which each of the latter are special PVM tasks that are ready to execute RPCs from their clients. The servers have the capability of starting other servers which gives the topology of Sciddle a tree structure. Sciddle thus combines the safety and ease of use of RPCs with the portability of PVM, with studies showing the Sciddle overhead to be minimal for applications with large data sets. A source code distribution of Sciddle is available. It is written in C and a very little Fortran 77 and can be compiled on most UNIX and multiprocessor platforms. The makefile is configured for quite a few platforms including Linux Intel. It is documented in a user's guide and several technical reports, all available in PostScript format.

[http://www.scsc.ethz.ch/www/pub/Sciddle/Sciddle.html]

 

scientific graphics
Packages with which scientific graphics can be produced, or at least those designed for such things, include:

 

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

[http://www.tc.cornell.edu/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/]

 

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:

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.ae.utexas.edu/~rwmcm/SciPlot.html]

 

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]

 

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/]

 

SCM
A Scheme interpreter written in C. [http://ftp-swiss.ai.mit.edu/~jaffer/SCM.html]

 

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; a choice of training methods including RBP and RPLA (with variable step size); and more. 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 collection of software for research on parallel programming on networks of workstations. It consists of:

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://www.rwcp.or.jp/lab/pdslab/]

 

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://www.labri.u-bordeaux.fr/Equipe/ALiENor/membre/
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 (send and receive UDP datagrams). Additional commands are supplied to simplify the implementation of network management applications: 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/]

 

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/index.html]

 

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

 

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.inter-soft.com/html/products/scriptum.html]

 

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; a coupled biological model; and more.

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.

[ftp://tashtego.rutgers.edu/pub/scrum/]

 

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. [ftp://swiss-ftp.ai.mit.edu/pub/su/scsh/]

 

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:4321/]

 

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]

 

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/]

 

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.neosoft.com/tcl/ftparchive/sorted/devel/]

 

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 which is used to increase computational efficiency and save memory; a choice of search directions including HRVW/KSH/M, AHO, and NT; information on the possible infeasibility of a given problem; and more. 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/]

 

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 XZ+ZX 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 optimization 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]

 

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]

 

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:

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:

[http://crusty.er.usgs.gov/sea-mat/]

 

searching and indexing tools
These include:

 

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: 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
Available security tools include:

 

sed
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) and Dougherty and Robbins (1997). [http://www.gnu.ai.mit.edu/order/ftp.html]
[http://sunsite.unc.edu/pub/Linux/utils/text/ ]
[http://www.wollery.demon.co.uk/ ]
[http://mickey.lcsc.edu/~steve/guckes.html ]

 

seismology software
Related packages include:

 

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]

 

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.  

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: 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 (1997) and Costales and Allman (1997).

[http://www.sendmail.org/]
[http://sunsite.unc.edu/pub/Linux/system/mail/mta/ ]

 

Sentry
A security program designed to detect and respond to port cans against a target host in real time. The features of Sentry include: A source code version is available which is configured for several systems including Linux.

[http://www.psionic.com/abacus/abacus_sentry.html]

 

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/]

 

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 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 Software Environment for the Simulation of Adaptive Modular Systems is a system for prototyping and implementing various types of nets. Its features include an object-oriented approach, a large set of C++ classes useful for building neural nets and for neurocontrol and pattern recognition, a kernel that is the framework for the C++ classes and allows run-time manipulation, construction, and integration of arbitrarily complex experiments, a graphical interface for visualization (but not for construction). A Linux port is available. The documentation includes a 220+ page reference manual and several descriptive papers. [ftp://omega.gmd.de/GMD/as/sesame/]

 

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/]

 

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: 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://amaunet.cs.uni-dortmund.de/projects/ir/SFgate/]

 

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; steam 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 the areas of: 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 files; configuration files; string manipulation and searching; file access; Internet socket access; Internet programming (e.g. MIME and CGI); server (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:

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, a large database of disks, and more. A source code distribution of sformat is available as is a Linux Intel binary. It is documented in a man page. [http://www.fokus.gmd.de/nthp/employees/schilling/index.html]

 

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

 

sgmls
This has been superseded by nsgmls which is available as part of the SP package.

 

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: An improved version of this called SGML-PowerTools is available in the same directory.

[http://www.xs4all.nl/~cg/sgmltools/]
[http://sunsite.unc.edu/pub/Linux/utils/text/ ]

 

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]

 

Shadow
A suite of tools to aid in the implementation of shadow passwords. The available tools include: 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/]

 

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/]

 

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; the capability of specifically enabling/disabling each feature at run-time; and more.

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

 

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]

 

shell
A shell is a command interpreter that manages your interaction with a UNIX system. It also provides a programming language for writing programs called shell scripts or procedures, which can be stored in files and executed like any other program. Shell scripts are used mostly for writing short programs that are combinations of often used commands, although they can be just as large and complicated as you want to make them. The default shell on most Linux systems is bash (the GNU shell),, although Linux ports are available for several other shells such as es, Osh, pdksh, rc, zsh, tcsh and ksh. See Anderson (1986), Arthur (1994), Kochan and Wood (1990), and Quigley (1997).

 

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 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/]

 

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/]

 

sh-utils
A collection of small shell programming utilities. The sh-utils collection includes basename, date, dirname, echo, env, expr, false, groups, hostname, id, logname, nice, nohup, pathchk, printenv, printf, pwd, sleep, stty, tee, test, true, tty, uname, users, who, whoami, and yes. 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/]

 

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. A source code version is available. 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. [http://w3.uwyo.edu/~morozov/sia/index.html]

 

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, the capability of embedding documents from one program into another; support for multiple interpreters including SIOD, Guile, Tcl, and C; support for drag and drop as defined by the DND protocol; support for string handling; support for 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; a selection of 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, 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://www.edu.stockholm.se/siag/]

 

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]

 

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. More details can be found on the SIMATH Web page . [ftp://ftp.math.uni-sb.de/pub/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, a graphical user interface, and more. [http://www.hep.ucl.ac.uk/%7Eajs/simcoupe/]

 

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:

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/README.html]

 

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/]

 

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.uni-passau.de/~simplex/simplex.shtml]

 

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/]

 

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/ ]

 

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, state 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: 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/]

 

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]

 

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/]

 

SkyCat
A tool for image visualization and accessing astronomy archive catalogs. The functionality of SkyCat includes: Binary distributions are available for several platforms including Linux Intel.

[http://arch-http.hq.eso.org/skycat/]

 

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:

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.

[ftp://192.32.253.5/pub/outgoing/slab/]

 

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: 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://space.mit.edu/~davis/slang.html]

 

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. [http://www.math.niu.edu/~zettl/SL2/]

 

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 component parts. These include analysis routines, benchmark and test problems, adaptive control, data analysis, filtering, identification, mathematical routines, nonlinear systems, synthesis routines, transformation routines, and utility routines.

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]

 

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]

 

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. [ftp://space.mit.edu/pub/davis/slrn/]

 

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/]

 

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:

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: 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 Eiffel
A free Eiffel compiler intended to be a complete, small and very fast. The version 0.85 (8/97) distribution includes a compiler, a pretty printer, and some other tools. 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 source code is available and has been ported to several platforms including Linux, BSD, HP-UX, SGI IRIX, XENIX, Sun Solaris, DOS, OS/2, Windows NT/95, Mac, NeXT, Amiga, and VMS. [ftp://ftp.loria.fr/pub/loria/genielog/SmallEiffel/]

 

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/]

 

SmartFiles
A library package that provides an abstraction for data files that frees the programmer from having to understand the actual storage of a file on disk in terms of raw binary or ASCII data. SmartFiles does this by using object-oriented principles to provide a mechanism for specifying file types that are to be associated with data files so that the user can interact with the data using the field abstractions and a set of extensible access routines, as opposed to interacting with a bit stream. The features of SmartFiles include:

A source code distribution of SmartFiles is available. It is written in C and portable to most UNIX flavors including Linux. Documentation includes a technical report and a set of man pages.

[http://www.cs.uwyo.edu/~haines/research/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:

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/]

 

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/ ]

 

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://samba.anu.edu.au/pub/samba/smblib/]

 

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]

 

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]

 

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/]

 

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/]

 

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.uk.linux.org/SMP/title.html]

 

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]

 

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]

A / B / C / D / E / F / G / H / I / J / K / L / M / N / O / P / Q / R / S / T / U / V / W / X / Y / Z
next up previous contents
Next: Sn-Sz Up: Linux Software Encyclopedia Previous: Rn-Rz
Steven K. Baum
7/16/1998