Algorithms
Overview
Algorithmic modules can be divided into three groups:
- General-purpose modules
corerandom
- Domain-specific modules
binaryreal-valuedtheorem-prover
- Application-specific modules
geneticflockemas
General-purpose modules
The core module contains the main classes and interfaces for writing evolutionary algorithms, along with many abstract high-level implementations.
The random module interfaces provide interfaces for random number generators, decoupling algorithms from these generators' implementations.
You can find more in-depth descriptions in the following sections:
Parameterized strategies
Most strategies in solution packages are parameterized by some S suptype of ISolution. This is usually the type of solution they are able to perform some operations on (e.g. factories, mutations, etc.).
Instances of these strategies need to provide an actual type parameter. That way, because of Java Generics invariance, we can be type-safely put together multiple genetic operators which can inter-operate together, while being sure that any of them won't get solutions of a type it does not support.
More specific strategies, which may need to make some assumptions about solutions, can narrow the solution type they can handle. That way, genetic operators which only make sense with regard to some specific kind of solutions can define this fact declaratively at a language level, and any misuse won't even compile.
Domain-specific modules
These modules provide concrete implementations of the many strategies from the core module, including factories, evaluators, concrete mutators and recombinators, etc..
These implementations are specific and optimized for some kind of representation:
binary- boolean representationsreal-valued- double representationstheorem-prover- integer representations
Application-specific modules
These modules use types from the previous modules and assemble them in ways specific to some kind of evolutionary algorithms: genetic algorithms, flock-based ones, emas, etc.