Next: On-Oz Up: Linux Software Encyclopedia Previous: Nn-Nz Contents

Oa-Om

Last checked or modified: Nov. 16, 1997

OASES: The Ocean Acoustics and Seismic Exploration Synthesis package is a general purpose computer code for modeling seismo-acoustic propagation in horizontally stratified waveguides using wavenumber integration in combination with the Direct Global Matrix (DGM) solution technique. The features of OASES include:

support for many environmental models including any number and combination of isovelocity fields, fluids with sound speed gradients, and isotropic elastic media;

any number of transversely isotropic layers;

media with general dispersion characteristics;

stratifications including an arbitrary number of poro-elastic layers with propagation defined by Biot's theory;

continuous sound speed profiles; and

field computations in stratified flow.

The package consists of several modules including:

OASES, the main driver module;

OASR, a reflection coefficient module;

OAST, a transmission loss module;

RDOAST, a range-dependent transmission loss module;

OASP, a 2-D wideband transafer functions module;

RDOASP, a 2-D range-dependent transfer functions module;

OASP3D, a 3-D wide-band transfer function module;

QASN, a noise, covariance matrices, and signal replicas module;

OASM, a matched field processing module;

OASS, a scattering and reverberation module;

PP, a pulse post-processor module; and

some graphics post-processing modules.

A source code distribution of OASES is available which contains a subset of the capabilities of the full version. It is written in Fortran 77 and is configured to compile on several platforms including Linux Intel using the g77 compiler. It is documented in a 120 page user's manual available in PostScript format.
[http://dipole.mit.edu:8001/arctic0/henrik/www/oases.html]
OAX: An spatial objective analysis program that applies the method of optimal interpolation (objective analysis) to estimate the values of variables at specified points in a multidimensional space. The computation at each point is based on a weighted average of the values of a specified number of data points closest to that point. Several dependent variables can be interpolated simultaneously using the same weights if the underlying statistical model and relative noise level in the input data are assumed the same for each variable.

The OAX package includes a stand-alone version, a C library, a Fortran library, an AVS module, and a Pipe version. Binaries are available for BSD, DEC, HP, IBM, SGI and SUN platforms. The source code is also available for each version. Each version package also contains documentation in either PostScript or ASCII format.
[http://www.tuns.ca/~hey/ocean/oview.html]
Oberon: A programming language in the Pascal/Modula tradition as well as a modern operating system for single-user personal workstations. Oberon was originally designed for computer science education by N. Wirth and J. Gutknecht in 1986. It has an integrated and modular programming environment and a versatile textual user interface. It is considered the successor to Modula-2.

The Oberon language features include:

a Pascal-like syntax and strong type checking;

separate compilation of modules with interface checking across module boundaries,

run-time type checking and run-time checks to catch overflow and out-of-range errors,

ASSERT statements for programming by contract,

type-extension for object-oriented programming which can be used across module boundaries,

I/O operations via standard libraries,

type-bound procedures for implementing methods,

compatibility between all numeric types,

string operations, and

support for system programming.

The compiler generates native code and is fast. This is a compiler for the Oberon-2 language that accomplishes said task by translating Oberon-2 code into C and compiling that resultant C code using the native C compiler.
The Oberon system features include:

dynamic and run-time linking of modules,

single-process multitasking,

commands (i.e. procedures that can be called like programs),

dynamic loading and support for persistent objects,

automatic and fast garbage collection with support for object finalization,

a completely modeless GUI with support for graphical primitives,

a component framework which allows the interactive construction and modification of graphical applications without programming,

support for the underlying hierarchical file system,

WYSIWYG printing via the printer drivers of the host system,

text as a built-in abstract type,

a document-based interface which allows the generation of dynamic documents,

complete integration with TCP/IP networks, and

and a standard text and document editor with support for embedded objects.

The system core components are a kernel, a dynamic loader, a garbage collector, drivers (for disk, diskette, mouse, keyboard, asynchronous and synchronous communication, printer and a bitmapped display), LAN services, a window subsystem, a text editor, and a compiler.
Versions of Oberon available for Linux platforms include:

Oberon V4 versions from Linz, ETH and an upgraded ETH version from Rochester;

Oberon System 3, an evolutionary development of V4;

JACOB, an Oberon-2 compiler; and

Ofront, an Oberon-2 to C translater.

Also useful is the Oberon Reference Site. See also the related B2 system. An interesting site to watch is Project Voyager at StatLab Heidelberg. See Dotzel and Skulski (1997) for a discussion on Oberon as an alternative to C++. See Moessenboeck (1993), Nikitin (1998), Reiser (1991), Reiser and Wirth (1992), and Wirth and Gutknecht (1992).
[http://www.oberon.ethz.ch/oberon/]
Oberon System 3: The features of Oberon System 3 include:

100% compatibility with the original system,

integration of object support in the kernel which allows all ingredients of the original system to be expressed uniformly

in terms of objects and object libraries,

implementation in the original Oberon language,

object autonomy and persistence,

hierarchic composability of all objects,

extensibility via a common message protocol that can be regarded as a kind of software bus,

a generalized Model-View-Controller (MVC) scheme which allows different views of one and the same object,

a powerful GUI framework called Gadgets that provides for interactive and programmed object composition using a library of predefined abstract and visual objects as well as tools for their interactive composition and inspection,

self-contained documents,

a rich package of network software with Internet connection possible via either an Ethernet link or SLIP dial-in, and

a completely self-contained layered system structure.

Binary versions of Oberon System 3 are available for PC native, Windows, Linux/X11 Intel, and Mac platforms. Documentation is mostly via an interactive on-line series of documents included in the distribution.
[http://www.oberon.ethz.ch/system3/]
OBJC: The Portable Object Compiler is an implementation of Objective C independent of those created by Stepstone, NeXT, GNU, and SunSoft. The distribution consists of:

objc, the actual compiler which consists of a driver script objc and a precompiler for C objc1 (with an additional binary objcplus1 which precompiles C++);

objcrt, an all C runtime library for objc which therefore needs no assembly language and is independent of stack layout, register allocation convections, etc.;

objpak, the Objective C Collection Classes which work with other Objective C implementations as well;

libcakit, the Computer Algebra Kit Objective C classes which provide a concise interface to a large set of classes for polynomial computing and arbitrary precision integer arithmetic;

a compiler source and oclib, a set of Objective C classes for parsing C and the Objective C extensions to C.

The features of OBJC include:

portability to many systems with the native C compiler, debuggers, and profilers;

partial support for C++ compilers; and

the built-in possibility of tracing Objective C messages.

Future plans include the development of more compatible Objective C libraries, increasing its portability, incorporating garbage collection runtime extensions, incorporating blocks objects (for exception handling), adding auxiliary tools, and more.
The OBJC package is available as a binary distribution since objc is written in itself and can't be compiled from source without a bootstrap compiler. A C compiler is needed to use the package, although it is portable over many types, including gcc. There are versions of OBJC for Linux, FreeBSD, Sun SunOS and Solaris, SGI IRIX, DEC Digital UNIX, MkLinux, NeXT, IBM AIX, and HP-UX platforms. See Cox and Novobilski (1991) and Pinson and Wiener (1991).
[http://www.can.nl/~stes/compiler.html]
Object REXX: An object-oriented scripting language based on its procedural predecesoor REXX. The Linux version of Object REXX is fully compatible with the versions for OS/2 Warp and Windows NT/95. It supports a large number of REXX utilities applicable to the UNIX enviroment and includes a Security Manager utility which provides control over calls on external functions, use of host commands, and access to the local and enviromental directories. TCP/IP sockets are supported via the RxSock interface which allows for network programming.
Binary versions of Object REXX for Linux are available in compressed and RPM formats. Documentation can be found at the second URL given below.
[http://service2.boulder.ibm.com/dl/rexx/orexxlinux-d/]
[http://www2.hursley.ibm.com/orexx/]
objectHTML: A scripting language that supports direct access to Java objects. It can be embedded into any document and has an HTML-based syntax and compact instruction set. It is primarily meant for dynamic HTML generation within Web-based applications, i.e. as an alternative to things like Java Server Pages (JSP). This is freely available for non-commercial use. A tutorial is available in either PDF or PostScript format.
[http://www.factum-gmbh.de/gb_products/object_html.html]
Objective-C: A superset of C which is a cross between Smalltalk and C, Smalltalk was designed by Brad J. Cox to add the main features of Smalltalk-80 to the C language. Objective-C is dynamically typed which makes class libraries much easier to deal with than in C++, with the Objective-C runtime allowing methods and classes to be accessed by their string names. It only extends C to support object-oriented features similar to those in Smalltalk, and also supports dynamic binding and has a messaging syntax like those in Smalltalk. It differs from C++ in that it doesn't have either operator overloading or multiple inheritance, and it also doesn't have the additional added syntax and semantics over C that exists in C+.
Objective-C has been implemented in the GNU GCC compiler since version 2, with versions 2.5.8 and above including both a compiler and a runtime library. See the GNU Objective-C Class Library libobjects for further details. See Budd (1991), Cox and Novobilski (1991), and Pinson and Wiener (1991).
[http://adsl-206-170-148-237.dsl.snfc21.pacbell.net/Objective-C/]
[http://www.cs.rochester.edu/u/mccallum/libobjects/]
[http://www.faqs.org/faqs/computer-lang/Objective-C/faq/]
[http://www.cs.indiana.edu/classes/c304/oop-intro.html]
[http://web3.foxinternet.net/jik/comp/objc.html]
[http://www.swarm.org/resources-objc.html]
Objective Caml: A functional programming language that is an implementation of the Caml dialect of ML extended with a powerful module system in the style of SML. Features include separate compilation, low memory requirements, fast turnaround through bytecode interpretation, module calculus, and a high performance native code compiler. Some effort has been expended to encourage numerical programming in this language. The native code compiler supports several processor/operating system combinations including Intel processors running Linux. This is the successor to Caml Light.
The tools comprising the distribution include:

ocamlc, a bach compiler that compiles source files to bytecode object files and links these to produce standalone bytecode executables;

ocaml, a top level program that permits interactive use of the system via a read-eval-print loop;

ocamlrun, the runtime system that executes bytecode files produced by the linking phase of ocamlc;

ocamlopt, a high performance native code compiler;

ocamllex and ocamlyacc, program generators that produce, respectively, a lexical analyzer and a parser;

ocamldep, a dependency generator;

ocamldebug, a source-level replay debugger;

ocamlprof, a program profiler;

a method for interfacing C with Objective Caml; and

a set of libraries including those for threading, math, UNIX system calls, graphics, databases, regular expressions, etc.

Source and Linux binary (RPM) distributions are available. The documentation is available in several formats. This is freely available even for building commercial software.
[http://pauillac.inria.fr/ocaml/]
object-oriented languages: Object-oriented languages/implementations or those with object-oriented features include:

ABCL

Ada

A'UM

BETA

Blue

b2c

C++

Cambridge Modula-3

Cecil

CHSM

CLAIRE

Cool

COX

C-Talk

Demeter

Dylan

Dynace

Eiffel

EusLisp

gbeta

ILOGTALK

Java

Kiev

Leda

Loglan82

Modula-3

NetRexx

Objective-C

Object REXX

Objective Caml

Obliq

OOF

Perl

Pike

Python

Sather

sC++

Self

SHIFT

TOM, originally developed as an enhanced Objective-C;

uC++, an extension of C++ for high-level concurrency;

UFO, for developing parallel programs;

YAFL, a language system representing the world as a network of connected objects communicating with messages; and

YoYo, a combination of Logo and Java.

[http://www.cera2.com/softd/object.htm]
ObjectProDSP: An object-oriented tool for digital signal processing (DSP) design, development and implementation. With it you can define and edit a DSP network graphically, excecute the network interactively, create standalone code for the network, and learn DSP using ObjectProDSP as a tutorial aid. This was developed on a Linux platform and is thus far available only for such platforms.

[ftp://tsx-11.mit.edu/pub/linux/packages/dsp/]
[http://www.mtnmath.com/]
ObjectSpace JGL: A Java library that is an add-on to the JDK. JGL provides a series of advanced collections and more than 50 generic algorithms that are design to complement the basic JDK features. It was designed to provide essential conatainer collections as well as the data processing algorithms needed to use with those collections, i.e. it's a sort of STL for Java. The algorithms were designed for use on JGL collections, Java native arrays of primitives and objects, and all JDK collections. They are generic and can be adapted using function objects and predicates to solve most commonly encountered collection processing problems.

JGL consists of eight Java packages, each designed to include a set of related functionality. The package includes a single jar file containing all classes, fully commented source code, complete HTML API javadoc documentation, a comprehensive HTML user guide with over 100 examples, online versions of each example, a suite of performance benchmarks, and free support.

A source code distribution of JGL is available. Versions 3.0 and 3.1 are compliant with JDK 1.1 and version 2.0.2 is compliant with JDK 1.1 and 1.0.2. All documentation is included in HTML format in the distributions.

[http://www.objectspace.com/jgl/]
Obliq: A lexically-scoped, untyped, interpreted language that supports distributed, object-oriented computation. Computations with Obliq may involve multiple threads of control within an address space, multiple address spaces in a machine, heterogeneous machines over a local network, and multiple networks over the Internet. Obliq computations can roam over the network while maintaining network connections. It differs from other distributed procedural languages in its adherence to lexical scoping in a distributed higher-order context, a feature which supports a natural and consistent semantics of distributed computation and enables elegant techniques for distributed programming. In addition to its usual roles, lexical scoping in Obliq ensures that computations have a precise meaning even when they migrate over a network, one which is determined by the binding location and network site of identifiers and not by execution sites.

Distributed computations in Obliq are structured as objects, with each network service seen as a network object (or interface). The object primitives are designed to be simple and powerful with a coherent relationship between their local and distributed semantics. Obliq objects are collections of named fields with four basic operations, i.e. selection/invocation, updating/overriding, cloning, and direction. Every object is potentially a network object and may become accessible over the network either by the mediation of a name server or by being used as the argument or result of a remote method. Objects are local to a site with network references transmitted from site to site rather than the objects themselves.
A distribution of Obliq is included in the DEC SRC Modula-3 package. It is documented in a language description and a paper, both available in PostScript format. Related projects which use Obliq are: Obliq 3-D, a high-level, fast turnaround 3-D animation system; Visual Obliq, a programming environment for building distributed multi-user applications; and Zeus, an algorithm animation system. The latter two are also included in the DEC SRC Modula-3 distribution.
[http://www.research.digital.com/SRC/personal/Luca_Cardelli/Obliq/Obliq.html]
OBQ: An efficient algorithm for estimating the Qth quantile of a set of N data points. The standard error of the quantile estimate is estimated using overlapping batch statistics. This is TOMS algorithm 727 and is documented in Hashem and Schmeiser (1994).
[http://www.acm.org/calgo/contents/]
[http://www.netlib.org/toms/index.html]
Obsidian: An Open Source 3-D network game for Linux and SGI machines, Obsidian is an extensible virtual world system with a multiplayer client-server architecture. It is not a VRML2 world system although there are plans to include that as a world data format option. The features include:

use of generic TCP/IP;

full 3-D headsup with texture mapping;

editable worlds and textures; and

inter-player communications.

A source code version of the present (8/98) alpha version is available.
[http://www.zog.net.au/computers/obsidian/]
occ: A C- compiler written in ML. C- is a portable assembly language meant to be used as a backend for high level languages. A major goal is to provide portable support for features needed by advanced languages, e.g. garbage collection, exception handling and debugging, without building specific instances of such things.
A source code distribution is available which runs under Standard ML and has backends for Alpha32 and X86. A manual is available in PostScript format.
[http://www.cse.ogi.edu/PacSoft/projects/C-/]
[http://research.microsoft.com/Users/simonpj/c-.html]
OCCOMM: The ocean model boundary exchange communications kernel benchmark is a low-level communications kernel benchmark that determines the performance of various message passing techniques as applied to contiguous, single- and double-strided data structures typically found in ocean and other grid-based models. The message passing libraries tested by this include MPI and PVM. A source code distribution is available as well as a user's guide in PostScript format.
[http://www.dkrz.de/dkrz/parallel/occomm/home-eng.html]
Ocean Acoustics Library: A repository of acoustic modeling software and data supported by the Office of Naval Research (ONR) Ocean Acoustics Program as a means of publishing software of general use to the ocean acoustics community. The contents are divided into several categories. Software involving ray analysis includes:

BELLHOP, a Gaussian/finite element beam code in the Acoustics Toolbox;

HARPO, a 3-D ray tracing program for acoustic waves in the ocean;

RAY, an ocean acoustic ray tracing program written in C; and

TRIMAIN, a range-dependent ray tracing package.

Packages related to normal modes include:

COUPLE, a stepwise coupled normal mode program for finding the 2-D underwater acoustic field;

KRAKEN, a normal mode program for range-varying environments contained in the Acoustics Toolbox suite;

MOATL, a program for computing acoustic transmission loss using normal modes;

NLAYER, a normal mode transmission loss program; and

WKBZ, an adiabatic ocean acoustic normal mode program using the WKB approximation.

Programs involving the use of the parabolic equation include:

FOR3D, for calculating ocean acoustic transmission using the parabolic equation method;

MMPE, a parabolic equation model that is a continuation of the UMPE effort;

PDPE, a program using the parabolic equation method for calculating the pressure in an oceanic waveguide;

RAM, a package for solving range-dependent ocean acoustics problems using the parabolic equation methodp; and

UMPE, a parabolic equation model for ocean acoustic propagation.

Wavenumber integration packages include:

OASES, for modeling seismo-acoustic propagation in horizontally stratified waveguides using wavenumber integration;

RPRESS, for the computation of seismo-acoustic wavefields in range-independent fluid-solid media;

SCOOTER, a wavenumber integration program in the Acoustics Toolbox; and

SPARC, a time-domain wavenumber integration program in the Acoustics Toolbox.

[http://oalib.njit.edu/]
OCEAN: A comprehensive chip design package which includes a full set of powerful tools for the synthesis and verification of semi-custom sea-of-gates and gate-array chips. OCEAN handles the back-end of the design trajectory from circuit level down to layout and a working chip. It is suitable for any low-cost chip design application, with large high-performance circuits up to a 90 MIPS processor having been designed with it. It was originally intended for research and educational purposes. The key feature is a hierarchical layout design style which allows the layout to be structured in the same way as the circuit. This allows large structured blocks such as registers or an ALU to be efficiently designed at the cost and design speed of a gate array.

The features of OCEAN include:

convenient input from logical synthesis tools such as SIS and MIS and a SLS-network format for textual circuit entry;

interactive simulation of a circuit at logic-, switch-, and SPICE-levels with the simulator interface allowing switching levels at the stroke of a button;

a circuit hierarchy that doesn't have to be flattened as in other systems so modules of any shape or size can be used and created;

a state of the art placer and router which can handle any number of interconnect layers and which have special power and clock routing facilities to enable high-performance designs;

several special provisions for semi-custom layout (e.g. substrate contacts);

manual placing, routing, viewing and modifying the layout;

verification of the connectivity and correctness of the layout design;

design rule checking and layout purification of manual layouts; and

extraction of circuits from layouts with the capability of extracting accurate parasitics.

OCEAN consists of a collection of programs of which the primary ones are:

SEADALI, an interactive layout editor and general interface for automatic and manual layout generation;

MADONNA, an automatic placer;

TROUT, an automatic router and connectivity verifier;

FISH, a layout purifier for sea-of-gates;

SPACE, a layout extractor;

SLS, a logic level and switch level simulator;

SIMEYE, an interactive simulator interface;

GHOTI, a circuit purifier for SPICE; and

CSLS, XSLS, CEDIF, and XEDIF for reading and writing various formats.

A source code distribution of OCEAN is available. It is written in C and C++ and has been compiled on several platforms including Linux Intel. Binaries are also available for Linux Intel platforms. Documentation is available in PostScript format.
[http://cas.et.tudelft.nl/software/ocean/ocean.html]
oceanography software: Software related to oceanography includes:

ACADIA, a finite element formulation of the advection-diffusion-reaction equation;

Acoustics Toolbox, a collection of codes pertaining to ocean acoustic modeling;

Air-Sea, a Matlab toolbox for computing surface wind stress and heat flux components from various measurements;

bobstuff, Matlab programs for performing vector correlation, complex correlation and various other statistical tasks encountered in oceanography;

COUPLE, a program for performing a stepwise mode calculation of q a 2-D underwater acoustic field;

EOFPACK, a set of codes for performing various types of EOF analysis;

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

flow1, simulates the motion of drifters in a random velocity field;

FUNDY, a 3-D diagnostic model for baroclinic, wind-driven and tidal circulation in shallow seas;

MDD, a Matlab package for designing and evaluating ocean moorings;

MOM, a 3-D primitive equation general ocean circulation model composed of modular components;

NUBBLE, a turbulent boundary layer model for the linearized shallow water equations;

OASES, general purpose code for modeling seismo-acoustic propagation in horizontally stratified waveguides using wavenumber integration and the DGM solution technique;

Ocean Acoustics Library, a collection of ocean acoustic modeling software and data;

OAX, a spatial objective analysis program;

OCCOMM, an ocean model boundary exchange communications kernel benchmark;

OCEANS, a collection of Matlab toolboxes useful for various oceanographic tasks;

POM, a sigma coordinate, free surface, primitive equation ocean circulation model with a turbulence sub-model;

QUODDY, a finite element circulation model;

RAM, a package for solving range-dependent ocean acoustics problems using the parabolic equation method;

RPSstuff, time series manipulation and analysis tools developed for oceanographic applications;

SCRUM, an ocean circulation model that solves the free surface, hydrostatic, primitive equations over variable topography using stretched terrain-following coordinates in the vertical and orthogonal curvilinear coordinates in the horizontal;

SEA, an ocean circulation model;

SEA-MAT, a collaborative effort to organize and distribute Matlab tools for the oceanographic community;

SPEM, a finite-difference ocean general circulation model;

STAPLOT, a Matlab program library for analyzing oceanographic data during and after a cruise;

Timeplt, Matlab routines for Gregorian labeling of stacked time series plots including vector stick plots;

TRIMAIN, a program for applying acoustic ray theory to a horizontally varying ocean; and

UNIVAR, a set of programs for performing various tasks in univariate statistical analysis.

Graphics packages that are especially useful for oceanographers include:

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

Ferret, an interactive and command-line 2-D graphics system developed for oceanographic applications;

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

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

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

Gri, a language for drawing scientific graphs;

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

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

M-Map, a set of Matlab mapping tools for projecting and plotting data in 15 different spherical projections;

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

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

Vis5D, a package for visualizing output from numerical weather models and similar sources.
OCEANS: A collection of Matlab programs (m-files) useful for various oceanographic tasks. The routines include:

bvfreq, for computing the Brunt-Vaisala frequency;

potentialtemp, for computing the potential temperature;

depth, for computing the depth given the pressure at some latitude;

soundspeed, for calculating the speed of sound using various standard equations;

swcp, for computing the heat capacity of sea water;

swstate, for computing the density and specific volume anomalies using the equation of state for sea water;

stickplot, for creating a standard stickplot graph for vector time series;

tsdiagram, for drawing a TS-diagram with density contours and a freezing curve; and

various other utility and demonstration programs.

These programs can be used with Matlab or with the freely available Octave package which can run most Matlab m-files.
[http://www.ocgy.ubc.ca/~rich/]
OC1: Oblique Classifier 1 is a decision tree induction system combining deterministic hill-climbing with two forms of randomization to find a good oblique split (in the form of a hyperplane) at each node of a decision tree. Oblique decision tree methods are tuned especially for for domains with numeric attributes, although they can be adapted to symbolic or mixed symbolic/numeric attributes. OC1 can generally construct oblique trees that are smaller and more accurate than their axis-parallel counterparts. It has been used for the classification of data in astronomy and DNA sequence analysis. A source code distribution of this C package is freely available for research purposes. It incorporates features intended to support flexible experimentation on a variety of data types, cross-validation experiments, the generation of artificial data, and the graphical display of data sets and decision trees. See Murthy et al. (1994), a PostScript version of which is also available in the distribution.
[http://www.cs.jhu.edu/~salzberg/announce-oc1.html]
OCRchie: An optical character recognition library that reads in a file in standard 2 level TIFF format and creates an ASCII output file. The package includes interactive learning, interactive segmentation of mathematics, page zoning (the ability to automatically or manually zone columns or regions of text), and read-order specification. The latest (3/97) version includes an interactive user interface developed using Tcl/Tk.

The package includes the source code which is written in C++ and which will compile with g++ (which is, in fact, strongly recommended). The Tcl/Tk packages are required as are the TIFF libraries. Thus it should be usable on most generic UNIX platforms including Linux. The package is documented online as well as in the distribution package.
[http://http.cs.berkeley.edu/~fateman/kathey/ocrchie.html]
Octave: A high-level interactive language primarily for numerical computations which is mostly compatible with Matlab. It can do arithmetic for real and complex scalars and matrices, solve sets of nonlinear algebraic equations, integrate functions over finite and infinite intervals, and integrate systemes of ordinary differential and differential-algebraic equations. The underlying numerical solvers are standard public domain Fortran packages such as LAPACK, LINPACK, ODEPACK, BLAS, etc. packaged in a library of C++ classes. Plotting (2- and 3-D) is fully supported via Gnuplot.

Significant and/or unique features of Octave include:

command and variable name completion as is found in tcsh and bash;

a command history that is saved between sessions;

a limited amount of support for organizing data in structures such as associative arrays;

the evaluation of Boolean operators in short-circuit fashion;

C-like increment and decrement operators in both prefix and postfix forms;

limited support for exception handling modeled after the unwind-protect form of Lisp;

a mechanism for handling functions that take an unspecified number of arguments and another for those that return an unspecified number of values; and

built-in ODE and DAE solvers.

A source code distribution of Octave is available. It can be installed on most UNIX flavors which have the full GNU GCC suite of compilers already installed. It is documented in a large user's manual, a manual for the C++ classes, and some quick reference cards, all of which are available in Texinfo and PostScript format.
[http://www.che.wisc.edu/octave]
ODBC: The Open DataBase Connectivity standard is an API defining a low-level set of calls allowing client and server applications to exchange instructions and share data without needing to know anything about each other. The ODBC standard aims for maximum interoperability so that a single application can access many DBMS (database management systems), and so applications can be developed and compiled without targeting a specific DBMS product. The ODBC interface defines:

a library of ODBC function calls that enable an application to connect to a DBMS, execute SQL statements, and retrieve results;

a standard way to connect and log on to a DBMS; and

a standardized representation for data types.

ODBC-related applications include:

CQL++, an ODBC compliant DBMS with support for SQL and B-tree/ISAM;

FreeTDS, an implementation of DB-Lib that supports the TDS protocol used by Sybase and Microshaft (with planned support for ODBC);

libsql++, a library that wraps ODBC calls into an object-oriented interface;

mxODBC, a Python interface to ODBC; and

unixODBC, an ODBC solution for UNIX/Linux.
ODE: The OSF Development Environment is a configuration management system designed to allow the simultaneous development on multiple revisions of a single set of sources to be compiled for a variety of different and essentially incompatible hardware platforms. The ODE consists of source code control, a build environment and private and public work areas. Each of these areas allows individual developers to work independently of others yet still allows release engineering to bring all the work together on a regular basis to create systems for testing and release.
The source code code control component features include:

a source code control mechanism that protects a public revision of each file while allowing developers to simultaneously modify private revisions;

a method for merging all of the successfully built and tested private changes back into the public revision; and

a method for reproducing earlier releases for bug fixes.

The build environment features include:

working with source control to facilitate the building of systems for both release and individual development;

a standard set of tools, header files, and libraries to allow official system to be duplicated while giving developers the flexibility to insert their own tools and files as needed; and

embedding many of the details of how a system is to be built in the ODE common makefiles and build tools; and

use of an enhanced version of make with additional functionality to support the build environment.

Source code and binary distributions are available, with the latter including one for Linux Intel. Documentation includes user's and system administrator's guides in Troff format.
[http://www.ede.com/ode/index.html]
ODEPACK: A collection of Fortran solvers for the initial value problem for ordinary differential equation (ODE) systems. It currently includes six solvers, suitable for both stiff and nonstiff systems, and includes solvers for systems given in linearly implicit form as well as solvers for systems given in explicit form.

The solvers for explicit systems include:

LSODE, a basic solver fo stiff and nonstiff systems;

LSODES, a solver which treats the Jacobian matrix in general sparse form in the stiff case and improves upon the earlier GEARS package;

LSODA, which solves systems with a full or banded Jacobian when the problem is stiff but otherwise automatically selects between nonstiff and stiff methods; and

LSODAR, a variant of LSODA with an added rootfinding capability.

The implicit solvers include:

LSODI, which solves linearly implicit systems in which the matrices involved are either full or banded; and

LSOIBT, whichsolves linearly implicit systems in which all thematrices are block tridiagonal.

The source code is written in Fortran and all the routines are written in double precision. A brief description of the software along with further references is contained within an ASCII file. See Hindmarsh (1983). There is a Matlab front-end to LSODE called lsodemat.

[http://www.netlib.org/odepack/index.html]
ODE++: A C++ class library for solving ordinary differential equations (ODE). It currently (7/00) consists of three class hierarchies for:

representing ODE systems;

representing the parameters of ODE problems; and

solving initial value problems.

[http://www.minet.uni-jena.de/www/fakultaet/iam/ode++/ode++_e.html]
Odin: A simpler and more reliable replacement for make whose features include:

building several variants concurrently from a single source tree;

parallel builds on multiple remote hosts;

persistent dependency databases with incremental updates;

building directly from arbitrary versions of RCS and SCCS files without requiring the checkout of a working copy; and

complete separation between build rules and system definitions.

A source code distribution is freely available along with a user's manual in PostScript format.
[ftp://ftp.cs.colorado.edu/pub/distribs/odin/]
OdinMP: A free, portable package implementing the OpenMP specification for ANSI C. OdinMP/CCp accepts full ANSI C with OpenMP extensions as input, and generates ANSI C with calls to the POSIX threads library pthreads. This is portable to any platform on which pthreads, Perl and Java are installed.
[http://www.it.lth.se/odinmp/]
ODMG: The Object Data Management Group develops the industry standard for persistent object storage, i.e. ODMG 2.0. It builds upon existing database, object and programming language standards to simplify object storage and to ensure application portability. It extends Java, C++ and Smalltalk with complete database programming facilities such that objects can be stored directly from any of these languages into ODMG 2.0 compliant databases without having to manage the actual storage process.
The functional components of the ODMG 2.0 standard include:

an Object Model based on the OMG Common Object Model (COM);

an Object Definition Language (ODL) that is a strict superset of the OMG IDL for database schema definition;

an Object Query Language (OQL) providing an environment for efficiently querying database objects; and

a set of Object Manipulation Languages (OML) that extend the abovementioned programming languages to support persistent objects.

[http://www.odmg.org/]
ODRPACK: A portable collection of Fortran subprograms for fitting a model to data. It is designed primarily for instances when the explanatory as well as the response variables have significant errors, implementing a highly efficient algorithm for solving the weighted orthogonal distance regression problem, i.e., for minimizing the sum of the squares of the weighted orthogonal distances between each data point and the curve described by the model equation. It can also be used to solve the ordinary least squares problem where all of the errors are attributed to the observations of the dependent variable. The source code, which compiles into a library containing the ODRPACK programs, is avaiable in single or double precision versions. The documentation is contained within a 100 page user's guide in PostScript format. This is part of CMLIB. See Boggs et al. (1989).
[http://www.netlib.org/odrpack/index.html]
Oedipus: A collection of Python classes and modules for mantaining a hierarchical directory of Web links in the manner of Yahoo and other sites. This can be used to maintain a personal collection of links, or it can use the XML dumps produced by the Open Directory Project.
[http://www.mems-exchange.org/exchange/software/python/oedipus/]
OFELI: The Object Finite Element LIbrary is an object-oriented library of C++ classes for developing finite element codes. The features include:

mesh manipulation;

various matrix storage schemes;

direct linear equation system solvers;

preconditioned iterative solution methods;

a variety of shape functions;

element arrays for many popular problems (e.g. diffusion-convection, fluid flow, elasticity, etc.); and

classes for various problem formulations (e.g. optimization, nonlinear problems, transient analysis, etc.).

[http://wwwlma.univ-bpclermont.fr/~touzani/ofeli.html]
Ofront: An Oberon-2 to C translator. A binary of this is freely available for several platforms including Linux Intel for non-commercial use.

[ftp://ftp.inf.ethz.ch/pub/Oberon/Ofront/]
OGDI: The Open Geographic Datastore Interface is a C and Tcl/Tk programming language interface (API) that facilitates connectivity with various geographic information data formats and products. OGDI uses a standardized access method to work in conjunction with GIS software pacakges and various geospatial data products. A client/server architecture permits the dissemination of data products over any TCP/IP netwrok, and a driver-oriented permits access to several geospatial data products/formats. This provides solutions to several of the most difficult geospatial data integratin problems including:

converting various formats into a uniform transient data structure;

adjusting coordinate systems and cartographic projections;

retrieving geometric and attribute data;

accessing a growing number of geospatial data products and formats; and

making use of the Internet as a medium for the distribution of geospatial data products.

The OGCI architecture can be divided into six components including:

an Application that performs processing, calls functions via the C or Tcl/Tk API, and retrieves results;

a Tcl/Tk API that extends Tcl/TK to access OGDI facilities;

a C API consisting of a dynamically-loadable C library for accessing OGDI facilities;

various Drivers in a dynamically-loadable library for accessing various data formats;

a Network Driver that allows remote access to external data drivers; and

a glftpd application that links the remote driver to external data drivers via the Internet.

A source code distribution of the OGDI package is freely available.
[http://gdal.velocet.ca/projects/ogdi/ogdi.html]
OGR: A C++ library and tools providing read and sometimes write access to a variety of vector file formats.
[http://gdal.velocet.ca/projects/opengis/]
OKBC: Open Knowledge Base Connectivity is an API for accessing knowledge bases stored in knowledge representation systems (KRSs). It provides a uniform model of KRSs based on a common conceptualization of classes, individuals, slots, facets and inheritance. OKBC transparently supports networked as well as direct access to KRSs and knowledge bases. It is defined in a programming language independent way and is available in implementations in Common Lisp, Java and C. The API consists of a set of operations that provide a generic interface to underlying KRSs which isolates an application from the idiosyncrasies of specific KRSs and enables the development of portable tools.
[http://www.ai.sri.com/~okbc/]
[http://www-ksl-svc.stanford.edu:5915/doc/release/okbc/index.html]
Omega Project: A project to develop frameworks and algorithms for the analysis and transformation of scientific programs. The software available from the project includes:

the Omega library, a set of routines for manipulating linear constraints over integer variables, Presburger formulas, and integer tuple relations and sets;

a code generation library, a set of routines for generating code to scan the points in the union of a number of convex sets;

the Omega calculator, a text-based interface to the Omega library;

the Uniform library, a source-to-source parallelizing transformation system; and

Petit, an educational/research tool for analyzing array data dependencies.

Source code distributions for all of the components of the Project are available. They are written in C++ and known to compile with g++. Documentation is available separately for the calculator, the library, and Petit, each in PostScript format. See Pugh (1992).
[http://www.cs.umd.edu/projects/omega/]
Omega Statistical Computing Project: A joint project with the goal of providing Open Source software for statistical applications, especially distributed applications. The project was initiated by the designers of S, R and XLispStat, and is directed to anyone wanting to extend the computing capabilities in one of those existing languages, those interested in statistical software based on Java and the Web, and those interested in the design of new statistical languages. The Omega software will be available on three levels:

as Java packages implementing methods of interest in statistical applications;

as mechanisms for distributed access to methods, e.g. use of the CORBA standard for distributed computing and interfaces to existing statistical systems; and

as interactive languages, including one or more languages developed for Omega itself.

One of the foundations of the project will be the implementation of an interactive language that is a superset of Java. The features of this language include:

object databases with persistence;

scoping implemented as a single search path that operates as a stack;

optional type checking;

optional lazy evaluation of arguments;

function overloading via functions that persist in databases;

support for user-level interpreted classes;

dynamic class loading extensions;

initialization of arrays;

a facility for call dispatching that handles function invocation, method dispatching and internal methods provided by the evaluator;

one or more graphical interfaces implemented in, e.g. Swing;

prompt evaluation via an interactive interpreter; and

multiple evaluator classes, instances and threads.

This project is currently (3/99) in the development stage.
[http://www.omegahat.org/]
OMF: The Weather Observation Definition Format is an application of XML to describe weather observation reports. The design goals of OMF are:

to mark up (i.e. annotate) raw observation reports with additional descriptions and derived, computed quantities;

to not modify the raw data which should be extractable simply by stripping away all the tags;

concision such that communication channels aren't unduly strained; and

extensibility while maintaining backwards compatibility.

[http://zowie.metnet.navy.mil/~spawar/JMV-TNG/XML/OMF.html]
[http://www.oasis-open.org/cover/xml.html]
omi: A package for FTP mirroring. This is currently (12/98) in alpha release.
[http://dorifer.heim3.tu-clausthal.de/~olli/omi/]
OMIS: The On-line Monitoring Interface Specification is the definition of a standard interface between various types of tools for parallel and distributed systems and the systems themselves. Tools require means for the observation and manipulation of the execution of parallel programs. Different tools need similar sets of information and manipulation facilities, and these facilities must be implemented for a large variety of target systems. A monitoring system with a standardized interface will allow a target system to be quickly supplied with the same powerful set of tools as other systems. OMIS is a project to define such an interface. Nothing is as yet available from this project, but all software products will be made available under the terms of the GPL.

[http://wwwbode.informatik.tu-muenchen.de/Par/tools/Projects/OMIS.html]
OMNeT++: The Objective Modular Network Testbed in C++ is an object-oriented modular discrete event simulator. OMNeT++ can be used for modeling communication protocols, computer networks and traffic, multiprocessors and distributed systems, and any other system that lends itself to the discrete event approach. A model developed with this consists of modules that communicate via message passing. These are called simple modules and are written using the simulation class library. Simple modules can be grouped together into compound modules with no limit to the number levels in the hierarchy, with a topology description language used for defining compound modules.

The components of OMNeT++ include:

a simulation kernel including a class library containing statistical, histogram, transient detection, container, parameter objects, message and output classes;

command line (Cmdenv) and graphical (Tkenv) interfaces;

NED, a topology description language with powerful features for specifying regular topologies such as chains, rings, hypercubes, and tree structures;

GNED, a graphical network editor that can generate NED files; and

Plove, a tool for plotting and analyzing simulation results that is built on top of Gnuplot.

A source code distribution of OMNeT++ is available. The development platform is a Linux Intel box with Tcl/Tk and Gnuplot. A user's manual is available in HTML format.
[http://www.hit.bme.hu/phd/vargaa/omnetpp.htm]
Omni: A collection of programs and libraries written in C and Java for building code transformation systems, i.e. compilers. The OpenMP C compiler is a component of this package that translates C and Fortran programs with OpenMP pragmas into C code that can be compiled with a native compiler linked with the Omni OpenMPP runtime library. The goal of the project is to create a portable implementation of OpenMP for both SMPs and clusters of SMPs.
The software consists of two major parts:

front-end programs that translate C and Fortran 77 programs containing OpenMP commands into an intermediate code called Xobject; and

Java libraries that transform Xobject code and generate C code with embedded threading commands.

[http://pdplab.trc.rwcp.or.jp/Omni/]
OMNI: A driver for printing via Ghostscript that contains support for over 100 printers and establishes a model allowing for additional devices to be easily added by editing or adding device description files. The features include:

the ability to easily extend existing device support via a well defined pluggable interface;

dynamic loading of new device support;

accurate per device printer features supported through command line options; and

a utility of querying the available options on a specific device.

[http://oss.software.ibm.com/developer/opensource/linux/projects/omni/]
OmniBroker: The name of this has been changed to ORBacus.
OmniMark: A network programming language for developing server and CGI-based network applications. The features include:

an English-like syntax and task-specific capabilities;

expressive pattern matching including nested pattern matching;

common language constructs including conditionals, loops, variables, functions, macros and arrays (including associative arrays);

developer libraries for database and network connectivity;

external functions for calling modules written in C, C++, Java and other languages;

various web relays including ISAPI, NSAPI, Apache and generic CGI;

an I/O model with powerful streaming support;

a flow handling feature called Catch and Throw that enables major redirections of program flow in a safe and structured way;

referents that enable simple and sophisticated data resequencing;

advanced link management capabilities for automating hypertext link generation; and

extensive native support for XML and SGML.

Source and binary distributions are freely available. Extensive documentation is available in HTML and various other formats.
[http://www.omnimark.com/]
OmniMoni: A highly configurable, real-time, program for monitoring UNIX system process information. It periodically displays textual messages as well as solid or lined graphs in a user configurable format in an X Window. A configuration file contains information about what OmniMoni is supposed to display and how to display it.
A source code distribution of OmniMoni is available. It is written in Tcl/Tk and thus requires the wish interpreter from that package if it is to be used. It is documented in a man page. Several example OmniMoni scripts are included in the distribution to familiarize the user with their form and function.
[http://sunsite.unc.edu/pub/Linux/system/status/]
omniORB: An object request broker (ORB) which implements version 2.0 of the CORBA specification. The implementation of the Internet Inter-ORB Protocol (IIOP) provides omniORB with the means of achieving interoperability with the ORBs implemented by others. The IIOP is the native protocol used by omniORB for communication amongst objects residing in different address spaces. The C++ language binding is supported.
OmniORB is fully multithreaded. Low IIOP call overhead is achieved by eliminating unnecessary call-multiplexing so at any time there is at most one call in-flight in each communication channel between two address spaces. This is done without limiting the level of concurrency by creating new channels connecting the two address spaces on demand and caching when there are more concurrent calls in progress, with each channel served by a dedicated thread. The package is also highly portable, with the IDL to C++ mapping for all targets the same. It uses real C++ exceptions and nested classes, and the CORBA specification standard mappings are adhered to as much as possible rather than using alternative mappings for C++ dialects. OmniWEB relies on native thread libraries to provide multithreading capabilities, with a small class library used to encapsulate the APIs of the native libraries.
A source code distribution of omniWEB is available as well as binary versions for Sun Solaris, DEC Digital UNIX, Linux Intel, and Windows NT platforms. The source code can be ported to any platform which supports POSIX threads, BSD sockets, and has a C++ compiler which supports exceptions. A user's guide is available as well as manuals on thread abstraction, the COS naming service, and the omniORB utilities. All are available in PostScript, PDF, and HTML format.
[http://www.uk.research.att.com/omniORB/]

omniORBpy

A complete CORBA ORB for Python. It follows the official OMG CORBA to Python mapping. The runtime uses a Python extension module written in C++ to talk to the rest of omniORB, although the stubs generated from IDL are pure Python.
[http://www.uk.research.att.com/omniORB/omniORBpy/]
OMP: A Matlab toolbox for using Optimal MultiParameter analysis in physical oceanography. OMP analysis is used to analyze water mass mixtures in a water sample by calculating the contributions from the original water masses. It is based on a simple model of linear mixing wherein it is assumed that all water mass properties undergo the same mixing processes, thus allowing their distribution in space to be determined via the solution of a linear set of mixing equations.
[http://www.ifm.uni-hamburg.de/~karstens/omp_std/]
OmSim: An environment for modeling and simulation based on Omola, an object oriented language for the modeling of continuous time and discrete event dynamical systems. OmSim has been used to model and simulate power grids, chemical processes, heat exchangers, valves with friction, power generation, and adaptive controllers. The OmSim environment consists of a parser which is invoked to load Omola model definitions into the environment, a library browser which allows the viewing of the contents of a loaded library and to select an object from it, a graphical model editor used for displaying and editing Omola models, a simulator which compiles Omola models and translates it into a suitable form, and a command language interpreter (OCL) which is a language for writing command procedures for setting up and running simulation experiments in OmSim.

The Omola language is designed to support model development and reuse. Models can be decomposed hierarchically with well-defined interfaces to describe interactions. All model components are represented as classes, with inheritance and specialization supporting easy modification. It supports behavioral descriptions in terms of differential-algebraic equations (DAEs), difference equations, and discrete events. OmSim analyzes and manipulates the model written in Omola to generate efficient simulation code so the user need not transform the equations into assignment statements. The manipulations include preevaluation of all constant subexpressions, elimination of algebraic variables from the dynamic problem when feasible, reduction of the DAE index, and identification of common expressions to avoid multiple evaluations.
A source code distribution of OmSim is available. Binary distributions are also available for HP-UX, Sun SunOS and Solaris, and Linux Intel platforms. The system is documented in a tutorial and user's manual available in PostScript format.
[http://www.control.lth.se/~cace/omsim.html]

Next: On-Oz Up: Linux Software Encyclopedia Previous: Nn-Nz Contents

Manbreaker Crag 2001-03-08