Orbital library
API Specification

The Orbital library is a class library providing object-oriented representations and algorithms for logic, mathematics and artificial intelligence.

See:
Description

Core Packages

orbital.logic	The logic package and its sub packages contain classes for logical operations and frameworks.
orbital.logic.functor	Contains template interfaces for logic functors like Predicates and Functions that can be used for generalized call-back, and functional operations based upon them.
orbital.logic.imp	Defines a generic interface to (symbolic) logic systems.
orbital.logic.sign	Defines generic interfaces for formal languages.
orbital.logic.sign.concrete	Defines the concrete syntax of formal languages.
orbital.logic.sign.type	Defines interfaces for general type systems.
orbital.logic.trs	Provides a term rewrite system (TRS) mechanism with substitution and unification.
orbital.math	Defines arithmetic objects and provides mathematical algorithms.
orbital.math.functional	Contains mathematical functors and extended functional operations.
orbital.util	Provides basic utility classes useful to ease several programming tasks.

Extension Packages

orbital.algorithm	This package and its sub packages contain important algorithms and algorithmic schemes.
orbital.algorithm.evolutionary	Genetic algorithms simulate nature on a very abstract level to get solutions for sophisticated problems.
orbital.algorithm.template	A framework for general algorithmic evaluation schemes including search and planning algorithms.
orbital.awt	Extends the core Java AWT Package and includes some Beans and GUI add-ons as well as generic customizers.

Implementation Packages

orbital.moon.awt	Implementation of extended Bean, AWT and GUI Add-ons along with useful applet to application converters.
orbital.moon.evolutionary	Contains implementation utilities and a front-end for evolutionary algorithms.
orbital.moon.logic	Contains implementations of some logics as well as a logic and mathematical expression parser.
orbital.moon.logic.functor	Experimental additional classes related to orbital.logic.functors.
orbital.moon.logic.resolution	Provides resolution inference theorem prover implementation and clause management.

The Orbital library is a class library providing object-oriented representations and algorithms for logic, mathematics and artificial intelligence. It comprises theorem proving, computer algebra, search and planning, as well as machine learning algorithms.

Generally speaking, the idea behind the Orbital library is to provide extensional services and components for Java, that are surrounding the heart of scientific applications. This foundation class library is strictly generalized in order to satisfy the requirements of high reusability. So many sophisticated problems can be solved easily with its adaptable components.

Contents

1. Copyright and License Agreement
2. Overview
3. Installation
   1. System Requirements
   2. Downloading the Archive
   3. Installing the Orbital library
   4. Configuring Orbital library with System Properties
4. Features
5. Bug Reports and Feedback
6. Web Pages

Copyright and License Agreement

Carefully read the Copyright Notice and License Agreement contained in the COPYRIGHT.txt file of this distribution. Also see here.

Overview

The Orbital library is divided into these sets of sub packages:

1. Core Packages
2. Extension Packages

Additional implementation specific classes and execution tools, which are subject to change without notice, are kept in:

3. Implementation Packages (sub packages of orbital.moon)

All classes are contained in sub packages of orbital.

Installation

System Requirements

Since the Orbital library is pure Java, you can apply it on virtually any machine, provided that you have already installed a Java Virtual Machine. To ensure maximum usage of the Orbital library, you should use a Java Virtual Machine and Runtime library that is compatible with Sun's JDK 1.4+ for the Java 2 Platform.
However most (but not all) parts of the library also support JDK 1.2+ or earlier.

Downloading the Archive

Prior to installing, you must accept the License Agreement. Then you can download the archive containing the Orbital library from World Wide Web.

Installing the Orbital library

Since the Orbital library is written completely in Java, most of the library is ready for use just after including it in the class-path (see below how). This can be achieved in a multitude of ways depending solely on your preference. However, if you intend to use some very specialized features, you might want to configure some system properties as well in addition to placing the library on the class-path.

In order to get the Orbital library into your class-path, you should either:

• Place the orbital*.jar archive files containing the library classes anywhere on your class-path, which is set in the CLASSPATH environment variable. We recommend this as the most reliable variant.
• Or specify the orbital*.jar files as a "bundled" extension with a relative path in the manifest attribute Class-Path of your program's deployment JAR archive for all applications and applets that use it.
• Or copy the orbital*.jar files as an "installed" extension to the lib/ext directory of the Java 2 platform runtime environment of your JVM. Be aware, however, that there are some situations (like applets or jikes) in which the installed extensions do not work as expected. So you might prefer setting the CLASSPATH explicitly.
• Or add all orbital*.jar files as an additional library to your preferred Integrated Development Environment (IDE). Refer to its documentation for details.

Most Java Virtual Machines work best when the classes are only kept at one single location. So consider simply storing it at a single location in the class-path. Also make sure that no old release of Orbital library is placed in the class-path.

To accelerate loading any Java applets that use the Orbital library from the internet, the archive files are split into several parts. JAR indexing then enables Java Plug-ins with a JVM of 1.3+ to transfer only those files that are necessary. Also specifying the Orbital library as a download extension in the applet's manifest makes sure that the JAR files are only transferred once at all.

The orbital*.jar archive files consist of

1. orbital-core.jar which contains the core packages of Orbital library.
2. orbital-ext.jar which contains the extension packages, implementation packages and additional resources.

Configuring Orbital library with System Properties

There are some additional system properties that help configuring the Orbital library for special applications. They can either be set statically in the system or user properties file of your Java Virtual Machine. Or they are set individually with the help of the -D command line switch of the Java interpreter.

• Math precision settings:
  • orbital.math.MathUtilities.defaultPrecisionDigits
  • orbital.math.MathUtilities.defaultTolerance
• Math implementation settings:
  • orbital.math.Values.implementation
  • orbital.math.Values.default
• Type system settings:
  • orbital.logic.sign.type.TypeSystem.default

Features

The Orbital library is a general extension to the java packages in the form of a foundation class library. It specifies several central concept classes (Core Packages), and whole class networks that contain extended components, generic abstractions, and additional services of reusable Java classes (Extension Packages). See:

• Summary of all features
• Pointers and hints recommending very important classes

Bug Reports and Feedback

Feel free to send a mail to submit a bug or request a feature. To directly submit a bug or request a feature, use:

• feedback form

Please make sure that you specify information as detailed as possible. You should also include a brief description of the operating system, compiler (respectively Java Virtual Machine) and any additional libraries you are using in case they might conflict with the Orbital library.