All Classes and Interfaces
Class
Description
An ADF is a GPNode which implements an "Automatically Defined Function",
as described in Koza II.
An ADFArgument is a GPNode which represents an ADF's
argument terminal, its counterpart which returns argument
values in its associated function tree.
ADFContext is the object pushed onto an ADF stack which represents
the current context of an ADM or ADF function call, that is, how to
get the argument values that argument_terminals need to return.
ADFStack is a special data object used to hold ADF data.
An ADM is an ADF which doesn't evaluate its arguments beforehand, but
instead only evaluates them (and possibly repeatedly) when necessary
at runtime.
AMALGAMSpecies is a FloatVectorSpecies which implements a faithful version of the
iAMaLGaM IDEA algorithm.
Returns an individual using a form of simulated annealing.
Thrown when you attempt to create a Parameter from bad path items.
Best1BinDEBreeder is a differential evolution breeding operator.
Performs a tournament selection restricted to only the best, or worst, n
indivdiuals in the population.
BitVectorIndividual is a VectorIndividual whose genome is an array of booleans.
BitVectorSpecies is a subclass of VectorSpecies with special
constraints for boolean vectors, namely BitVectorIndividual.
Similar to FitProportionateSelection, but with a Simulated Annealing style twist.
A Breeder is a singleton object which is responsible for the breeding
process during the course of an evolutionary run.
A BreedingPipeline is a BreedingSource which provides "fresh" individuals which
can be used to fill a new population.
A BreedingSource is a Prototype which
provides Individuals to populate new populations based on
old ones.
Does a tournament selection, limited to the subpopulation it's
working in at the time.
If empty, a
BufferedBreedingPipeline makes a request of exactly num-inds
individuals from a single child source; it then uses these
individuals to fill requests (returning min each time),
until the buffer is emptied, at
which time it grabs exactly num-inds more individuals, and so on.
ByteVectorIndividual is a VectorIndividual whose genome is an array of bytes.
CheckingPipeline is a BreedingPipeline which just passes through the
individuals it receives from its source 0, but only if those individuals
ALL pass a validation check (the method allValid(), which you must override).
Checkpoints ec.EvolutionState objects out to checkpoint files, or
restores the same from checkpoint files.
Clique is a class pattern marking classes which
create only a few instances, generally accessible through
some global mechanism, and every single
one of which gets its own distinct setup(...) call.
CMAESBreeder is a Breeder which overrides the breedPopulation method
to first update CMA-ES's internal distribution, then replace all the
individuals in the population with new samples generated from the
distribution.
CMAESDefaults is the basic defaults class for the cmaes package.
CMAESInitializer is a SimpleInitializer which ensures that the subpopulations are all set to the provided
or computed lambda values.
CMAESSpecies is a FloatVectorSpecies which implements a faithful version of the
CMA-ES algorithm.
Code provides some simple wrapper functions for encoding and decoding
basic data types for storage in a pseudo-Java source code strings
format.
CompetitiveEvaluator.java
CornerMap can help us to quickly identify the possible individuals that is
able to form a hyperbox around best individual.
CrossoverPipeline is a GPBreedingPipeline which performs a strongly-typed
version of
Koza-style "Subtree Crossover".
DEBreeder provides a straightforward Differential Evolution (DE) breeder
for the ECJ system.
DecodeReturn is used by Code to provide varied information returned
when decoding.
DEEvaluator is a simple subclass of SimpleEvaluator which first evaluates the population, then
compares each population member against the parent which had created it in Differential Evolution.
DefaultsForm is the interface which describes how Defaults objects
should work.
DoubleVectorIndividual is a VectorIndividual whose genome is an array of
doubles.
DOVSBreeder is a Breeder which overrides the breedPopulation method to first
construct hyperbox around current best individual and replace the population
with new individuals sampled from this hyperbox.
DOVSDefaults is the basic defaults class for the dovs package.
The DOVSEvaluator is a SimpleEvaluator to evaluate the Individual.
DOVSFitness is a subclass of Fitness which implements contains important
statistics about simulation results of the individual.
DOVSInitializer is a SimpleInitializer which ensures that the subpopulations
are create from an existing individual read from file.
DOVSSpecies is a IntegerVectorSpecies which implements DOVS algorithm.
ERC is an abstract GPNode which implements Ephemeral Random Constants,
as described in Koza I.
ESSelection is a special SelectionMethod designed to be used with
evolutionary strategies-type breeders.
An Evaluator is a singleton object which is responsible for the
evaluation process during the course of an evolutionary run.
An EvolutionState object is a singleton object which holds the entire
state of an evolutionary run.
Evolve is the main entry class for an evolutionary computation run.
The Exchanger is a singleton object whose job is to (optionally)
perform individual exchanges between subpopulations in the run,
or exchange individuals with other concurrent evolutionary run processes,
using sockets or whatever.
Finisher is a singleton object which is responsible for cleaning up a
population after a run has completed.
FirstCopyPipeline is a BreedingPipeline similar to ReproductionPipeline, except
that after a call to prepareToProduce(...), the immediate next child produced
is produced from source 0, and all the remaining children in that produce()
call and in subsequent produce() calls are produced from source 1.
Always picks the first individual in the subpopulation.
Fitness is a prototype which describes the fitness of an individual.
Picks individuals in a population in direct proportion to their
fitnesses as returned by their fitness() methods.
FloatVectorIndividual is a VectorIndividual whose genome is an array of
floats.
FloatVectorSpecies is a subclass of VectorSpecies with special
constraints for floating-point vectors, namely FloatVectorIndividual and
DoubleVectorIndividual.
ForceBreedingPipeline has one source.
FullBuilder is a GPNodeBuilder which implements the FULL tree building method described in Koza I/II.
A static class that returns the base for "default values" which GE-style
operators use, rather than making the user specify them all on a per-
species basis.
GEIndividual is a simple subclass of IntegerVectorIndividual which not only prints out (for humans)
the Individual as a int vector but also prints out the Individual's tree representation.
Gene is an abstract superclass of objects which may be used in
the genome array of GeneVectorIndividuals.
GeneDuplicationPipeline is designed to duplicate a sequence of genes from the chromosome and append
them to the end of the chromosome.
GenerationSwitchPipeline is a simple BreedingPipeline which switches its source depending
on the generation.
GeneVectorIndividual is a VectorIndividual whose genome is an array of Genes.
GeneVectorSpecies is a subclass of VectorSpecies with special
constraints for GeneVectorIndividuals.
GEProblem is a special replacement for Problem which performs GE mapping.
GESpecies generates GPIndividuals from GEIndividuals through the application of a grammar parse graph
computed by the GrammarParser.
A GPAtomicType is a simple, atomic GPType.
A static class that returns the base for "default values" which various
GP breeding
operators use, rather than making the user specify them all on a per-
species basis.
A GPBreedingPipeline is a BreedingPipeline which produces only
members of some subclass of GPSpecies.
GPData is the parent class of data transferred between GPNodes.
A static class that returns the base for "default values" which GP-style
operators use, rather than making the user specify them all on a per-
species basis.
GPFunctionSet is a Clique which represents a set of GPNode prototypes
forming a standard function set for forming certain trees in individuals.
GPIndividual is an Individual used for GP evolution runs.
GPInitializer is a SimpleInitializer which sets up all the Cliques,
( the initial
[tree/node]constraints, types, and function sets) for the GP system.
A static class that returns the base for "default values" which Koza-style
operators use, rather than making the user specify them all on a per-
species basis.
GPNode is a GPNodeParent which is the abstract superclass of
all GP function nodes in trees.
GPNodeBuilder is a Prototype which defines the superclass for objects
which create ("grow") GP trees, whether for population initialization,
subtree mutation, or whatnot.
A GPNodeConstraints is a Clique which defines constraint information
common to many different GPNode functions, namely return types,
child types, and number of children.
GPNodeGatherer is a small container object for the GPNode.nodeInPosition(...)
method and GPNode.numNodes(...) method.
GPNodeParent is a Prototype which identifies objects which may
be parents of GPNodes, namely: GPTrees and GPNodes.
GPNodeSelector is a Prototype which describes algorithms which
select random nodes out of trees, typically marking them for
mutation, crossover, or whatnot.
A GPProblem is a Problem which is meant to efficiently handle GP
evaluation.
A GPSetType is a GPType which contains GPAtomicTypes in a set, and is used
as a generic GP type.
GPSpecies is a simple individual which is suitable as a species
for GP subpopulations.
GPTree is a GPNodeParent which holds the root GPNode of a tree
of GPNodes.
A GPTreeConstraints is a Clique which defines constraint information
common to many different GPTree trees, namely the tree type,
builder, and function set.
GPType is a Clique which represents types in
Strongly-Typed Genetic Programming (STGP).
A GrammarNode representing a GPNode in the GE Grammar.
The abstract superclass of nodes used by GrammarParser to construct a parse graph to generate
GEIndividuals.
A GrammarParser is the basic class for parsing a GE ruleset into a parse graph of GrammarNodes.
A GrammarNode representing a Rule in the GE Grammar.
GreedyOverselection is a SelectionMethod which implements Koza-style
fitness-proportionate greedy overselection.
GroupedProblemForm.java
GrowBuilder is a GPNodeBuilder which
implements the GROW tree building method described in Koza I/II.
HalfBuilder is a GPNodeBuilder which
implements the RAMPED HALF-AND-HALF tree building method described in Koza I/II.
HyperboxSpecies is a DOVSSpecies which contains method for updating promising
sample area and also sample from that area.
Measures the hypervolume of a population's Pareto front.
An immutable 2-dimensional point.
A simple interface (simpler than List) for accessing random-access objects without changing their size.
An Individual is an item in the EC population stew which is evaluated
and assigned a fitness which determines its likelihood of selection.
InitializationPipeline is a BreedingPipeline which simply generates a new
random inidividual.
The Initializer is a singleton object whose job is to initialize the
population at the beginning of the run.
Maintains a simple array (objs) of ints and the number of ints (numObjs) in the array
(the array can be bigger than this number).
IntegerVectorIndividual is a VectorIndividual whose genome is an array of ints.
IntegerVectorSpecies is a subclass of VectorSpecies with special constraints
for integral vectors, namely ByteVectorIndividual, ShortVectorIndividual,
IntegerVectorIndividual, and LongVectorIndividual.
InternalCrossoverPipeline picks two subtrees from somewhere within an individual,
and crosses them over.
InterPopulationExchange is an Exchanger which implements a simple exchanger
between subpopulations.
IslandExchange is an Exchanger which
implements a simple but quite functional asynchronous
island model for doing massive parallel distribution of evolution across
beowulf clusters.
Job.java
This class stores information regarding a job submitted to a Slave: the individuals,
the subpopulations in which they are stored, a scratch array for the individuals used
internally, and various coevolutionary information (whether we should only count victories
single-elimination-tournament style; which individuals should have their fitnesses updated).
KozaFitness is a Fitness which stores an individual's fitness as described in
Koza I.
KozaNodeSelector is a GPNodeSelector which picks nodes in trees a-la Koza I,
with the addition of having a probability of always picking the root.
A Koza-style statistics generator, intended to be easily parseable with
awk or other Unix tools.
A simple line-by-line String tokenizer.
Does a simple tournament selection, limited to the subpopulation it's
working in at the time.
ListCrossoverPipeline is a crossover pipeline for vector individuals whose length
may be lengthened or shortened.
Modified from
apache mail-archives.
Defines a log to which Output outputs.
A LogRestarter is an abstract superclass of objects which are
capable of restarting logs after a computer failure.
LongVectorIndividual is a VectorIndividual whose genome is an array of longs.
MasterProblem.java
MersenneTwister and MersenneTwisterFast
MersenneTwister and MersenneTwisterFast
MetaProblem is a special class for implenting so-called "Meta-Evolutionary Algorithms",
a topic related to "HyperHeuristics".
Miscellaneous static utility methods.
MuCommaLambdaBreeder is a Breeder which, together with
ESSelection, implements the (mu,lambda) breeding strategy and gathers
the comparison data you can use to implement a 1/5-rule mutation mechanism.
MultiBreedingPipeline is a BreedingPipeline stores some n child sources;
each time it must produce an individual or two,
it picks one of these sources at random and has it do the production.
MultiObjectiveFitness is a subclass of Fitness which implements basic
multi-objective mechanisms suitable for being used with a variety of
multi-objective selection mechanisms, including ones using pareto-optimality.
MultipleVectorCrossoverPipeline is a BreedingPipeline which implements a uniform
(any point) crossover between multiple vectors.
MultiPopCoevolutionaryEvaluator.java
MultiSelection is a SelectionMethod which stores some n subordinate
SelectionMethods.
MuPlusLambdaBreeder is a subclass of MuCommaLambdaBreeder which, together with
ESSelection, implements the (mu + lambda) breeding strategy and gathers
the comparison data you can use to implement a 1/5-rule mutation mechanism.
MutateAllNodesPipeline implements the AllNodes mutation algorithm described
in Kumar Chellapilla,
"A Preliminary Investigation into Evolving Modular Programs without Subtree
Crossover", GP98.
MutateDemotePipeline works very similarly to the DemoteNode algorithm
described in Kumar Chellapilla,
"A Preliminary Investigation into Evolving Modular Programs without Subtree
Crossover", GP98, and is also similar to the "insertion" operator found in
Una-May O'Reilly's thesis,
"An Analysis of Genetic Programming".
MutateERCPipeline works very similarly to the "Gaussian" algorithm
described in Kumar Chellapilla,
"A Preliminary Investigation into Evolving Modular Programs without Subtree
Crossover", GP98.
MutateOneNodesPipeline implements the OneNode mutation algorithm described
in Kumar Chellapilla,
"A Preliminary Investigation into Evolving Modular Programs without Subtree
Crossover", GP98.
MutatePromotePipeline works very similarly to the PromoteNode algorithm
described in Kumar Chellapilla,
"A Preliminary Investigation into Evolving Modular Programs without Subtree
Crossover", GP98, and is also similar to the "deletion" operator found in
Una-May O'Reilly's thesis,
"An Analysis of Genetic Programming".
MutateSwapPipeline works very similarly to the Swap algorithm
described in Kumar Chellapilla,
"A Preliminary Investigation into Evolving Modular Programs without Subtree
Crossover", GP98.
MutationPipeline is a GPBreedingPipeline which
implements a strongly-typed version of the
"Point Mutation" operator as described in Koza I.
NEATBreeder is a Breeder which overrides the breedPopulation method to first
mark the individuals in each subspecies that are allow to reproduce, and
replace the population with new individuals in each subspecies.
NEATDefaults is the basic defaults class for the neat package.
NEATGene is the combination of class Gene and class Link in original code.
NEATIndividual is GeneVectorIndividual with NEATNetwork as phenotype.
NEATInitializer is a SimpleInitializer which ensures that the subpopulations
are all create from an existing template individual read from file.
NEATInnovation is a class for recording the innovation information during the
evolution of neat.
NEATNetwork is the phenotype of NEATIndividual.
NEATNode is the class to represent node in network, it stores status of the
node in that network.
The activation function is used in for hidden node.
The place this node could be.
The type of a node.
NEATSpecies is a GeneVectorSpecies which implements NEAT algorithm.
NEATSubspecies is the actual Species in original code.
ECJ implements Push's s-expressions as trees of nonterminals
and terminals.
This SimpleBreeder subclass breeds a set of children from the Population, then
joins the original Population with the children in a (mu+mu) fashion.
We use a state variable to make sure that the nextSubpopulationSize() method
is only called at the appropriate time.
NSGA2MultiObjectiveFitness is a subclass of MultiObjeciveFitness which
adds auxiliary fitness measures (sparsity, rank) largely used by MultiObjectiveStatistics.
Outputs and logs system messages, errors, and other various
items printed as a result of a run.
Thrown whenever a problem occurs when attempting to output to a Log.
This exception is thrown by the Parameter Database when it fails to
locate and load a class specified by a given parameter as requested.
A Parameter is an object which the ParameterDatabase class
uses as a key to associate with strings, forming a key-value pair.
This extension of the Properties class allows you to set, get, and delete
Parameters in a hierarchical tree-like database.
Particle is a DoubleVectorIndividual with additional statistical information
necessary to perform Particle Swarm Optimization.
PBILBreeder is a Breeder which overrides the breedPopulation method
to first update PBIL's internal distribution, then replace all the
individuals in the population with new samples generated from the
distribution.
PBILSpecies is an IntegerVectorSpecies which implements a faithful version of the
PBIL algorithm.
A Population is the repository for all the Individuals being bred or
evaluated in the evolutionary run at a given time.
Problem is a prototype which defines the problem against which we will
evaluate individuals in a population.
This selection method adds parsimony pressure to the regular tournament selection.
Prototype classes typically have one or a few prototype instances
created during the course of a run.
PSOBreeder is a simple single-threaded Breeder which performs
Particle Swarm Optimization using the Particle class as individuals.
PTC1 implements the "Strongly-typed Probabilistic Tree Creation 1 (PTC1)" algorithm described in
PTC2 implements the "Strongly-typed Probabilistic Tree Creation 2 (PTC2)" algorithm described in
PTCFunctionSet is a GPFunctionSet which adheres to PTCFunctionSetForm, and thus
can be used with the PTC1 and PTC2 methods.
PTCFunctionSetForm defines the methods that the PTC1 and PTC2 tree-creation
algorithms require of function sets.
PushBuilder implements the Push-style tree building algorithm, which permits nonterminals of arbitrary arity.
PushInstruction encapsulates a custom Push instruction.
A PushProblem contains useful methods to help you create an
interpreter, write out the ECJ GP tree to a string, build a Push Program
around this string, load the interpreter with all your custom instructions,
and run the Push Program on the interpreter.
Implementations of various center-pivot QuickSort routines in Java,
and (if you really want 'em) Insertion Sort routines as well.
Rand1EitherOrDEBreeder is a differential evolution breeding operator.
RandomBranch implements the Random_Branch tree generation
method described in
RandomChoice organizes arrays of floats into distributions which can
be used to pick randomly from.
Used by RandomChoice to pick objects by probability from a distribution.
Used by RandomChoice to pick objects by probability from a distribution.
A special Statistics class which performs random restarts on the population,
effectively reininitializing the population and starting over again.
Picks a random individual in the subpopulation.
Does a tournament selection, limited to the subpopulation it's
working in at the time.
RehangPipeline picks a nonterminal node other than the root
and "rehangs" it as
a new root.
RepeatPipeline is a BreedingPipeline which, after prepareToProduce() is called,
produces a single individual from its single source, then repeatedly clones that
child to fulfill requests to produce().
ReproductionPipeline is a BreedingPipeline which simply makes a copy
of the individuals it recieves from its source.
Rule is an abstract class for describing rules.
RuleConstraints is a class for constraints applicable to rules.
RuleCrossoverPipeline is a BreedingPipeline which implements a simple default crossover
for RuleIndividuals.
A static class that returns the base for "default values" which rule-style
operators use, rather than making the user specify them all on a per-
species basis.
RuleIndividual is an Individual with an array of RuleSets, each of which
is a set of Rules.
A SimpleInitializer subclass designed to be used with rules.
RuleMutationPipeline is a BreedingPipeline which implements a simple default Mutation
for RuleIndividuals.
RuleSet is a set of Rules, implemented straightforwardly as an arbitrary-length array of Rules.
RuleSetConstraints is an basic class for constraints applicable to rulesets.
RuleSpecies is a simple individual which is suitable as a species
for rule sets subpopulations.
A SelectionMethod is a BreedingSource which provides direct IMMUTABLE pointers
to original individuals in an old population, not fresh mutable copies.
Setup classes are classes which get set up once from user-supplied parameters
prior to being used.
ShortVectorIndividual is a VectorIndividual whose genome is an array of shorts.
Similar to FitProportionateSelection, but with adjustments to scale up/exaggerate differences in fitness for selection when true fitness values are very close to
eachother across the population.
Breeds each subpopulation separately, with no inter-population exchange,
and using a generational approach.
The SimpleEvaluator is a simple, non-coevolved generational evaluator which
evaluates every single member of every subpopulation individually in its
own problem space.
A SimpleEvolutionState is an EvolutionState which implements a simple form
of generational evolution.
A SimpleExchanger is a default Exchanger which, well, doesn't do anything.
SimpleFinisher is a default Finisher which doesn't do anything.
A simple default fitness, consisting of a double floating-point value
where fitness A is superior to fitness B if and only if A > B.
This portrayal uses a text pane to display the results of
printIndividualForHumans().SimpleInitializer is a default Initializer which initializes a Population
by calling the Population's populate(...) method.
SimpleProblemForm is an interface which defines methods
for Problems to implement simple, single-individual (non-coevolutionary)
evaluation.
A Simple-style statistics generator, intended to be easily parseable with
awk or other Unix tools.
A basic Statistics class suitable for simple problem applications.
A Singleton is a class for which there will be only one instance
in the entire course of a run, and which will exist for pretty
much the entire run.
SizeFairCrossover works similarly to one written in the paper
"Size Fair and Homologous Tree Genetic Programming Crossovers" by Langdon (1998).
Slave.java
SlaveMonitor.java
The interface for passing objects to ec.util.QuickSort
The interface for passing objects to ec.util.QuickSort
In a spatially-embedded EA, the subpopulations of individuals are assumed to be
spatially distributed in some sort of space, be it one-dimmensional, two-
dimmensional, or whatever else.
A Spatial1DSubpopulation is an EC subpopulation that is additionally embedded into
a one-dimmensional space.
A slight modification of the simple breeder for spatially-embedded EAs.
SpatialMultiPopCoevolutionaryEvaluator implements a coevolutionary evaluator involving multiple
spatially-embedded subpopulations.
A slight modification of the tournament selection procedure for use with spatially-embedded EAs.
This subclass of SimpleBreeder overrides the loadElites method to build an archive in the top elites[subpopnum]
of each subpopulation.
We use a state variable to make sure that the archive isn't built twice in a row.
SPEA2MultiObjectiveFitness is a subclass of MultiObjectiveFitness which adds three auxiliary fitness
measures used in SPEA2: strength S(i), kthNNDistance D(i), and a final fitness value R(i) + D(i).
Species is a prototype which defines the features for a set of individuals
in the population.
Statistics and its subclasses are Cliques which generate statistics
during the run.
This subclass of Breeder performs the evaluation portion of Steady-State Evolution and (in distributed form)
Asynchronous Evolution.
This subclass of Evaluator performs the evaluation portion of Steady-State Evolution and (in distributed form)
Asynchronous Evolution.
This subclass of EvolutionState implements basic Steady-State Evolution and (in distributed form)
Asynchronous Evolution.
The SteadyStateExchangerForm is a badge which Exchanger subclasses
may wear if they work properly with the SteadyStateEvolutionState
mechanism.
This interface defines the hooks for SteadyStateEvolutionState objects
to update themselves on.
StubPipeline is a BreedingPipeline subclass which, during fillStubs(), fills all the stubs
with its own stub pipeline.
Subpopulation is a group which is basically an array of Individuals.
Picks individuals in a population using the Stochastic Universal Selection (SUS) process, using
fitnesses as returned by their fitness() methods.
This Statistics subclass implements Poli's "Tarpeian" method of parsimony control, whereby some
kill-proportion of above-average-sized individuals in each subpopulation have their fitnesses
set to a very bad value, and marks them as already evaluated (so the Evaluator can skip them).
Terminal is the leaf node in Push trees and is used to represent Push
instructions of all types.
ThreadPool.java
A simple, lightweight thread pool, for those who cannot or will not use Java's baroque
java.util.concurrent package.
A Worker is a special kind of object which represents an underlying
Worker thread usable in the ThreadPool.
Returns the single fittest individual in the population, breaking ties randomly.
Does a simple tournament selection, limited to the subpopulation it's
working in at the time.
Uniform implements the algorithm described in
UniquePipeline is a BreedingPipeline which tries very hard to guarantee that all
the individuals it produces are unique from members of the original subpopulation.
VectorCrossoverPipeline is a BreedingPipeline which implements a simple default crossover
for VectorIndividuals.
Vector defaults is the basic defaults class for the Vector package.
VectorIndividual is the abstract superclass of simple individual representations
which consist of vectors of values (booleans, integers, floating-point, etc.)
VectorMutationPipeline is a BreedingPipeline which implements a simple default Mutation
for VectorIndividuals.
VectorSpecies is a species which can create VectorIndividuals.
Version is a static class which stores version information for this
evolutionary computation system.