Overview
This document provides pointers to the most useful classes of the Orbital library
along with a brief description of possible applications. It helps you
jump right into action, profiting from the various features of the Orbital
library, spontaneously. Nevertheless, there are still large parts of the library
which  however useful  can not be discussed here, briefly. To discover them
you should still browse the primary documentation.
Interesting Pointers, Links, Hints, and Examples

GeneralSearch
is the main class for general purpose statespace search algorithms
applicable in various problems. For applying a multitude of different
algorithms for general search problems it is sufficient to model the specific
problem as a statemodel. In programming terms, this is achieved by
implementing a common interface shared amongst all implementations.
Especially conservative artificial intelligence problems profit from this
collection of readytouse algorithms. Some example applications of
GeneralSearch
are provided, including 8Puzzle,
and Rubik's Cube.
A very simple example is provided as SimpleGSP.
 Several additional algorithmic
templates are available that follow the same scheme of providing the
algorithms for problem solution and deferring the problemspecific part into
an interface. These include backtracking problems, greedy algorithms, Divide
and Conquer, dynamic programming, MDPs. See the documentation of these algorithms for more details.
Also see the Algorithms subdirectory of the
examples, as well as robot
navigation, and Knapsack.

CustomizerViewController
has the capability of inventing a standard customizer for JavaBeans from
scratch justintime. With just a few calls to reflection and introspection, a default customizer view
appears that allows changing the properties of any Bean very easily. If
available, a bean's corresponding BeanInfo class is queried for property descriptions
etc. Even incredibly sophisticated user dialogs can be created by providing a BeanInfo class with
extended information, or register new PropertyEditors. An application that
uses the default customizer to allow the user change its settings is kept in
the Propertizer subdirectory of the examples.
For instance, you can automagically create customizers like the following without programming:

Functionals,
and Setops
constitute a useful combination of powerful tools for collection data processing.
Functionals provides very general functional combinators and possibilities for
processing collections of data in bulks in a very simple way. Setops complements
this with typical set operations, implicit traversion, filtering, powersets,
crossproducts. In conjunction, Functionals and Setops provide a very flexible
and simple way of using functionalstyle operations in Java.

Arithmetic objects are
accessible through a common unified interface for arithmetic operations like
+,,*,/,^. Like with polymorphic operators, the advantage of using the
Arithmetic interface for implementing an algorithm or function is, that it
will run unchanged for other algebraic data types of the same
structure and laws. This way, many operations will as well work with
ordinary double value, specialized integer, complexvalued or matrixvalued
data through one single interface. Implementations of arithmetic objects
already support matrix, vector, complex number, functional and even symbolic operations.
Some examples with numerical algorithms, statistics and matrices are provided in the SimpleDemos directory.
To see how easy a single function can be applied to a multitude of different
arithmetic data types, see FunctionalTest.

Mathematical functions
have a general interface for functions in mathematics with the abilities of
(even symbolic) differentiation and integration. Along with several
compositional functionals that are aware of symbolic derivatives as well,
comes a bunch of common function implementations. What often proves very
useful, too, are the generalized mathematical operations
provided, which can handle arithmetic objects as well as functions. There is
also a parser for mathematical expressions in the implementation package
orbital.moon.logic
.
Apart from the Functional
subdirectory of the examples, functions are also used in some of the SimpleDemos.
 Logic functions, predicates
and functionals
found the basis for the major part of this library, and also form the
foundations of the mathematical functions API. However, they have
proven to be that useful in such a broad range of situations that you may
well want to apply them directly, too. What you can expect them to do is
provide a framework for generalized callbacks, allow functional operations
like composition, argument binding, list mapping, function nesting, and
argument swapping. They also give you essential tools for structural
composition of functions and common schemes of recursion, as well as fixed
point operations. Last but not least, you will get term substitution
functions and a term rewrite system for Java.
Although the examples include a directory Functional
just for functions, you can also admire them in real world use in the other
examples, due to their virtual omnipresence.

Logic is a
generic logic framework and has an implementation of classical logic and
fuzzy logic. It provides you with a general interface to logic systems. As with all logic functions you can choose between different notations
(prefix, infix, postfix,...) for your logical junctors' string representation.
There is also an extensible
parser for logical functions and mathematical expressions in the
implementation package
orbital.moon.logic
. The documentation
of the logic package is itself very extensive and selfcontained, while some examples of applications are
provided in the Logic
subdirectory. Also note that there is a binary tool (in the bin
subdirectory) for invoking classical logic and the mathematical parser from
the command line. Call
"ClassicalLogic help" for help.

StreamMethod is a class that
introduces concurrent and streamed connectors that turn programming multithreaded methods with multiple returnvalues or collections into
something almost as simple as conventional single threaded programming.
Additionally, instead of affecting the implementation of a stream method,
its aspect of synchronicity is merely parametric. A short instructive code
snippet with tree iterators is contained in the documentation of
StreamMethod. Examples showing how to apply stream methods and comparing the different modes
of stream method connectors are provided in the SimpleDemos
directory, whilst a real world example is an asynchronous variation of the 8Puzzle
implementation.