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.
Picks among the best n individuals in a population in
direct proportion to their absolute
fitnesses as returned by their fitness() methods relative to the
fitnesses of the other "best" individuals in that n.
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.
Checks type-compatibility constraints between the ADF, its argument terminals, and the tree type of its associated tree, and also checks to make sure the tree exists, there aren't invalid argument terminals in it, and there are sufficient argument terminals (a warning).
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.
Clones a new subtree, but with each node in oldNodes[] respectively
(which may or may not be in the subtree) replaced with
the equivalent
nodes in newNodes[] (and not clones).
Clones a new subtree, but with each node in oldNodes[] respectively
(which may or may not be in the subtree) replaced with
the equivalent
nodes in newNodes[] (and not clones of them).
constraints on the GPTree -- don't access the constraints through
this variable -- use the constraints() method instead, which will give
the actual constraints object.
"Reevaluates" a set of individuals together,
for the purpose of printing out
interesting facts about the individuals in the context of the
Problem, and logs the results.
ESEvolutionState is an EvolutionState which accepts the (mu,lambda)
and (mu+lambda) breeding strategies found in the ec.es.MuPlusLambdaBreeder
and ec.es.MuCommaLambdaBreeder breeders, to do evolution-strategies style
evolution.
This will be called to create your evolution state; immediately
after the constructor is called,
the parameters, random, and output fields will be set
for you.
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.
Searches down through databases to find a given parameter, whose value
must be a full Class name, and the class must be a descendent of but not equal
to mustCastTosuperclass.
Searches down through databases to find a given parameter, whose value must be a full Class name, and the class must be a descendent, or equal to, mustCastTosuperclass.
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 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.
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.
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.
GPNodeSelector is a Prototype which describes algorithms which
select random nodes out of trees, typically marking them for
mutation, crossover, or whatnot.
A GPTreeConstraints is a Clique which defines constraint information
common to many different GPTree trees, namely the tree type,
builder, and function set.
MuCommaLambdaBreeder is a Breeder which, together with ESEvolutionState
and 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.
MuPlusLambdaBreeder is a Breeder which, together with ESEvolutionState
and 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.
Returns the lowercase "name" of this ERC function class, some
simple, short name which distinguishes this class from other ERC
function classes you're using.
Returns true if I am the "genetically" same as this node, and our
children arrays are the same length, though
we may have different parents and children.
Returns an organized distribution (see ec.util.RandomChoice) of likelihoods
that various nonterminals in the function set will be chosen over other nonterminals
with the same return type.
Picks a random item from an array of probabilities,
normalized and summed as follows: For example,
if four probabilities are {0.3, 0.2, 0.1, 0.4}, then
they should get normalized and summed by the outside owners
as: {0.3, 0.5, 0.6, 1.0}.
Picks a random item from an array of probabilities,
normalized and summed as follows: For example,
if four probabilities are {0.3, 0.2, 0.1, 0.4}, then
they should get normalized and summed by the outside owners
as: {0.3, 0.5, 0.6, 1.0}.
Picks a random item from an array of objects, each with an
associated probability that is accessed by taking an object
and passing it to chooser.getProbability(obj).
Picks a random item from an array of objects, each with an
associated probability that is accessed by taking an object
and passing it to chooser.getProbability(obj).
Picks a random source from an array of sources, with their
probabilities normalized and summed as follows: For example,
if four
breeding source probabilities are {0.3, 0.2, 0.1, 0.4}, then
they should get normalized and summed by the outside owners
as: {0.3, 0.5, 0.6, 1.0}.
Assuming that either minSize and maxSize, or sizeDistribution, is defined,
picks a random size from minSize...maxSize inclusive, or randomly
from sizeDistribution.
Called before produce(...), usually once a generation, or maybe only
once if you're doing steady-state evolution, to let the breeding source
"warm up" prior to producing.
Should print the individual in a way that can be read by computer,
including its fitness, using state.output.println(...,verbosity,log)
You can get fitness to print itself at the appropriate time by calling
fitness.printFitness(state,log,verbosity);
Should print the individual out in a pleasing way for humans,
including its
fitness, using state.output.println(...,verbosity,log)
You can get fitness to print itself at the appropriate time by calling
fitness.printFitnessForHumans(state,log,verbosity);
Prints out a COMPUTER-readable and Lisp-like atom for the node, which
is also suitable for readNode to read, and returns
the number of bytes in the string that you sent to the log (use print(),
not println()).
Prints out a COMPUTER-readable and Lisp-like atom for the node, which
is also suitable for readNode to read, and returns
the number of bytes in the string that you sent to the log (use print(),
not println()).
Prints out a human-readable and Lisp-like atom for the node,
and returns the number of bytes in the string that you sent
to the log (use print(),
not println()).
An alternative form of "produce" special to Selection Methods;
selects an individual from the given subpopulation and
returns its position in that subpopulation.
An alternative form of "produce" special to Selection Methods;
selects an individual from the given subpopulation and
returns its position in that subpopulation.
Produces n individuals from the given subpopulation
and puts them into inds[start...start+n-1],
where n = Min(Max(q,min),max), where q is the "typical" number of
individuals the BreedingSource produces in one shot, and returns
n.
Whether or not the system should prematurely quit when Evaluator returns true for runComplete(...) (that is, when the system found an ideal individual.
Reads the node symbol,
advancing the DecodeReturn to the first character in the string
beyond the node symbol, and returns a new, empty GPNode of the
appropriate class representing that symbol, else null if the
node symbol is not of the correct type for your GPNode class.
Called after preBreedingExchangePopulation(...) to evaluate whether or not
the exchanger wishes the run to shut down (with ec.EvolutionState.R_FAILURE) --
returns a String (which will be printed out as a message) if the exchanger
wants to shut down, else returns null if the exchanger does NOT want to shut down.
The SimpleEvaluator determines that a run is complete by asking
each individual in each population if he's optimal; if he
finds an individual somewhere that's optimal,
he signals that the run is complete.
The SteadyStateEvaluator determines that a run is complete by asking
each individual if he's optimal; if he finds one that's optimal,
he signals that the run is complete.
This should be used to set up only those things which you share in common
with all other individuals in your species; individual-specific items
which make you you should be filled in by Species.newIndividual(...),
and modified by breeders.
The SimpleEvaluator is a simple, non-coevolved generational evaluator which
evaluates every single member of every subpopulation individually in its
own problem space.
Sorted population -- since I *have* to use an int-sized
individual (short gives me only 16K),
I might as well just have pointers to the
population itself.
Sorted population -- since I *have* to use an int-sized
individual (short gives me only 16K),
I might as well just have pointers to the
population itself.
Issue an error (not a fatal -- we guarantee that callers
of this method will also call exitIfErrors) if any
of your sources, or their sources, etc., are not
of SteadyStateBSourceForm.
Called to check to see if the breeding sources are correct -- if you
use this method, you must call state.output.exitIfErrors() immediately
afterwards.
A SteadyStateBreeder is an extension of SimpleBreeder which works in conjunction
with SteadyStateEvolutionState to breed individuals using a steady-state breeding
method.
The SteadyStateEvaluator is a simple, mostly single-threaded,
non-coevolved steady-state
evaluator which evaluates every single member of every subpopulation
individually.
Returns an organized distribution (see ec.util.RandomChoice) of likelihoods
that various terminals in the function set will be chosen over other terminals
with the same return type.
You might want to override this to return a special human-readable version of the erc value; otherwise this defaults to toString(); This should be something that resembles a LISP atom.
Returns the "typical" number of individuals
generated with one call of produce(...) -- by default this is
set to 1; you should override this if 1 is not appropriate.