Up: Linux Software Encyclopedia
Last checked or modified: Nov. 16, 1997
- 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
- 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
- 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:
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.
- 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
- string operations, and
- support for system programming.
The Oberon system features include:
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.
- 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.
Versions of Oberon available for Linux platforms include:
Also useful is the
Oberon Reference Site.
See also the related B2 system.
An interesting site to watch is
See Dotzel and Skulski (1997) for a discussion on Oberon as
an alternative to C++.
See Moessenboeck (1993),
Reiser and Wirth (1992), and
Wirth and Gutknecht (1992).
- 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.
- The Portable Object Compiler is an implementation of
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:
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
- portability to many systems with the native C compiler, debuggers,
- partial support for C++ compilers; and
- the built-in possibility of tracing Objective C messages.
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
See Cox and Novobilski (1991) and
Pinson and Wiener (1991).
- Object REXX
- An object-oriented scripting language based on its procedural
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.
- 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.
- 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
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
See the GNU Objective-C Class Library
libobjects for further details.
See Budd (1991),
Cox and Novobilski (1991), and
Pinson and Wiener (1991).
- 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
The documentation is available in several formats.
This is freely available even for building commercial software.
- object-oriented languages
- Object-oriented languages/implementations
or those with object-oriented features
- 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
- 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.
- 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
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
- 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).
- An Open Source 3-D network game
for Linux and SGI machines,
Obsidian is an extensible virtual world system with a multiplayer
It is not a VRML2 world system although there
are plans to include that as a world data format option.
The features include:
A source code version of the present (8/98) alpha version is
- use of generic TCP/IP;
- full 3-D headsup with texture mapping;
- editable worlds and textures; and
- inter-player communications.
- 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.
- 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
The message passing libraries tested by this include
A source code distribution is available as well as a user's
guide in PostScript format.
- 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:
Packages related to normal modes include:
- BELLHOP, a Gaussian/finite element beam code in the
- 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
- 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
- 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:
Wavenumber integration packages 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.
- 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
- 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
- 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.
- oceanography software
- Software related to oceanography includes:
- ACADIA, a finite element formulation of the
- 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
- 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.
- A collection of Matlab programs (m-files) useful for various
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
- 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
- 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.
- 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
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
See Murthy et al. (1994), a PostScript version of which is
also available in the distribution.
- 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
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.
- 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
BLAS, etc. packaged in a library of
Plotting (2- and 3-D) is fully supported via
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
- 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
- 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
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
- 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:
The build environment features include:
- a source code control mechanism that protects a public revision
of each file while allowing developers to simultaneously modify
- 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.
- 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.
- 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:
The implicit solvers 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.
- 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
- 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.
- A simpler and more reliable replacement for make whose features include:
A source code distribution is freely available along with a user's
manual in PostScript format.
- 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 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
This is portable to any platform on which
pthreads, Perl and
Java are installed.
- 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.
- 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
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).
- 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.
- 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.).
- An Oberon-2 to C translator.
A binary of this is freely available for several platforms
including Linux Intel for non-commercial use.
- 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:
A source code distribution of the OGDI package is freely available.
- 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
- a glftpd application that links the remote driver to external
data drivers via the Internet.
- A C++ library and tools providing read and sometimes
write access to a variety of vector file formats.
- Open Knowledge Base Connectivity is an
API for accessing knowledge bases stored in knowledge representation
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
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.
- 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
Source code distributions for all of the components of the Project
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).
- 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:
This project is currently (3/99) in the development stage.
- 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.
- The Weather Observation Definition Format is an
application of XML to describe weather
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.
- A package for FTP mirroring.
This is currently (12/98) in alpha release.
- 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.
- 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
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
A user's manual is available in HTML format.
- 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.
- 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
- a utility of querying the available options on a specific device.
- The name of this has been changed to
- A network programming language for developing server and
CGI-based network applications.
The features include:
Source and binary distributions are freely available.
Extensive documentation is available in HTML and various other
- 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
- developer libraries for database and network connectivity;
- external functions for calling modules written in
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
- 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
- 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
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.
- A complete CORBA ORB for
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
- A Matlab toolbox for using
Optimal MultiParameter analysis in physical
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.
- 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.
Up: Linux Software Encyclopedia