Next: Pa-Pm Up: Linux Software Encyclopedia Previous: Oa-Om Contents

On-Oz

Last checked or modified: Nov. 16, 1997

OOF: Object-Oriented Fortran was designed to allow portable, parallel Fortran applications to be written for distributed and parallel computers. The OOF language consists of extensions to Fortran to support the declaration and manipulation of objects in support of parallelism. Parallel programming is accomplished by defining a set of data objects and their associated functions. A program can create as many instances of different objects as are needed to solve a problem. Parallelism is implicit in that operators for different object instances are all independent and, given sufficient processors, each object in the program may have an operator simultaneously executing. Objects communicate by scheduling operators on each other with the parameters of the operator being the data to be exchanged.
A source code distribution of OOF is available. It is written in C and has been successfully compiled on a number of UNIX flavors. Compilation creates an oof binary that acts as a preprocessor and front-end for the system Fortran compiler. Documentation includes a user's guide and several technical reports.
[ftp://ftp.erc.msstate.edu/oof/]
[http://www.erc.msstate.edu/research/labs/hpcl/projects/mpi/papers/oof/oof.html]
OOF (FE): The Object-Oriented Finite element package is designed to help materials scientists calculate macroscopic properties from images of real or simulated microstructures. It consists of two parts:

ppm2oof, reads images in PPM format and assigns material properties to image features; and

oof, conducts virtual experiments on the data structures created by ppm2oof to determine the macroscopic properties.

[http://www.ctcms.nist.gov/oof/]
OOMMF: The Object-Oriented MicroMagnetic Framework is a project for developing portable, extensible, public domain micromagnetic programs and tools in a C++ and Tcl/Tk framework. OOMMF is a collection of specialized programs that together comprise a micromagnetic simulation system. The programs work together by providing services to one another via standard Internet connections.
Part of the OOMMF framework consists of several applications including:

mmLaunch, which launches, monitors and controls other OOMMF applications as well as providing user interfaces to applications which do not have their own;

mmProbEd, an interface for creating and editing micromagnetic problem descriptions which also acts a server for providing problem descriptions to running solvers;

FileSource, an application similar to mmProbEd that is used for editing description files that can't be handled by the latter program;

mmSolve2D, a micromagnetic computation engine capable of solving problems defined on 2-D square grids of 3-D spins;

mmDataTable, provides a data display service to client applications;

mmGraph, provides data display services in the form of 2-D line plots;

mmDisp, displays 2-D spatial distributions of 3-D vector fields;

mmArchive, provides a vector field data storage service; and

mmHelp, manages the display and navigation of hypertext help files.

A source code distribution of OOMMF is available. It is written in C++ and also requires Tcl/Tk for the GUI portions. It has been successfully compiled and used on Linux Intel platforms with GCC and egcs. Documentation is available in the usual formats.
[http://math.nist.gov/oommf/]
ooMPEG: A reentrant multi-threaded MPEG decoder written in C++ and based on the MPEG Library. The features include: multi-threaded decoding (i.e. one thread displaying one or more movies and one thread decoding each movie) using most available POSIX threads packages; multiple movies by making the MPEG decoder reentrant; and naive buffering of movies in memory. A source code distribution of ooMPEG is available which has been tested on several platforms including Linux Intel.
[http://www.cs.brown.edu/software/ooMPEG/]
OOMPI: An object oriented approach to MPI This is a class library the encapsulates the functionality of MPI into a class hierarchy to provide a simple, flexible and intuitive interface. The source code is available and has thus far (4/96) been implemented on top of MPI implementations LAM and MPICH. The documentation is available in PostScript format.
[http://www.mpi.nd.edu/research/oompi/]
Oorange: The Object ORiented Analysis Numerics and Graphics Environment is a software framework for experimental mathematics. Oorange is a set of high level tools loosely connected via a manager which passes messages among the tools. Each of the tools has an associated graphical user interface in which tasks can be performed. The top level tools are the Network Manager, the Script Editor, the Inspector Manager, and a data viewer. The package is built using the Oorange Objective C class library.
The Network Manager controls a data flow type of network in which data flows along the edges of the graph of the network with each node representing some action or transformation applied to the data. Oorange replaces the typical action-based nodes in such networks with object-based nodes (i.e. instances of Objective C objects) and supplies an interpreted script at each node. This leads to a modified data flow paradigm in which object pointers are passed along the nodes joined by an edge rather than data being passed along the edges. Update procedures are not built in to the nodes but rather are provided by the interpreted scripts. Each node in a network can itself contain sub-networks, and a user can build networks from scratch using the Manager. The Script Editor displays the (Tcl) scripts associated with the nodes, with the scripts containing Objective C method calls directed to the various objects at the node. The Editor consists of a text editor with an attached Tcl interpreter which can be used to test the scripts before they're used in the network. The Inspector Manager allows the editing of node features or contents other than the Tcl scripts. The IM queries an object at a node for a Tcl command for inspecting itself and evaluates this command to create an inspector panel consisting of Tk widgets which display and edit the state of an object. The selection of another node causes the old panel to vanish and a new one to appear, with any changes made automatically update. It was designed this way to prevent a proliferation of secondary panels. A 2- and 3-D viewer is provided which makes use of a 3-D class library modeled on Open Inventor, with support for VRML planned.
The Orange Objective C class library has a base class called OoObject and a set of collection classes (including lists, linked lists, hash tables, and stacks) which inherit from OoObject. The main class of the infrastructure tools used by the network manager is OoNode. The node contents are implemented with a class called OoNodeContents. There is a general purpose data grid class called OoDataGrid which can be configured for as a multiple dimension array with entries at each point. This works closely with the OoFunction class which is an object wrapper for a C function with arbitrary input and output and which can be compiled and linked into a running Oorange session. There are additional classes for color and three dimensional shapes. There are also C libraries for linear algebra, complex numbers, quaternions, and utility functions like error reporting and memory allocation.
The Oorange package is built on top of GNU Objective C, Tcl/Tk, [incr Tcl], and OpenGL. Perl is also required for various utility tasks. Binary distributions are currently (5/97) available for SGI IRIX and Linux Intel platforms. Much documentation is available including a primer and tutorials for the various program components. These are all available in both PostScript and PDF format.
[ftp://ftp-sfb288.math.tu-berlin.de/pub/oorange/]
[http://www-sfb288.math.tu-berlin.de/oorange/]
[http://www-sfb288.math.tu-berlin.de/~konrad/articles/oorange/]
OPAL: A research project into a programming environment in which advanced language concepts and formal development methods can be used for creating production-quality software. The OPAL language, which integrates concepts of algebraic specification and functional programming, is at the core of the project. The OPAL Compilation System (OCS) consists of a set of tools supporting the language.
OPAL is a strongly typed, higher order, functional language along the lines of ML and Haskell which also has the algebraic characteristics of such languages as CIP-L and OBJ. The language features include:

separated signature and implementation parts of structures (i.e. modules),

selective importing of items from structures,

parameterized structures,

free constructor views on sorts which allows pattern-based function definitions,

full overloading of names, and

a puristic scheme language with no built-in data types except booleans and denotations.

The OCS consists of a batch compiler OC built from a front-end OC1 and a back-end OC2, a standard library, a maintenance system based on make, and documentation. The front-end OC1 analyzes the OPAL code and generates an intermediate, enriched second-order polymorphic lambda-calculus as wel as diagnostics. The back-end OC2 compiles the lambda-calculus to standard C, implements a residual garbage collector, performs some source-level optimizations, and propagates on demand implementation-dependent information across compilation unit boundaries for inter-module optimizations. The library consists of over 100 structures supply basic data types, realizes a monadic I/O approach, implements agents (i.e. threads) which concurrently execute monadic commands and communicate via service access points in a client/server style, supports POSIX-like access to system resources, and is mostly formally specified. The maintenance system supports the management of small to very large scale programs consisting of many subsystems in conjunctino with ShapeTools, a configuration management system.
A source code distribution of OPAL is available. It can be compiled and installed on many UNIX systems via the supplied autoconfig script. The documentation includes a tutorial, a language definition report, a user's guide, a library guide, and some other documents, all available in PostScript format. Ancillary programs available for the system include: DOSFOP, a documentation system for OPAL projects which supports literate programming; and OpalWin, a GUI library implemented on top of Tcl/Tk which uses agent communication.
[http://uebb.cs.tu-berlin.de/~opal/]
OPBDP: A C++ program for solving (non)linear 0-1 (or pseudo-Boolean) optimization problems with integer coefficients. OPBDP is a Davis-Putnam based enumeration algorithm for linear pseudo-Boolean optimization. A linear 0-1 term can either be maximized or minimized with respect to a set of linear constraints over 0-1 variables. All linear 0-1 constraints are transformed to inequalities, and the optimization problem is solved by solving a sequence of satisfiability problems of a set of linear 0-1 constraints. The search tree is explored depth first, and each time a satisfiable solution is found the value of the objective function under this solution is calculated and the constraint added. Enumeration is continued until unsatisfiability is detected, with the previous solution then the optimal solution. See ().
[http://www.mpi-sb.mpg.de/units/ag2/software/opbdp/]
Open AFS: A distributed filesystem that enables users to share and access all the files stored on a network of computers as easily as they access the files stored on their local machines. Open AFS uses a client/server model wherein files are stored on a subset of the available machines called file servers, and can be retrieved by the other network machines called clients. The file server machines separately run several server processes, i.e. a number of distinct, specialized services including handling file requests, tracking file locations, managing security, etc. Other key features of Open AFS include:

an administratively independent site running Open AFS is called a cell;

cells can be combined to form all of the local filespaces into a global filespace with transparent access, i.e. the pathname for the file is the same for all no matter where it is actually stored;

files are grouped into volumes to enable the distribution of files across many machines while maintaining a uniform namespace, i.e. a volume is a unit of disk space that functions like a container for a set of related files;

commonly used volumes can be replicated on server machines, i.e. identical collections of popular read-only files can be made available via several server machines;

caching is used to improve efficiency on client machines, with the up-to-date status of the cached files maintained via callbacks;

the use of mutual authentication to guarantee that servers provide information only to authorized clients and that clients only receive information from legitimate servers; and

users can build access control lists (ACLs) for their personal directories to selectively grant or deny access to individual files.

[http://oss.software.ibm.com/developerworks/opensource/afs/]
OpenAL: An open source platform for all-purpose high-fidelity sound that intends to become the audio counterpart to the OpenGL 3-D graphics API. The goal is to create a powerful, elegant C-based API for creating rich, high-quality 3-D sound content with cross-platform compatibility. OpenAL is a mid-level library meant to sit on top of the existing low-level libraries of vendors.
[http://www.openal.org/home/]
OpenBasic: A project to provide a commercial quality business Basic interpreter and run-time system. This is based on the original Basic Four Business Basic and its more recent derivatives. Project releases are available under the GPL.
[http://www.openbasic.org/]
OpenBIOS: A project to create a free BIOS for PCs.
[http://www.freiburg.linux.de/OpenBIOS/]
OpenCA: A project to develop a robust, full-featured, Open Source Certification Authority (CA) that implements the most useful protocols with full strength cryptography worldwide.
[http://www1.openca.org/]
Open Cascade: A set of reusable C++ object libraries for producing domain-specific graphic modeling applications. The libraries are grouped into six modules:

Foundation Classes divided into libraries for kernel classes, math utilities, and basic data storage that provide a variety of general purpose services including:

primitive types, strings and other types of quantities;

automated management of heap memory;

exception handling;

classes for manipulating aggregates of data;

math tools such as vectors, matrices and primitive geometric types;

basic services for saving data in ASCII files.

Modeling Data Classes divided in libraries for 2-D geometry, 3-D geometry, geometry utilities and topology that provide:

2-D geometric data structures including Bezier, B-spline and offset curves;

3-D geometric data structures;

standard high-level functions in 2- and 3-D geometry including direct construction algorithms, interpolation of points sets to form a curve, calculations of points on a 2- or 3-D curve, etc.; and

a topological library for building topological data structures from components such as vertices, edges, wires, faces, shells, solids and compound solids.

Modeling Algorithms Classes organized into:

geometric tools for calculation curve and surface intersections, project points onto 2- and 3-D curves, construct lines and circles from constraints, etc.;

topological tools including algorithms for tesselating shapes, validing shapes, and determining the local and global properties of shapes;

tools for the construction of primitives such as prisms, cylinders, cones and tori;

tools for performing Boolean operations such as common, cut, fuse and section to create new shapes from old ones;

algorithms for constructing fillets and chamfers on shape edges;

algorithms for the creation of offset shapes and variants, tapered shapes, sewing and the creation of sweeps;

algorithms for building both form and mechanical feature topologies on shapes; and

algorithms for hidden line removal.

Visualization Classes for creating graphic presentations from geometric models organized into:

classes for manipulating graphic primitives in 2- and 3-D;

an Interactive Context class for piloting 3-D visualizations and selections;

an Interactive Object class connecting the underlying reference geometry of a model to its graphic representation;

a Graphic Attributes Manager class that stores the graphic attributes for specific interactive objects; and

Selection Filters for refining the dynamic detection context to be put into effect.

3-D visualization services including selection and presentation of 3-D data structure;

Data Exchange classes providing services that allow applications to exchange data with other applications including:

a STEP-AP214 Interface class for reading STEP models and writing Open CASCADE applications in STEP format;

an IGES Interface classes for reading/writing IGES 3-D models; and

a DXF/SAT interface interface class for reading Autocad models in DXF and SAT formats.

Application Framework classes for rapid application development whose features include:

handling application data by the mechanism of attributes;

organizing attributes by development needs;

managing multiple documents;

read-to-use modeling data attributes common to CAD/CAM applications;

data storage services; and

an undo/redo function.

[http://www.opencascade.org/]
OpenCms: A project to create the first professional level open source content management system (CMS). OpenCms is intended to hide the complexity involved in Internet publishing from the end users, i.e. allow them to concentrate on creating content. OpenCms includes all the functionality needed to maintain a web site including:

easy to use editors;

integrated user and group management;

different security levels for access to specific resources;

separation of content and design;

workflow and task management;

integrated project management; and

an open and documented API for the extension of the system.

[http://www.opencms.org]
OpenC++: A toolkit for C++ translators and analyzers that was designed to enable users to develop those tools without using a parser or type systems. OpenC++ can be used to develop, e.g. a C++ translator for implementing an extension to C++ or for optimizing the compilation of class libraries. The method involves writing a meta-level program, written in C++ and defining a small number of classes, which specifies how to translate or analyze a C++ program. This program is compiled by the OpenC++ compiler and linked to the compiler itself as a compiler plug-in. The resulting compiler translates or analyzes a source program as is specified in the meta-level program.

The meta-level program is written according to a specification called the OpenC++ MOP or Metaobject Protocol. This code is translated by class metaobjects and assembled again into a complete C++ program. The pieces of code in the program are represented by Ptree metaobjects in the form of a parse tree, and although the metaobjects are identical to regular C++ objects they exist only in the compiler and represent a meta-aspect of the base level program. This is why they're called metaobjects. The OpenC++ MOP is unique in that the class metaobject doesn't interpret the base level program in the customary way but rather translates that program at compile time to the customized behavior is implemented.
A source code distribution of OpenC++ 2.5.* is currently (5/98) available. This version has been successfully installed on Sun SunOS/Solaris, FreeBSD and Linux Intel platforms. A manual is available in HTML and PDF format.
[http://www.softlab.is.tsukuba.ac.jp/~chiba/openc++.html]
OpenCV: The Open Source Computer Vision library is designed for real time computer vision applications, e.g. human-computer interaction (HCI), object identification, segmentation and recognition, motion tracking, mobile robotics, etc. The extensive OpenCV library contains functions for:

creating, allocating and destroying images;

data structures including static types and dynamic storage;

finding, displaying, manipulating and simplifying image contours;

geometrical operations including line and ellipse fitting, convex hulls and contour analysis;

feature recognition including first and second image derivatives, lines via Canny and Hough transforms, and corners via finding and tracking;

finding image statistics including mean, STD, min, max, moments, etc.;

image pyramids with color/texture separation;

morphological operations including erosion, dilation, opening and closing;

background differing and distance transforms;

thresholding;

flood filling;

camera calibration;

view morphing via 8-point an algorithm and epipolar alignment of images;

motion templates including overlaying silhouettes;

active contours;

optical flow;

Kalman and condensation estimators;

histograms for recognition;

matrix mathematics;

eigenvalue and eigenfunction calculations;

embedded HMMs;

drawing primitives; and

various system and utility functions.

The OpenCV package is built on top of the Image Processing Library (IPL). It is also available and includes functions for:

image creation and access (same image header used for both libraries);

image arithmetic and logic operations;

image filtering;

linear image transformation;

image morphology;

color space conversion;

image histogram and thresholding;

geometric transformations; and

image moments.

[http://www.intel.com/research/mrl/research/cvlib/]
OpenDX: An Open Source version of IBM's Visualization Data Explorer, a general purpose package for data visualization and analysis. DX employs a data-flow driven client/server execution model and provides a graphical program editor allowing the creation of visualizations via a point and click interface. Applications can be built on top of parts of DX, allowing custom applications to be developed using DX as the computational and rendering engine.
[http://www.opendx.org/]
OpenEV: A library and reference application for viewing and analyzing raster and vector geospatial data. The features of OpenEV include:

handling both raster and vector data;

supporting 2- and 3-D display;

gracefully handling large (e.g. gigabyte) raster datasets;

support for multi-channel and complex raster datasets;

understanding and interpreting georeferencing information and providing on-the-fly reprojection of datasets;

view manipulation functions (pan, zoom, rotate) at interactive frame rates; and

a powerful image analysis tool.

This open source package is built on top of OpenGL, Python, GTK+, GDAL and PROJ.
[http://openev.sourceforge.net/]
OpenGL: The Open Graphics Library is a standard which provides a software interface for applications to generate 2-D and 3-D computer graphics. It is designed to be independent of operating systems, window systems, and hardware operations. The interface consists of a set of several hundred procedures and functions which specify objects and operations involved in producing graphical images, with an emphasis on 3-D images. The functions available include modeling, transformations, color, lighting, smooth shading, texture mapping, NURBS, fog, alpha blending, and motion blur. OpenGL was originally developed by SGI as a successor to its IRIS GL graphics software, but is currently controlled by an industry consortium known as the OpenGL Architectural Review Board (ARB) composed of DEC, IBM, Intel, Microsoft, and SGI. See OpenGL Architecture Review Board (2000).
Freely available partial implementations of the OpenGL standard include

Mesa and

Ygl.

Other packages related to OpenGL include:

GGK,

GLEX,

GLX,

GLUT,

GtkGLArea, an OpenGL widget for GTK+;

MET++,

OpenGL4Java,

OpenRM, a scene graph API that uses OpenGL as a graphics platform;

Tecate,

TIGER,

TkSM,

Togl,

V,

VolVis, and

Vtk.

[http://www.opengl.org/]
[http://www.sgi.com/Technology/openGL/index.html]
OpenGL4Java: A package containing Java OpenGL bindings. The source files or a precompiled library are available for Linux Intel, Sun and Win32 platforms. The JDK 1.1.1 is required for Linux platforms.
[http://www.magma.ca/~aking/]
OpenGUI: A high-level C/C++ graphics library built upon a fast, low-level x86 assembly graphics kernel. OpenGUI provides 2D drawing primitives and an event-driven windowing API for easy application development, and it supports the BMP image file format. The library consists of three layers:

a hand-coded, fast assembler kernel that does most of the work;

a middle layer implementing the API for drawing graphics primitives;

a top layer written using C++ that offers a complete object set.

The features of OpenGUI include:

support for using the keyboard and mouse as event sources and the Linux framebuffer/svgalib as drawing backends

support for Mesa;

resolutions ranging from 320x200 to 1600x1200;

an object-oriented multi-platform API (DJGPP, WATCOM, GCC, LINUX, QNX);

a full application development framework; and

a tool for interactive code generation.

[http://www.tutok.sk/fastgl/]
OpenH323: A project to create a full-featured, interoperable, open source implementation of the H.323 teleconferencing protocol. The software available from the project includes a library and several applications built using the library, i.e.

a class library implementing the H.323 protocol;

OhPhone, a text mode telephony client application;

Open Phone, a GUI-based telephony client application;

OpenAM, an H.323 answering machine;

PSTN Gateway, an H.323 to PSTN gateway that allows an H.323 client to receive and make calls on the Public Switched Telephone Network, i.e. the regular telephone system; and

Dump323, a program to dump H.323 protocol data units.

The audio codecs supported are G.711 and GSM, and the video codec H.261 (all in software). Source and binary distributions are available for Linux.
[http://www.openh323.org/]

OpenGatekeeper

An open source H.323 gatekeeper based on the OpenH323 project. OpenGateKeeper supports all the basic features of an H.323 Gatekeeper such as registration, admissions and access control, address translation, and bandwidth monitoring and control. It also has some advanced features including:

gatekeeper-routed calls;

support for H.323v2 alias types (e.g. party number, URL, transport ID and email address);

support for gateway prefixes;

registration and call activity logs;

a neighbor gatekeeper database; and

registration time to live.

[http://www.opengatekeeper.org/]
OpenJava: A extensible language based on Java in which the extended features are specified by a meta-level program given at compile time. OpenJava can be use to develop better libraries as well as to develop extended versions of Java. The meta-level programs (as distinguished from the base-level programs written in OpenJava) extend Open Java via an interface called the OpenJava MOP or Metaobject Protocol.

The OpenJava compiler implements a three stage process: a preprocessor, a source to source translator from OpenJava to Java, and the back-end Java compiler. The MOP is an interface to control the translator in the second stage, specifying how an extended feature of OpenJava is translated into regular Java code. Extended features of OpenJava are supplied as add-on software to the compiler consisting of the meta-level program and runtime support code, with the latter providing classes used by the base-level program translated into Java, i.e. the base-level program is first translated into Java by the meta-level program and then dynamically linked with the runtime support code.

A source code distribution of OpenJava is available. It is written in Java and requires JDK 1.1 or better. Documentation includes an online tutorial and an API reference guide.
[http://www.softlab.is.tsukuba.ac.jp/~mich/openjava/]
OpenLDAP: A collaborative effort to create a commercial-grade, fully featured, and Open Source suite of LDAP applications and development tools. The suite is currently (9/98) in version 1.0 which includes:

slapd, a standalone LDAP server;

slurpd, a standalone LDAP replication server;

ldapd, an LDAP to X.500 gateway server;

libraries implementing the LDAP protocol; and

various utilities, tools and sample clients.

A source code distribution is freely available.
[http://www.OpenLDAP.org/]
OpenMap: A JavaBeans-based toolkit for building applications and applets needing geographic information. The core is a set of Swing components that understand geographic coordinates which can show map data and handle user events for manipulating that data. A source code distribution of this Open Source software package is available.
[http://openmap.bbn.com/]
OpenMath: A standard for communicating mathematical objects between computer programs. The standard has multiple bindings, notably to SGML and HTML, as well as efficient binary representations. It is also extensible to allow for the frequent invention of new mathematical concepts.

[http://www.openmath.org/]
[http://www.nag.co.uk/projects/OpenMath.html]

Java OpenMath Library

A set of packages that implement the basic OpenMath standard in Java. This requires JDK 1.1 or greater.

[http://pdg.cecm.sfu.ca/openmath/lib/]
OpenMP: A specification for a set of compiler directives, library routines, and environment variables that can be used to specify shared memory parallelism in Fortran and C/C+++ programs. This project and specification consolidates several vendor-specific implementations into a single syntax and semantics to provide single-source portability for shared-memory parallelism. It also addresses the inability of previous implementations to deal with coarse-grain parallelism.
[http://openmp.org/]
OpenNMS: A project to build a fully distributed network management platform with enterprise and element management capabilities. This is being built with Java, C, C++, XSL and ODBC. The planned functionality includes:

ICMP discovery and polling for interface availability;

SNMP capability checking;

HTTP, SMTP, DNS and FTP polling for service availability;

a fully distributed client/server architecture;

a Java real-time console for displaying instantaneous network status;

XML using XSL style web access and reporting;

business view partitioning of the network using policies and rules;

a graphical rule builder;

Java configuration panels;

redundant and overlapping pollers and a master station; and

repeating and one-time calendaring for scheduled downtime.

Source code snapshots of this currently (5/00) alpha project are available.
[http://www.opennms.org/]
OpenPTC: A cross-platform graphics API developed to make writing games and demos easy and the resulting application fast. It is designed for high-speed graphics applications and will take advantage of whatever hardware acceleration is available for blitting and clearing operations. This library accesses the framebuffer of a specific platform, manages offscreen buffers, and converts the buffers to whatever video format is available. Basically, it provides an array of pixels to draw to and the means to quickly output them to the display device. It also provides other features such as basic keyboard input and a high resolution timer. This is available under the LGPL.
[http://www.gaffer.org/ptc/]

Pexl

The PTC extension library aims at providing additional functionality not found in OpenPTC.
[http://www.ping.be/gpcafe/]

Titan

A portable image handler for OpenPTC. This fast and portable library for gaining access to the display buffer can load most images from TGA, BMP, PCX, PNG and JPG files, and save to TGA, PNG and JPG files. Images can be loaded from either disk or directly from memory for use in a virtual file system.
[http://www.geocities.com/SiliconValley/Station/7463/]
OpenRM: A scene graph API that uses OpenGL as a graphics platform and graphics hardware acceleration. This can be used to build portable 2-D/3-D/stereo high performance graphics, virtual reality, visualization applications, and games for UNIX and Win32 platforms. A scene graph model is a useful way to organize data for rendering in a way that is especially efficient for graphics display engines. It also allows you to easily reuse code and ideas from other sources. The planned features of OpenRM include:

configurable multipass rendering, e.g. 3-D opaque, 3-D transparent, or 2-D;

full attribute inheritance along the scene graph depth;

binocular analglyph and multibuffered stereo;

picking of objects;

first class support for user-written immediate mode primitives;

cones, cylinders and spheres created using triangles;

direct volume rendering;

full read access to render state in node callbacks;

model switching callbacks (along with application-provided code) for implementing LOD manipulation;

node traversal masks for detailed and fine rendering control;

multiple views and/or viewports within a window for creating multiple views of a 3-D scene or annotation displays;

OpenGL vertex arrays and display lists for built-in primitives used wherever possible;

sprite and bitmap primitives in 2- or 3-D;

imaging model support for index-color or true color image data in textures and sprites as well as scale/bias;

hardware-assisted imaging operations including resizing;

cross-platform compatibility, i.e. X11 and Win32;

direct control over the depth buffer including background images;

direct control over the color planes of the framebuffer including background tiles;

clipping planes; and

use as a standalone application or in combination with other applications or toolkits that provide event loop management.

[http://openrm.sourceforge.net/]
OpenSched: A project scheduler that reads a project description file contain information about:

tasks that must be accomplished;

resources that can work on those tasks; and

work that has already been completed.

It then schedules resources to work on tasks and can produce several types of reports including:

a summary of all tasks and task dependencies;

a work schedule for the entire project;

a work schedule for each resource;

GANTT charts; and

weekly and monthly work summaries for each resource.

The reports are produced as LaTeX source code. A source code distribution of this is released under the GPL. It is written in C and can be used on generic UNIX systems with the appropriate prerequisites.
[http://www.m-tech.ab.ca/download/sched/]
OpenScheme: A Scheme interpreter and compiler. This implementation has been extended with a CLOS-like object-oriented programming interface that uses dynamic binding similar to that seen in Smalltalk. Other features of OpenScheme include:

a precise mathematics library that implements integers, rational numbers and complex numbers;

a large set of libraries containing characters, strings, vectors, lists, regular expressions, timers, a console interface, primitive graphics, and a unified OS interface;

easy extensibility;

a symbolic debugger for setting breakpoints, etc.;

a foreign interface for linking other dynamic libraries;

a mechanism for directly integrating C programs; and

cross-platform development, i.e. UNIX and Windoze.

This was mostly developed on a Linux platform and freely available binary and source distributions are available. Documentation is contained within separate user's guides and reference manuals.
[http://linux-kheops.com/erian/osm/]
OpenSelf: An implementation of the Self language. This is a rewrite from scratch of the Self Virtual Machine (VM) that aims to be smaller and better integraable with the OS and other utilities.
[http://www.linuxsupportline.com/~openself/]
Open Source: Other people have thought long and hard about the definition and meaning of Open Source, so I'll offer both a description and a definition verbatim from the official Open Source site. The introductory description states: ``The basic idea behind open source is very simple. When programmers on the Internet can read, redistribute, and modify he source for a piece of software, it evolves. People improve it, people adapt it, people fix bugs. And this can happen at a peed that, if one is used to the slow pace of conventional software development, seems astonishing. We in the open-source community have learned that this rapid evolutionary process produces better software than the traditional closed model, in which only a very few programmers can see source and everybody else must blindly use an opaque block of bits.''
The official Open Source Definition is a multi-part beastie prefaced with a statement that open source doesn't just mean access to the source code. The distribution terms of open-source software must comply with the following criteria:

Free Redistribution
The license may not restrict any party from selling or giving away the software as a component of an aggregate software distribution containing programs from several different sources. The license may not require a royalty or other fee for such sale.

Source Code
The program must include source code, and must allow distribution in source code as well as compiled form. Where some form of a product is not distributed with source code, there must be a well-publicized means of obtaining the source code for no more than a reasonable reproduction cost - preferably, downloading via the Internet without charge. The source code must be the preferred form in which a programmer would modify the program. Deliberately obfuscated source code is not allowed. Intermediate forms such as the output of a preprocessor or translator are not allowed.

Derived Works
The license must allow modifications and derived works, and must allow them to be distributed under the same terms as the license of the original software.

Integrity of The Author's Source Code
The license may restrict source-code from being distributed in modified form only if the license allows the distribution of ``patch files'' with the source code for the purpose of modifying the program at build time. The license must explicitly permit distribution of software built from modified source code. The license may require derived works to carry a different name or version number from the original software.

No Discrimination Against Persons or Groups
The license must not discriminate against any person or group of persons.

No Discrimination Against Fields of Endeavor
The license must not restrict anyone from making use of the program in a specific field of endeavor. For example, it may not restrict the program from being used in a business, or from being used for genetic research.

Distribution of License
The rights attached to the program must apply to all to whom the program is redistributed without the need for execution of an additional license by those parties.

License Must Not Be Specific to a Product
The rights attached to the program must not depend on the program's being part of a particular software distribution. If the program is extracted from that distribution and used or distributed within the terms of the program's license, all parties to whom the program is redistributed should have the same rights as those that are granted in conjunction with the original software distribution.

License Must Not Contaminate Other Software
The license must not place restrictions on other software that is distributed along with the licensed software. For example, the license must not insist that all other programs distributed on the same medium must be open-source software.

Several licenses are considered to conform to the Open Source Definition including the GPL, LPGL and QPL. There are others I've forgotten and still others whose conformance is a matter of the sort of cantankerous debate that makes the Internet such a fun and interesting place.
[http://www.opensource.org/]
Open Source Audio Library: A project to implement a set of C++ classes that include all the functionality needed to build an audio application. The library is built on a set of core classes that provide the basic functionality, the new clases to operate on sound data derived from these. A file base class (aflibFile) defines the API for any device or file class to be developed. There are currently (8/00) seven derived classes implemented as dynamically shared objects for handling various formats including OSS, WAV, AU, AIFC, AIFF and MP3 files. Proprietary formats can be handled as binary pluggable modules.
The worker classes that do the actual calculations include:

aflibAudioSampleRateCvt, converts audio sample rates;

aflibAudioPitch, changes audio pitch;

aflibAudioConstantSrc, an audio test source;

aflibAudioEdit, for audio editing;

aflibAudioRecorder, an audio timer recorder;

aflibAudioSpectrum, an audio VU meter and spectrum display;

aflibAudioMixer, an audio mixer; and

aflibAudioFile, for reading or writing data to and from devices or files.

Various utility classes will also be provided, e.g. aflibFFT, for performing FFTs on audio samples and aflibEnvFile, for user environment storage and retrieval. This is currently (8/00) in alpha code phase and available as open source.
[http://osalp.sourceforge.net/]
OpenSS7: An open source implementation of the Signaling System No. 7 (SS7) protocol stack, a telephone network and next generation networking signaling system. OpenSS7 aims to be the most robust UNIX implementation of the SS7 protocol stack at Levels 2 through 4.
[http://www.openss7.org/]
Open Telecom: A project to develop Open Source software for computer telephony that specifically focuses on the hot-swap and circuit switching capabilities of systems built with CompactPCI and the H.110 CT Bus.
[http://www.opentelecom.org/]
OpenThought: A web application engine that doesn't require loading new pages, i.e. all communication between the browser and the server is done in the background using XML, with the changes displayed automatically using DHTML. OpenThought requires Apache 1.3.X, mod_perl 1.2.X and Perl 5.6.0. Several additional Perl modules are also required.
[http://openthought.net/]
OpenThreads: A user-level threads package that supports common thread abstractions and a well-defined meta-interface for altering the behavior of these abstractions. OpenThreads allows system-level programmers to use high-level abstractions without having to sacrifice performance, flexibility, or portability. This uses the Open Implementation software design technique for writing modules that are both reusable and very efficient for a wide range of clients.
[http://www.cs.uwyo.edu/~haines/research/ot/]
OpenVault: A package of mediation software that helps storage management applications manage removable media. OpenVault arbitrates access to removable media devices by allocating and deallocating these devices to various applications. This provides middleware that raises the level of abstraction to enable the rapid deployment of removable media libraries, drives, systems, and client applications. Storage applications that can use OpenVault include:

tape access, e.g. tar or cpio;

backups;

long-term archiving of data;

hierarchical storage management, i.e. automatically staging data to the most cost-effective medium;

CD-ROM jukeboxes or information libraries; and

broadcast libraries containing videotapes.

The OpenVault architecture consists of several components including:

a Media Library Manager (MLM) server process that mediates among the other components;

any number of client applications that can make requests using the Client API (CAPI);

an administrative interface that makes system requests in a similar but less restrictive Administrative API (AAPI);

a persistent database that keeps track of cartridges and other system components;

a Library Control Program (LCP) for each removable media library controlled by the MLM server, which talks to the MLM using the Abstract Library Interface (ALI); and

a Drive Control Program (DCP) for each drive controlled by the MLM server, which talks to the MLM using the Abstract Driver Interface (ADI).

The code for OpenVault has been released as Open Source, and is currently (8/99) available although not yet fully ported to anything other than various versions of IRIX. The documentation includes application programmer, infrastructure programmer, and operator and administrator guides, each available in both HTML and PDF format.
[http://oss.sgi.com/projects/openvault/]
Openwall: A kernel patch containing a collection of security-related features for the Linux kernel including:

a non-executable user stack area to protect against some buffer overflow exploits;

not allowing regular users to create hard links to files they don't own, i.e. restricted links in /tmp;

restricting writes into trusted FIFOs to make data spoofing attacks harder;

restricting permissions on /proc such that non-root users can only see their own processes and nothing about active network connections;

ensuring that file descriptors 0, 1 and 2 are always open when SUID/SGID binaries are started;

enforcing process limits on execve(2) calls;

destroying shared memory segments not in use; and

allowing only root to bind sockets to addresses of privileged aliased interfaces.

[http://www.openwall.com/linux/]
operating systems: Operating systems, proposed OS projects and OS-related software that is mostly related to the x86 architecture. It's quite amazing how many operating systems you can find that will run on x86 machines that aren't cobbled together by Microshaft. Sites with OS-related information include:

Current OS Projects and Research
http://www.cs.arizona.edu/people/bridges/oses.html

Operating Systems on the Web
http://home.t-online.de/home/Sven.Paas/os.htm

AltOS
http://www.altos.org.uk/

Review of Operating Systems
http://www.tunes.org//Review/OSes.html

Related items in the list include:

Amoeba, a microkernel-based OS that transforms a collection of workstations into a transparent distributed system;

AROS, a project to develop an OS compatible with AmigaOS 3.1;

Choices, an object-oriented OS;

DOSEMU, a DOS emulator for Linux;

eCos, an embeddable real-time OS;

EROS, a small, real-time OS providing orthognal persistence;

exopc, an exokernel-based OS;

FreeBSD, a free version of BSD;

FreeDOS, a project to develop a MS-DOS compatible OS;

Hurd, a GNU OS project based on the Mach microkernel;

Inferno, a network OS for heterogeneous networks;

JOS, a Java-based OS;

Linux, the one and only OS;

Mach, a microkernel upon which several OS projects are based;

MINIX, a microkernel-based free UNIX clone;

MOSIX, a set of kernel enhancements for Linux to support cluster computing;

NachOS, an instructional OS environment;

NetBSD, a free version of BSD;

PicoBSD, a one floppy version of FreeBSD;

Plan 9, the precursor to Inferno;

RTEMS, a real-time kernel for embedded applications;

Scout, an OS targeted at network appliances;

SimOS, an OS simulator for the MIPS R4000/10000 and Digital Alpha processors;

SPIN, an OS that blurs the distinction between kernels and applications;

2K, a component-based network-centric OS;

UNIX, grandpa OS; and

VSTa, a microkernel-based OS.
OPIE: One-time Passwords In Everything is an implementation of the One-Time Password (OTP) system currently (2/99) being considered as an Internet standard. OPIE provides a one-time password system secure against passive attacks. This is derived in part from and interoperable with the Bellcore S/Key Release 1 software, although several additions and modification have been made including:

a modified BSD FTP daemon that does OTP;

a version of su that uses OTP by default;

support for both MD4 and MD5 (with a more portable version of the former);

a revised opiekey program for supporting both MD4 and MD5; and

optional transition mechanisms for preventing potential back doors.

A source code distribution is available.
[ftp://ftp.inner.net/pub/opie/]
[http://www.ipv6.nrl.navy.mil/ist/otp]
OPNML: A set of Matlab functions for postprocessing the output files created by a series of finite element shallow-water hydrodynamic simulation models.
[http://www.opnml.unc.edu/OPNML_Matlab/]
OPP: The Odin Plus Plus class library is a C++ class library freely available via the GPL. It is currently in the early stages of development but aims to provide:

an object-oriented framework for cross platform application development;

the functionality found in the Rogue Wave class libraries;

an interface familiar to Java programmers and suitable for easily porting Java code to C++;

a multithreaded embedded object database and corresponding server; and

an object-oriented container framework.

A source code distribution is available which currently requires egcs for compilation.
[http://www.odin-consulting.com/OPP/]
opt_depot: A suite of Perl scripts for managing installed software across a wide range of client systems. This makes it possible to keep all files associated with a program together in one directory so installation and deinstallation are simple. This allows the files needed to run a piece of software to be organized into discrete packages and to keep them physically separate. The software is installed into packages by the sysadmin and then opt_depot manages a set of symbolic links to make it accessible to the end users via the PATH, MANPATH and library path variables.
The component scripts of opt_depot are:

opt_depot, the core script responsible for creating and maintaining links from the subdirectories in the software base directory to the subdirectories in each package in the depot directory;

opt_clean, removes links to files that are either nonexistent or have been excluded;

opt_link, creates symbolic links going from the depot directory to packages located in separate package archives in a networked environment;

opt_setup, invokes the previous three commands with a single command to automate the process, e.g. via cron; and

opt_nuke, a self-destruct program that removes all links created by opt_depot.

A source code distribution is available.
[http://www.arlut.utexas.edu/csd/opt_depot/opt_depot.html]
OPTIMIX: An optimizer generator that can be used to generate program analyses and transformations. The basic idea underlying OPTIMIX is to regard all of the information in the intermediate representation of a compiler as a set of relational graphs. This leads to representing program objects, abstract syntax tree nodes, and intermediate code instructions as nodes, and predicates of these entities as relations. Program analysis and transformation will then consist of rewriting graphs. Program analysis typically entails enlarging graphs with new edges representing information, while code transformation involves rewriting graphs by deleting and attaching subgraphs. This makes the optimization process a sequence of graph rewrite system applications that starts with an intermediate representation given by the front-end and ends with a modified intermeidate graph handed over to the back-end for code generation. OPTIMIX can currently (2/99) input and produce Java code.
Source and binary version of the OPTIMIX package are available, with one of the latter being for Linux Intel systems. Compilation requires both Cocktail and Perl 5. Documentation includes a language manual and a tutorial.
[http://i44s11.info.uni-karlsruhe.de:80/~assmann/optimix.html]
optimization software: Informative sites concerned with various aspects of numerical optimization include:

Linear Programming FAQ
[http://www-unix.mcs.anl.gov/otc/Guide/faq/linear-programming-faq.html]

Nonlinear Programming FAQ
[http://www-unix.mcs.anl.gov/otc/Guide/faq/nonlinear-programming-faq.html]

Mathematical Programming Glossary
[http://www-math.cudenver.edu/~hgreenbe/glossary/glossary.html]

NEOS Optimization Tree
[http://www.mcs.anl.gov/home/otc/Guide/OptWeb/]

Global Optimization
[http://solon.cma.univie.ac.at/~neum/glopt.html]

Tom Cavalier's Optimization Links
[http://www.personal.psu.edu/faculty/t/m/tmc7/tmclinks.html]

Available software for performing numerical linear and/or nonlinear optimization tasks includes:

AMPL, a language and system for formulating, solving and understanding mathematical programming problems;

ANALYZE, for analyzing linear programs and their solutions;

ASA, for solving nonlinear optimization problems using an adaptive simulated annealing method;

BPMPD, a primal-dual interior point algorithm for solving optimization problems;

BTN, for unconstrained nonlinear minimization with parallel computers;

cGOP, an implementation of rigorous global optimization algorithms for solvling a class of nonconvex nonlinear problems;

COAP, a collection of programs from the journal for Computational Optimization and Applications;

COIN, an initiative to spur the development of open source software for the operations research community;

Concorde, a package for exploring and solving the traveling salesman and related network optimizatino problems;

CONMAX, programs for general nonlinearly constrained function minimization;

CONTIN, implements a continuation algorithm with an adaptive choice of a local coordinate system;

COOOL, a package of tools for writing optimization code and solving optimization problems;

CUTDSP, an implementation of a cutting plane approach based on semidefinite programming;

CUTE, a suite of programs and test problems for linear and nonlinear optimization problems;

DIRECT, implements the dividing rectangles algorithm for finding the minimum of a Lipschitz continuous function;

DONLP2, implements a technique for regularizing inconsistent quadratic programming (QP) problems;

Econometrics Toolbox, contains an optimization function library;

FSQP, implements a superlinearly convergent algorithm for optimization problems with competing linear/nonlinear objective functions;

GENBLIS, a genetic optimization program for estimating structure equation models with latent variables;

genocop, a set of genetic optimization algorithms;

GFARIT/GFPLYS/GENIN, a set of programs for generating the Niederreiter low-discrepancy sequences used in multidimensional integration and global optimization problems;

GlobSol, a Fortran 90 package for finding rigorously verified solutions to constrained and unconstrained global optimization problems;

HCL, an object-oriented programming package for implementing objects such as vectors and linear operators;

HOMPACK, for solving systems of nonlinear equations by homotopy methods;

HOPDM, for solving linear programming problems based on the primal-dual logarithmic barrier method;

LANCELOT, for solving large scale nonlinearly constrained optimization problems;

L-BGFS-B, for minimizing nonlinear functions wherein the Hessian matrix is difficult to compute or dense;

LIPSOL, for solving linear programs using interior point methods;

LMITOOL, for solving linear matrix inequality (LMI) problems;

LoLA, a library of algorithms for location planning problems;

LPL, a modeling language for large linear and mixed integer programs;

lp_solve, a mixed integer linear programming solver based on the simplex method;

MANPAK, subroutines for computing with submanifolds implicitly defined by a system of nonlinear equations;

MCS, a program for bound constrained global optimization using function values only and based on a multilevel coordinate search procedure;

MINQ, a program for bound constrained indefinite quadratic programming based on rank 1 modifications;

MLMNP, routines for solving statistical parameter estimation problems for general nonlinear models;

MODLER, a package implementing a language for representing linear programming models;

MPQC, a quantum chemistry program with optimization capabilities;

Mx, a matrix algebra interpreter and numerical optimizer;

NAPACK, a collection of subroutines for numerical linear algebra and optimization;

NBI, for solving nonlinear multicritera optimization problems;

pysimplex, a Python package of mixed integer linear programming modules;

ODRPACK, a collection of programs for fitting a model to data;

OFELI, a object-oriented finite element library containing classes for solving optimization problems;

OPBDP, a Davis-Putnam based enumeration algorithm for linear pseudo-Boolean optimization;

Opt++, an object-oriented nonlinear optimization package for serial architectures;

ORLIB, a basic library of over 50 programs for operations research;

PCx, an interior-point predictor-corrector linear programming package;

PETSc, a numerical analysis library with optimization capabilities;

PLAM, a Prolog implementation of an algebraic modeling language for mathematical programming tasks;

POLSYS_PLP, for solving complex coefficient polynomial systems using a probability-one, globally convergent homotopy method;

PORT, a huge mathematical subroutine library with optimization capabilities;

PORTA, optimization routines for analyzing polytopes and polyhedra;

PRAXIS, for finding the minimum of a function using the principal axis method;

RANDMOD, a package for randomly perturbing linear programs whose matrix file is already available;

RIOTS, a toolbox for solving optimal control problems;

Scilab, a numerical analysis environment with optimization capabilities;

SDPSOL, a parser/solver for semidefinite programming (SDP) and determinant maximization problems with matrix structure;

SLATEC, a huge numerical package containing several optimization routines;

space, a package for the analysis and optimization of computer models or simulations;

SPLP, a subroutine for solving linear optimization problems;

StarFLIP++, an iterative optimization library suite for combinatorial problems with fuzzy constraints;

SYMPHONY, a parallel, generic implementation of the branch, cut and price algorithm for solving integer and mixed-integer problems;

TAO, a toolkit for solving large-scale optimization programs using object-oriented techniques on distributed memory parallel computers;

TENMIN, a package for finding the unconstrained minimizer of a nonlinear function using either a tensor or standard method;

TENSOLVE, for solving systems on nonlinear equations and nonlinear least squares problems using tensor methods;

TENSRD, for finding the unconstrained minimizer of a nonlinear function using either a tensor or standard method;

TN, solves unconstrained and simply bounded optimization problems using a truncated Newton algorithm;

TSPLIB, a library of traveling salesman and related problem instances;

UNCMIN, for solving the unconstrained nonlinear optimization problem;

VE08AD, for minimizing partially separable objective functions with possible upper and lower bounds on the variables; and

WNLIB, routines for data structures, numerical methods and nonlinear optimization.

See also genetic algorithms.
OPIE: The One-Time Passwords In Everything package is an implementation of the One-Time Password (OTP) protocol specified in RFC 1938. This is downward compatible with both S/Key Version 1. A source code distribution is available.
[ftp://ftp.cert.dfn.de/pub/tools/password/nrl-opie/]
Opt++: An object-oriented nonlinear optimization package for serial architectures. Opt++ provides four solution algorithms: a Newton method, a finite difference Newton method, a quasi-Newton method, and a nonlinear conjugate gradient method.
[http://acts.nersc.gov/optplusplus/]
[http://csmr.ca.sandia.gov/projects/opt/opt++.html]
OPT++: A tool for database query optimization which uses the object-oriented features of C++ to simplify the task of implementing, extending, and modifying an optimizer. It incorporates all of the features of an extensible optimization framework including specification of logical algebra, execution algorithms, logical and physical query processing alternatives, and selectivity and cost estimation. The goal of OPT++ was to extract all the parts of a query optimizer which aren't dependent upon any query language so it can be used to write optimizers for a large class of query languages. The distribution includes a sample optimizer called SampleOpt which contains an optimizer and a parser for an SQL-like language.

The source code for OPT++ is available. It is written in C++ and can be compiled with g++ 2.6.2 or later. The included make file allows compilation on most generic UNIX platforms with a C++ compiler which handles templates. The package is documented in a 60+ page user's guide available in PostScript format.
[http://www.cs.wisc.edu/~navin/research/apg.html]
ORBacus: A CORBA-2 compliant Object Request Broker (ORB). The features of ORBacus include:

full CORBA IDL support,

complete CORBA-to-C++ and CORBA-to-Java mappings,

use of IIOP as native protocol,

a Dynamic Invocation Interface (DII),

a Dynamic Skeleton Interface (DSI),

an interface repository,

peer-to-peer communication with nested method invocations,

support for non-blocking method invocations,

support for timeouts,

integration with X11 and Windows,

a COS-compliant naming service,

an IDL-to-HTML translator for generating documentation, and

a DynAny API for dynamic Any type handling.

Compatible extensions include CorbaScript and Fnorb.

A source code distribution of ORBacus is freely available for non-commercial uses. It has been tested on several platforms including Linux Intel using g++ 2.7.2, although it is still (10/97) experimental since g++ does not yet fully support exception handling.
[http://www.ooc.com/ob.html]
Orca: A language for parallel programming on distributed systems, based on the shared data-object model. This model is a simple and portable form of object-based distributed shared memory. It has been implemented on several platforms, including Amoeba, SunOS, Solaris, Linux, CM-5, Sp-2, Parix and Myrinet, although only a Solaris distribution is currently (3/97) available. The documentation is contained within a book and several research papers, the latter of which are available in PostScript format. See Bal et al. (1992).

[http://www.cs.vu.nl/vakgroepen/cs/orca.html]
ORCA: A tool for plotting arbitrary data from text files onto a directory on a Web server such that it can be perused via a browser. The features include:

file-based configuration;

watches data files for updates and sleeps between reads;

finds new files at specified times;

remembers last modification times so files aren't continuously reread;

plotting the same type of data from different files into different or the same GIFs;

creating different plots based on the filename;

creation of arbitrary plots from data in different columns;

plotting the results of arbitrary Perl expressions;

grouping multiple columsn into a single plot using regular expressions on the column titles;

creation of a tree of HTML files and GIF plots;

creation of indices of URL links listing all available targets and/or different plot types;

separate CGI setup not required; and

runnable under cron or its own automatic sleep/wake mode.

A source code distribution is available. This is built on top of the RRD TOOL.
[http://www.geocities.com/~bzking/]
ORLIB: A basic library of programs for operations research. Each of the 28 available programs is available in BASIC, C, PASCAL, Fortran and Java. The available programs in Part 1 include:

ASSIGN, the assignment problem;

CPMALLO, the CPM problem for resource allocation;

CUTSTOCK, the cutting stock problem;

DPG, dynamic programming;

GAMERESE, a game model;

IP01, 0-1 integer programming;

IPCUT, cutting plane method integer programming;

IPKNAP, the knapsack problem;

INVEND, a deterministic inventory model;

INVENP, a probabilistic inventory model;

LPRESE, linear programming using the revised simplex method;

LPSIMP, linear programming using the simplex tableau;

MAXFLO, the maximum flow problem;

MIPBB, integer programming using the branch and bound method;

NETDIK, the shortest path problem;

NETMIN, the minimum cost problem;

NETRCM, the all pairs shortest path problem;

NLPMIN, unconstrained nonlinear programming;

PERTGS, the PERT model;

QPRESE, quadratic nonlinear programming;

QUEUE, a queueing model;

REPLACE, a replacement model;

SIMULQ, simulation;

SSTOCK, the safe stock problem;

TPALL, the network problem using the network simplex method;

TRANSI, the transportation problem;

TRANST, the time transportation model; and

VRPHS, the vehicle routing problem.

The more advanced programs in Part 2 or ORLIB are:

BIGAME, the bi-matrix game model;

CREW, the crew scheduling problem;

CUTPL, the 2-D plane cutting problem;

DECISION, the decision making model;

DIALIDE, the dial-a-ride problem;

FORCAS, the demand forecasting model;

GPRESE, goal programming;

KSHORT, the multi-shortest path problem;

LCP, the linear complementarity problem;

LPADEC, linear programming using the decomposition principle;

LPAFFINE, the interior point method using affine transformations;

LPALLM, the all vertices enumeration problem;

LPBAR, the interior point method using logarithmic barriers;

LPBT, linear programming with general bounds;

LPELSD, linear programming using the ellipsoid method;

LPFEAS, linear programming using the feasible direction method;

LPKART, the interior point method using Karmarkar's method;

TSP, the traveling salesman problem;

LPREPO, the revised simplex method using the product form;

MOLP, multi-objective linear programming;

NETBELL, the shortest path problem using the Ford-Bellman method;

NETOKF, the minimum cost problem using out-of-kilter method;

NLPFDB, nonlinear programming with linear constraints;

PCENTER, the p-center problem;

PMEDIAN, the p-median problem;

PROBAB, the probabilistic model;

REGRESS, the regression analysis model; and

RELIAB, the reliability problem.

[http://orly1.snu.ac.kr/software/orlib/or.html]
OROMatcher: A regular expression package for Java which is completely compatible with Perl 5 regular expressions and supports the processing of InputStreams.
A source code implementation of OROMatcher is freely available under the terms of a non-exclusive, non-transferable limited license whose details are available at the site. The most recent (V1.1) release requires JDK 1.1 although older releases (V1.0.x) can use 1.0.2. The API is documented in HTML format.
[http://www.oroinc.com/]
[http://www.cs.bham.ac.uk/ums/java/packages/OROMatcher-1.1b3/]
[http://psaweb.pisa.otm.it/archweb/develop/software/java/misc/]
ORP: The Open Runtime Platform is an open source research platform for investigating dynamic compilation and garbage collection technologies. It implements support for executing type-safe bytecode and can run many of the applications compiled for a Java Virtual Machine (JVM). The runtime environment is support by the GNU Classpath libraries. The features of ORP include:

a Virtual Machine (VM) module;

a Just-in-Time (JIT) compiler module;

a Garbage Collection (GC) module;

two internal interface (JIT/VM and GC/VM) that cleanly separate dynamic compilation and garbage collection from the remaining virtual machine;

two JITs, i.e. an O1 JIT that generates code quickly and provides dynamic feedback to the O3 JIT which can recompile and reoptimize a method for faster execution; and

several garbage collectors including a moving generational and a non-moving collector.

[http://www.intel.com/research/mrl/orp/]
Orrery: See Geomview.
ORTEP-III: The Oak Ridge Thermal Ellipsoid Program is a Fortran program for drawing crystal structure illustrations. Ball-and-stick type illustrations of a quality suitable for publication are produced with either spheres or thermal-motion probability ellipsoids derived from anisotropic temperature factor parameters on the atomic sites. ORTEP also produces stereoscopic pairs of illustrations which aid in the visualization of complex arrangements of atoms and their correleated thermal motion patterns.

The source code for ORTEP-II is available. It is written in Fortran and can be compiled with g77 or with f2c. The program results can be output to files in HPGL or encapsulated PostScript format. The results can also be viewed interactively with the use of the PGPLOT program. A user's manual is available in PostScript or PDF format.
[http://www.ornl.gov/ortep/ortep.html]
ORTHPOL: A collection of Fortran 77 routines and examples for generating orthogonal polynomials relative to arbitrary weight functions. These routines produce the coefficients in the three-term recurrence relation satisfied by the polynomials. Once these are known, additional quantities such as zeros of orthogonal polynomials and Gauss-type quadrature rules can be generated with various routines in the package. This is TOMS algorithm 726 and is documented in Gautschi (1994).
[http://www.acm.org/calgo/contents/]
[http://www.netlib.org/toms/index.html]
OScheme: Objective Scheme is an embeddable scheme interpreter which conforms mostly to R4RS except: the arithmetic implementation is reduced to the native integer type of the underlying architecture (although it provides inexact number via the native C double type), and the macro system is simpler than the one described in R4RS. It provides various extensions such as regular expressions, system utilities, process and socket modules, autoload, an autodoc package (to generate on-line and HTML documentation from C and scheme sources), a prototype-based object model similar to that of Self, a C-level interface to the Motif toolkit, C-level interfaces to various Web libraries, and more. It can also be compiled in secure mode, i.e. a bunch of controls are performed while Scheme code is executed.

A source code distribution of OScheme is available. It is written in C and has been compiled on DEC OSF1, Linux INtel, SGI IRIX, IBM AIX, and Sun SunOS platforms. A sketchy manual is available.
[ftp://avahi.inria.fr/pub/OScheme/]
OSCR: The Open Source Course Reserve package is an electronic course reserves system for an academic library. This is written in Perl and uses MySQL to provide database services. The system content can be searched by either instructor or course identifiers, and it can manage either PDF files or URLs. This is available under the GPL.
[http://timesync.gmu.edu/OSCR/]
OSE: A collection of programming tools and class libraries for use by C++ programmers. OSE has been developed with the aim of improving programmer productivity through both the ability to reuse software components and by reducing the time developers need to devote to managing the infrastructure supporting day to day programming tasks. The three main components of the environment are the C++ class libraries, a build environment, and a set of documentation extraction tools.
The class libraries in OSE are:

OTCLIB, a library of generic components including support for error handling, error message logging, error recovery, program debugging, memory management, resource management, generic collections, text manipulation, operating system interfacing, and event-driven systems;

OUXLIB, a library of components which primarily extends classes in OTCLIB to support features specific to the UNIX operating system; and

OTKLIB, a library of components which builds on OTCLIB and OUXLIB to allow the integration of the Tcl/Tk library into applications using the event-driven systems framework provided by OTCLIB.

The build environment supplied with OSE is called makeit. It consists of a wrapper around GNU make as well as a predefined set of makefiles structured as modules. Each module supports a different feature, with the developer including only those modules that are needed via the include mechanism of GNU make. There are modules which support commonly used programming tools such as C and C++ compilers. Special modules exist for combining multiple code libraries into one, forming template closure on C++ libraries, creation of C++ template repositories, and the installation of programs and libraries created by the build enviroment. The documentation extraction tools allow C++ class documentation to be embedded within header files as C++ comments. A program called class2man can create man pages from the embedded comments. There is also a companion tool called class2src which creates stubs for each member function of a C++ class. Another useful tool is mksrc which creates header files and code files, filling out the files with file headers giving the author and copyright details.
A source code distribution of OSE is available. It is portable to a wide range of C++ compilers including G++. A template preprocessor is supplied with OSE for compilers which don't support templates. The package is also portable to most UNIX flavors including Linux.
[http://ose.sourceforge.net/]
Osh: A setuid root, security enhanced, restricted shell. Osh allows an administrator to carefully limit access to special commands and files to users whose duties require such access, while at the same time maintaining audit records. A configuration file contains an administrator-defined access profile for each authorized user or group, which lists the commands that may be used and specific access rights for files and directories. All typed commands are logged along with a notation of their success or failure. The Osh looks like a standard shell and supports pipes, wildcards, aliasing, redirection and environment referencing, but does not have the concept of a path since the user is restricted to only those specific commands and paths chosen by the administrator. A source code distribution is available.

[http://www.engarde.com/~mcn/osh.html]
OSI: The Open Systems Interconnection standards are a set of data transfer standards which can be seen as either an alternative or complementary to the TCP/IP internet protocols. There are fundamental differences between the OSI reference model and the Internet protocol suite which makes comparisons difficult. OSI application standards are based on an upper layer architecture and discrete modules, with three upper layer stacks providing interworking flexibility which are in principle independent of the OSI Transport and Network Layers. The Internet application protocols, e.g. TCP/IP-based application services such as FTP, are built from the ground up and are plugged directly into the Transport services. Thus it is possible to run OSI application services over any lower layer stock, i.e. even over TCP/IP. The complementary/alternative nature of these two sets of protocols has led to some specifications for multi-protocol systems which aim to provide an any-to-any solution for any application service over any lower layer protocol stack. Such an approach has been taken with the OSIMIS toolkit. Other implementation are the ISODE and the OSIkit.
The OSI reference model is divided into seven protocol layers which each provide specific services. These layers are (in order from more to less directly related to hardware):

Physical Layer, provides the electrical, functional and procedural characteristics to activate, maintain and deactivate physical links that transparently send a bit stream that is recognized only as individual bits;

Data Link Layer, provides for the activation, maintenance, and deactivation of data link connections, grouping bits into characters and message frames, character and frame synchronization, error control, media access control, and flow control (e.g. HDLC and Ethernet);

Network Layer, provides independence from the data transfer technology and relaying and routing considerations, masks the peculiarities of the data transfer medium from higher layers, and provides switching and routing functions to establish, maintain and terminate network layer connections and transfer data between users (e.g. IP);

Transport Layer, the first true end-to-end layer, this provides transparent transfer of data between systems, relieves upper layers from providing reliable and cost effective data transfer, provides end-to-end control and information exchange with the quality of service needed by the application program (e.g. UDP and TCP);

Session Layer, provides mechanisms for organizing and structuring dialogues between application processes which allow for two-way simultaneous or alternate operation, the establishment of major and minor synchronization points, and techniques for structuring data exchanges;

Presentation Layer, provides independence for application processes from differences in data representation by allowing the user to select a presentation context with conversion between between alternative contexts; and

Application Layer, provides service elements used by all applications such as library routines which perform interprocess communication and provide common procedures for constructing application protocols and for accessing the services provided by servers residing on the network.

The first four layers are primarily the concern of engineers dealing with protocols, and the last three the concern of programmers building distributed applications.
Various OSI standards and their Internet protocol equivalents are:

OSI X.400 message handling system (MHS) and Internet mail (SMTP/822),

OSI X.500 directory protocol and the domain name system (DNS),

OSI common management and the SNMP,

OSI transports and the transmission control protocol (TCP), and

OSI and Internet datagrams (CLNP and IP) routing.

The OSI and TCP/IP standards are compared and contrasted in Cypser (1991), Halsall (1996), Perlman (1992), Piscitello and Chapin (1993), and Udupa (1995). The OSI protocols are covered in Betanov (1992), Black (1995a), Hebrawi (1993), Kille (1991), Inc. (1993b), Naugle (1993), Potts and Black (1992), Radicati (1992), Rose (1990), Taylor (1995), and Yemeni (1993).
[http://www2.echo.lu/oii/en/osi.html]
OSIkit: A collection of tools for the application of Estelle and ASN.1. Estelle is a formal description technique for computer communication protocols contained within the OSI standard suite. The Portable Estelle Translator (PET) is a parser that checks Estelle specifications for syntax and static semantic correctness and builds a representation of the specification in the static model. A library is provided to reload this representation back into memory for further processing, which makes PET a suitable front-end for tools which process Estelle specifications. The Distributed Implementation Generator (DINGO) exploits the output of PET to generate C++ code for distributed implementations of Estelle specifications. The code includes functions and structures for an optional X Window interface with executing modules.

The Estelle prototype compiler (ESTPC) is a compiler from Estelle to C and a run-time system written in C. The compiler translates a formal Estelle description into declarations of data structures and procedures in C which much be augmented with a library of run-time functions. This can be used to produce an executable program to realize the behavior of the formal description. The Free Value Tool for ANS.1 (ASNFVT) is suitable for studying and evaluating one or several ASN.1 modules or for building a prototype encoder-decoder. The kit includes a fairly complete translator from ASN.1 modules into an instance of the model. An Estelle syntax-directed editor called Wizard includes thorough checking of syntax and static semantics and generates code for use with the Wise tool. The Estelle simulation environment called Wise works with Wizard and is a simulation and symbolic debugging tool for specifications written in Estelle which provides simulated multiple sites and processes and a window-based interface for control and observation.
The PET, DINGO, ESTPC and ASNFVT tools are all written in ANSI C and C++ and can be compiled and used with the typical GNU tool suite. Wizard and Wize require proprietary software. All of the programs contain user's manuals in TeX format.
[ftp://osi.ncsl.nist.gov/pub/osikit/]
[ftp://ncbi.nlm.nih.gov/toolbox/osikit/]
OSIMIS: The OSI Management Information Service system is an object oriented platform based on the OSI model and realized in the C++ programming language. It provides an environment for the development of OSI-based applications which hide the complexity of the underlying protocols and harness the power and expressiveness of the associated information model. OSIMIS lets an implementor concentrate on the intelligence of applications rather than on the mechanics of protocol access. It also combines the OSI management power with the large installed base of Internet SNMP-capable network elements via a generic CMIS/P to SNMP proxy facility. OSIMIS is known to be interoperable with IBN NetView TMN, HP OpenView, Bull ISM, and Ericsson TMOS.

The services provided by OSIMIS include:

an implementation of CMISE based on version 2 of the international standard (over either the ISODE 8.0 ROSE/ACSE or through XOM/XMP);

an implementation of SNMPv1 (used for the CMIS/P to SNMP proxy);

a single-threaded, event-driven coordination mechanism for organizing a complex management application implemented as a single UNIX process which works seamless with the coordination mechanisms of GUIs such as the X Window System and Tcl/Tk;

object-oriented ASN.1 support;

the Generic Managed System (GMS), a fully generic OSI agent engine which provides a plug-in managed object facility and all the CMIS functional units;

a GDMO compiler;

system management functions, e.g. event reporting, log control, object management, etc.;

an object oriented manager infrastructure implemented in Tcl, i.e. the Tcl-RMIB, which can be used with Tk to implement managing applications with graphical user interfaces;

a location transparency mechanism based on the X.500 directory service;

a generic CMIS to SNMP proxy based on the IIMC standards which makes use of a SNMP SMI to GDMO translator and of the GDMO compiler to produce run-time support; and

a number of generic manager applications including a GUI-based MIB browsers and a Tcl-based management shell.

OSIMIS will operate on several UNIX platforms including Sun Solaris and SunOS, Linux Intel, and HP-UX. It is backwards compatible to gcc 2.5.8 and uses the freely available ISODE 8.0 upper layer stack on all of the platforms mentioned. It supports Tcl 7.4 and Tk 4.0.
[http://www.cs.ucl.ac.uk/research/osimis/]
OSKit: A framework and set of modularized library code together with extensive documentation whose goal is to make it easier for OS developers to create new ones. It facilitates running user code directly on the hardware including programming language runtimes, porting an existing OS to a platform supported by the OS Toolkit, or enhancing an OS to support a wider range of devices, file system formats, or executable formats. The Toolkit is designed for someone to be able to use it and immediately have a basis on which they can begin concentrating on substantial OS issues such as scheduling, VM, IPC, file systems, security, etc. instead of spending forever writing boot loader code, startup code, device drivers, malloc code, a kernel debugger, etc.
The package contains 30 libraries oriented to OS development and maintenance. The function libraries are:

liboskit_c, a minimal C library minimizing dependencies with the environment and between modules;

liboskit_kern, kernel support code for setting up a basic kernel environment including providing default handlers for traps and interrupts;

liboskit_smp, additional kernel support code dealing with setting up a multiprocessor system;

liboskit_com, utility functions for handling COM interfaces and a set of generic wrapper components; and

liboskit_dev, default implementations of glue functions required by device drivers and other large encapsulated components imported from other OS environments.

The various component libraries supplied with OSKit include:

liboskit_freebsd_c, a POSIX-like C library derived from BSD that provides both single- and multi-threading configurations;

liboskit_freebsd_m, a complete standard math library taken from FreeBSD's libm;

liboskit_lmm, a flexible memory management library for managing either physical or virtual memory;

liboskit_amm, an address map manager library that manages collections of resources wherein each element of a collection has a name (i.e. address) and a set of attributes (e.g. swap space and process virtual address space);

liboskit_svm, a simple virtual memory library that uses liboskit_amm, to define a simple virtual memory interface for a single address space that can provide memory protection and paging to block devices (e.g. disk partitions);

liboskit_threads, providing support for multithreaded kernels including POSIX threads, synchronization, scheduling and stack guards;

liboskit_memdebug, providing debugging versions of malloc;

liboskit_gprof, run-time support for a kernel to collect and report profiling data about itself;

liboskit_diskpart, a generic library that recognizes various disk partitioning schemes and produces a map of the organization of any disk;

liboskit_fsread, a read-only file system interpretation library that supports various common file systems;

liboskit_exec, a generic executable interpreter and loader that supports popular executable formats during bootstrap and general operation;

liboskit_linux_fs, an encapsulated Linux 2.0.29 filesystem supporting ext2fs and other PC filesystems supported under Linux;

liboskit_netbsd_fs, an encapsulated NetBSD 1.2 filesystem;

liboskit_freebsd_net, encapsulated FreeBSD 2.1.7.1 networking code including socket layer and protocol support;

liboskit_bootp, a simple interface for performing the BOOTP protocol on Ethernet devices;

liboskit_hpfq, providing hierarchical proportional-share control of outoging network link bandwidth;

liboskit_linux_dev, an encapsulated Linux 2.0.29 device driver set;

liboskit_freebsd_dev, an encapsulated FreeBSD 2.1.7.1 device driver set;

liboskit_wimpi, a simple hierarchical windowing system based on MGR; and

liboskit_video, basic video support including SVGALIB 1.3.0, one based on XFree86 3.3.1, and support for X11 clients.

Libraries provided mainly for convenience include:

liboskit_startup, containing functions to start up and initialize various OSKit components;

liboskit_unsupp, containing various unsupported hacks and utilities;

liboskit_unix, providing support to debug and run certain OSKit components on FreeBSD in user mode; and

liboskit_fudp, providing a fake UDP implementation for a send-only no-fragmenting version of UDP.

A source code distribution of OSKit is available. It contains the code for all of the libraries, over 40 example toy kernels, and a 500 page document describing most of the libraries in detail. A couple of conference papers are also available in the way of documentation. This contains some machine-dependent code for the Intel x86 architecture but most of the code is independent of architecture.
[http://www.cs.utah.edu/projects/flux/oskit/]
[http://www.cs.uct.ac.za/~fabian/coding.html]
OSPF: The Open Shortest Path First protocol is a TCP/IPO routing protocol classifed as a IGP (Interior Gateway Protocol). It distributes routing information between routers belonging to a single autonomous system. It is based on link-state or SPF technology, departing from the Bellman-Ford base used by traditional routing protocols.
[http://www.faqs.org/rfcs/rfc2178.html]
OSS: The Open Sound System is a universal audio and sound programming API originally developed for Linux. It is a set of device drivers which provide a uniform API across all of the major UNIX architectures and supports Sound Blaster compatible sound cards which can be plugged into any UNIX workstation supporting the ISA or EISA bus architecture. It also supports workstations with on-board digital audio hardware. OSS should supply to UNIX platforms the capabilities for streaming audio, speech recognition/generation, computer telephony, and other applications now found on Windows and Mac platforms.

The features of OSS include:

digital audio sampling and playback (e.g. 8 bit unsigned and u-law, 16 bit signed PCM data, stereo and mono sampling/playback, sampling rates between 4 and 48 KHz, half duplex and full duplex (on hardware supporting full duplex), support for direct access to the audio DMA buffer, the capability to synchronize audio recording/playback with MIDI playback, etc.);

FM and wave-table MIDI playback (e.g. hardware independent access to MIDI features using built-in synthesizer chips and MIDI synthesizers or sound modules, a device independent sample/patch loading API library for synthesizers, support for SMPTE, MTC and other timing standards, etc.);

MIDI input and output (e.g. support for MPU-401 UART and Sound Blaster MIDI UART MIDI I/O, support for the XG MIDI standard, etc.); and

audio mixing (e.g. main, FM synthesizer, wave-table, digital audio volume, microphone, CD input, etc.).

A freely available version of OSS called OSS/Free is included in the Linux kernel source distribution package. A commercial version is also available for Linux and many other UNIX platforms. Documentation can be found in an online HTML programmer's guide.
[http://www.4front-tech.com/ossfree/]
OSS/Free: See OSS.
OSSIM: The Open Source Software Image Map project aims to construct an integrated tool for remote sensing, image processing and GIS analysis. The features and capabilities of OSSIM include:

basic image manipulation functions;

a non-native file format plug-in architecture;

projection/datum coordinate transformations;

intelligent memory management and caching;

intelligent zooming;

a basic architecture for sensor model development;

a platform independent GUI viewer;

intelligent resampling;

keyword batch processing and state generation;

scripting and XML support.

[http://ossim.org/]
OTP: The Open Trading Protocol provides an interoperable framework for Internet commerce. It is payment system independent and encapsulates existing payment systems. The goal is to provide a virtual capability safely replicating the paper-based, traditional one of the real world.
[http://www.oasis-open.org/cover/otp.html]
OTPW: The One Time PassWord package consists of a one-time password generator plus verification routines that can easily be added to programs such as login and ftp on POSIX systems. This will allow reasonably secure user authentication over network lines. It is intended for traveling users connecting to their home system via untrusted terminals that don't provide the security of, e.g. ssh between frequently-used computers. The user carries a password list on paper, but the scheme is designed to be robust against theft of the paper list and race-for-the-last-letter attacks. Cryptographic has values of the one-time passwords are stored for verification in the user's home directory. A source code distribution is available.
[http://www.cl.cam.ac.uk/~mgk25/otpw.html]
Otter: An automated deduction system designed to prove theorems stated in first-order logic with equality. Otter's reference rules are based on resolution and paramodulation and it includes facilities for term rewriting, term orderings, Knuth-Bendix completion, weighting, and strategies for directing and restricting searches for proofs. It can be used as a symbolic calculator and has an embedded equational programming system. Otter is mainly used for abstract algebra and formal logic research but has been used in the areas of finite semigroups, ternary Boolean algebra, logic calculi, combinatory logic, group theory, lattice theory, and algebraic geometry.

A source code distribution of Otter is available. It is written in portable C and can be compiled and used on most generic UNIX platforms. It is documented in a reference manual and user's guide as well as in several technical papers, all of which are available in PostScript format.
[http://www.mcs.anl.gov/home/mccune/ar/otter/]
OutaSite: A Perl program that produces (for a given URL) an outline in HTML showing all the children of that URL. The features of OutaSite include:

hierarchical numbering of URL children;

printing the children of a given URL only once;

showing the URLs as hyperlinked titles;

treating frames as hyperlinks;

adjustable maximum depth for a searching tree and for the number of children at any branch;

disallowing links that obviously aren't HTML;

indicating links not found or forbidden in red;

indicating unreachable links in orange;

indicating redirects (which are followed) in green; and

hyperlinking of section numbers back to parents.

A source code distribution of this Perl script is available.
[http://www-hgc.lbl.gov/homes/nomi/outasite/]
Overture: A C++ class library designed to make it easy to write programs to solve partial differential equations (PDEs) in complicated domains. The Overture classes encapsulate the details involved in discretizing PDEs in curvilinear domains so the programmer can ignore many of the annoying details that make programming in C++ a hell on earth. For example, the operator classes define differential operators using finite difference and finite volume discretizations. Overlapping grids are used to represent complicated geometries, and large and difficult problems can be solved using adaptive mesh refinement and moving grids.
The classes that comprise Overture are:

Mapping, a transformation that can be used to represent a curvilinear domain such as square, annulus or sphere;

MappedGrid, a logically rectangular grid that is a discrete version of Mapping which contains grid point coordinates, boundary conditions, periodicities, etc.;

realMappedGridFunction, a grid function that holds a solution (e.g. pressure or velocity) on a MappedGrid;

MappedGridOperators, the class used with grid functions to define spatial derivatives and to apply boundary conditions;

PlotStuff, a class used to interactively plot objects;

Ogshow, a class for saving solutions and other information;

Oges, an equation solver class that can be used to solve systems of boundary value problems such as Poisson's equation;

CompositeGrid, an overlapping composite grid in which each component is a MappedGrid;

realCompositeGridFunction, a grid function that holds a solution on a CompositeGrid;

CompositeGridOperators, classes used with grid collection functions to define spatial derivatives and to apply boundary conditions; and

Ogen, the overlapping grid generator that can be used in a moving grid computation to regenerate an overlapping grid when one or more of the component grids change.

A source code distribution of Overture is available. Installation also requires A++, HDF, OpenGL, and Motif. On Linux Intel platforms Overture has been compiled and is supported with the egcs compiler. Quite a bit of documentation is available including a primer and guides to most of the individual classes, all of which are available in PostScript format.
[http://www.llnl.gov/casc/Overture/]
Ox (grammar system): An attribute grammar compiling system based on yacc, lex, and C. It is a yacc/lex/C preprocessor designed to bring attribute grammars to the mainstream of UNIX-based language development. It is a good choice for language designers, experimenters, and developers familiar with yacc, lex, and C, and can also be used with Bison, Flex, and C++. Ox generalizes the function of yacc in the way that attribute grammars generalize context-free grammars, i.e. ordinary yacc and lex specifications may be augmented with definitions of synthesized and inherited attributes written in C syntax. Ox checks these specifications for consistency and completeness and generates a program that builds and decorates attributed parse trees. It handles the tedious and error-prone details of writing code for parse-tree management, and thus eases problems of security and maintainability associated with that aspect of translator development.

A source code distribution is available as is a binary for Linux Intel platforms. The source code is written in yacc, lex, and C and can be compiled on platforms with the appropriate tools. The distribution also contains Ox-ready yacc/lex parsers for C, C++, Pascal, Ada, and Fortran, as well as a large example program. The documentation includes a tutorial introduction and a reference manual.
[ftp://ftp.cs.iastate.edu/pub/ox/]
Ox (statistics): An object oriented matrix language with C and C++ like syntax. This is a freely available alternative to the commercial Gauss package. Although the specific functions supplied with the basic package are mostly for use in statistics, Ox can be used as a general matrix manipulation package like, e.g. RLaB or Octave.

Ox comes with an extensive library of functions to perform many tasks. These are divided into general functions (e.g. binary and and or operations, string conversion, max and min values, computing row and column sums, etc.), type functions (e.g. testing if an argument is an integer, real, string, etc.), matrix functions (e.g. compute the determinant of a matrix, invert a matrix, return the trace of a matrix, etc.), input/output functions, math functions (e.g. complex operations, absolute values, beta functions, logs, square roots, etc.), matrix creation, matrix decomposition functions (e.g. Cholesky and LU decompositions, singular value decomposition, eigenvalues, etc.), matrix modification and reordering functions, probability functions (e.g. several densities, quantiles and distributions), statistical functions (e.g. correlations, menas, variances, etc.), random number functions, time series functions, trig functions, maximization and (numerical) differentiation functions, and graphics functions.
There are currently (5/96) versions of Ox for Windows, MS-DOS, Linux, SunOS and HP-UX platforms, and all will remain freely available but for the Windows version (which will become a commercial product in late 1996). The documentation is contained in a 300+ page manual in PostScript format available separately from the software.
[http://www.nuff.ox.ac.uk/Users/Doornik/]
Oz: A concurrent constraint programming language designed for applications that require complex symbolic computations, organization into multiple agents, and soft real-time control. This is an interactive implementation of Oz featuring a programming interface based on Emacs, a concurrent browser, an object-oriented interface to Tcl/Tk, powerful interoperability features, an incremental compiler, a garbage collector, and support for stand-alone applications. The Oz language is based on a computational model providing a uniform foundation for higher-order functional programming, constraint logic programming, and concurrent objects with multiple inheritance.

The features of Oz include:

logic variables and concurrent control;

higher-order language features, i.e. functions, procedures, objects, classes, methods, messages and modules are created dynamically and are designated by first-class values which may be passed as arguments, returned as results, tested for equality, and stored in the attributes of objects;

full compositionality in which every computation is described by an expression;

concurrent objects and multiple inheritance;

first-class names, i.e. the names of record fields, methods and attributes are first-class values which can be specified through variables;

soft real-time control employing an asynchronous, preemptive, and priority-controlled task scheduling policy;

computing with partial information;

powerful and pre-defined search abstractions;

finite domain constraints;

deep guards; and

a logic sublanguage in which Horn clause programs will execute in a logically sound manner.

The Oz system is distributed in two parts: a platform independent base system in source form and platform specific binaries of the compiler and emulator. The latter is available for Sun SunOS and Solaris, DEC Ultrix, HP-UX, Linux (Intel and Motorola), SGI IRIX, and IBM RS6000 platforms. Using the Oz development environment also requires the Emacs text editor. Several documents are available in PostScript format, including a primer, a language manual, a programming manual, a user's manual, a module manual, and more. See Smolka et al. (1995).
[http://www.ps.uni-sb.de/oz/]

[ home / linux ]

Next: Pa-Pm Up: Linux Software Encyclopedia Previous: Oa-Om Contents

Manbreaker Crag 2001-03-08