| Modifier and Type | Method and Description |
|---|---|
static EvolutionState |
Evolve.initialize(ParameterDatabase parameters,
int randomSeedOffset)
Initializes an evolutionary run given the parameters and a random seed adjustment (added to each random seed).
|
static EvolutionState |
Evolve.initialize(ParameterDatabase parameters,
int randomSeedOffset,
Output output)
Initializes an evolutionary run given the parameters and a random seed adjustment (added to each random seed),
with the Output pre-constructed.
|
static EvolutionState |
Evolve.possiblyRestoreFromCheckpoint(String[] args)
Restores an EvolutionState from checkpoint if "-checkpoint FILENAME" is in the command-line arguments.
|
| Modifier and Type | Method and Description |
|---|---|
abstract Population |
Breeder.breedPopulation(EvolutionState state)
Breeds state.population, returning a new population.
|
static void |
Evolve.cleanup(EvolutionState state)
Begins a fresh evolutionary run with a given state.
|
void |
Exchanger.closeContacts(EvolutionState state,
int result)
Closes contacts with other processes, if that's what you're doing.
|
void |
Problem.closeContacts(EvolutionState state,
int result)
Called to shut down remote evaluation network contacts when the run is completed.
|
void |
Evaluator.closeContacts(EvolutionState state,
int result)
Called to shut down remote evaluation network contacts when the run is completed.
|
void |
Problem.describe(EvolutionState state,
Individual ind,
int subpopulation,
int threadnum,
int log)
Part of SimpleProblemForm.
|
void |
Problem.describe(Individual ind,
EvolutionState state,
int subpopulation,
int threadnum,
int log,
int verbosity)
Deprecated.
Use the version without verbosity
|
abstract void |
Evaluator.evaluatePopulation(EvolutionState state)
Evaluates the fitness of an entire population.
|
void |
Statistics.finalStatistics(EvolutionState state,
int result)
Called immediately after the run has completed.
|
void |
Problem.finishEvaluating(EvolutionState state,
int threadnum)
Will be called by the Evaluator after prepareToEvaluate(...) is called
and then a series of individuals are evaluated.
|
abstract void |
Finisher.finishPopulation(EvolutionState state,
int result)
Cleans up the population after the run has completed.
|
void |
SelectionMethod.finishProducing(EvolutionState s,
int subpopulation,
int thread)
A default version of finishProducing, which does nothing.
|
abstract void |
BreedingSource.finishProducing(EvolutionState s,
int subpopulation,
int thread)
Called after produce(...), usually once a generation, or maybe only
once if you're doing steady-state evolution (at the end of the run).
|
void |
BreedingPipeline.finishProducing(EvolutionState state,
int subpopulation,
int thread) |
void |
Statistics.generationBoundaryStatistics(EvolutionState state)
STEADY-STATE: called each time the generation count increments
|
void |
Exchanger.initializeContacts(EvolutionState state)
Initializes contacts with other processes, if that's what you're doing.
|
void |
Problem.initializeContacts(EvolutionState state)
Called to set up remote evaluation network contacts when the run is started.
|
void |
Evaluator.initializeContacts(EvolutionState state)
Called to set up remote evaluation network contacts when the run is started.
|
abstract Population |
Initializer.initialPopulation(EvolutionState state,
int thread)
Creates and returns a new initial population for the evolutionary run.
|
void |
Fitness.merge(EvolutionState state,
Fitness other)
Merges the other fitness into this fitness.
|
void |
Individual.merge(EvolutionState state,
Individual other)
Replaces myself with the other Individual, while merging our evaluation results together.
|
Individual |
Species.newIndividual(EvolutionState state,
DataInput dataInput)
Provides an individual read from a DataInput source, including
the fitness.
|
Individual |
Species.newIndividual(EvolutionState state,
int thread)
Provides a brand-new individual to fill in a population.
|
Individual |
Species.newIndividual(EvolutionState state,
LineNumberReader reader)
Provides an individual read from a stream, including
the fitness; the individual will
appear as it was written by printIndividual(...).
|
protected void |
Individual.parseGenotype(EvolutionState state,
LineNumberReader reader)
This method is used only by the default version of readIndividual(state,reader),
and it is intended to be overridden to parse in that part of the individual that
was outputted in the genotypeToString() method.
|
void |
Population.populate(EvolutionState state,
int thread)
Populates the population with new random individuals.
|
void |
Subpopulation.populate(EvolutionState state,
int thread) |
abstract Population |
Exchanger.postBreedingExchangePopulation(EvolutionState state)
Performs exchanges after the population has been bred but before it has been evaluated,
once every generation (or pseudogeneration).
|
void |
Statistics.postBreedingStatistics(EvolutionState state)
GENERATIONAL: Called immediately after breeding occurs.
|
void |
Statistics.postCheckpointStatistics(EvolutionState state)
Called immediately after checkpointing occurs.
|
void |
Statistics.postEvaluationStatistics(EvolutionState state)
GENERATIONAL: Called immediately after evaluation occurs.
|
void |
Statistics.postInitializationStatistics(EvolutionState state)
GENERATIONAL: Called immediately after population initialization occurs.
|
void |
Statistics.postPostBreedingExchangeStatistics(EvolutionState state)
Called immediately after the post-breeding exchange occurs.
|
void |
Statistics.postPreBreedingExchangeStatistics(EvolutionState state)
Called immediately after the pre-breeding exchange occurs.
|
abstract Population |
Exchanger.preBreedingExchangePopulation(EvolutionState state)
Performs exchanges after the population has been evaluated but before it has been bred,
once every generation (or pseudogeneration).
|
void |
Statistics.preBreedingStatistics(EvolutionState state)
GENERATIONAL: Called immediately before breeding occurs.
|
void |
Statistics.preCheckpointStatistics(EvolutionState state)
Called immediately before checkpointing occurs.
|
void |
Statistics.preEvaluationStatistics(EvolutionState state)
GENERATIONAL: Called immediately before evaluation occurs.
|
void |
Statistics.preInitializationStatistics(EvolutionState state)
Called immediately before population initialization occurs.
|
void |
Problem.prepareToEvaluate(EvolutionState state,
int threadnum)
May be called by the Evaluator prior to a series of individuals to
evaluate, and then ended with a finishEvaluating(...).
|
void |
SelectionMethod.prepareToProduce(EvolutionState s,
int subpopulation,
int thread)
A default version of prepareToProduce which does nothing.
|
abstract void |
BreedingSource.prepareToProduce(EvolutionState state,
int subpopulation,
int thread)
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.
|
void |
BreedingPipeline.prepareToProduce(EvolutionState state,
int subpopulation,
int thread) |
void |
Statistics.prePostBreedingExchangeStatistics(EvolutionState state)
Called immediately before the post-breeding exchange occurs.
|
void |
Statistics.prePreBreedingExchangeStatistics(EvolutionState state)
Called immediately before the pre-breeding exchange occurs.
|
void |
Fitness.printFitness(EvolutionState state,
int log)
Should print the fitness out in a computer-readable fashion,
with a verbosity of Output.V_NO_GENERAL.
|
void |
Fitness.printFitness(EvolutionState state,
int log,
int verbosity)
Deprecated.
Verbosity no longer has meaning
|
void |
Fitness.printFitness(EvolutionState state,
PrintWriter writer)
Should print the fitness out in a computer-readable fashion,
using writer.println(...).
|
void |
Fitness.printFitnessForHumans(EvolutionState state,
int log)
Should print the fitness out fashion pleasing for humans to read,
with a verbosity of Output.V_NO_GENERAL.
|
void |
Fitness.printFitnessForHumans(EvolutionState state,
int log,
int verbosity)
Deprecated.
Verbosity no longer has meaning
|
void |
Individual.printIndividual(EvolutionState state,
int log)
Should print the individual in a way that can be read by computer,
including its fitness, with a verbosity of Output.V_NO_GENERAL.
|
void |
Individual.printIndividual(EvolutionState state,
int log,
int verbosity)
Deprecated.
Verbosity no longer used.
|
void |
Individual.printIndividual(EvolutionState state,
PrintWriter writer)
Should print the individual in a way that can be read by computer,
including its fitness.
|
void |
Individual.printIndividualForHumans(EvolutionState state,
int log)
Should print the individual out in a pleasing way for humans,
with a verbosity of Output.V_NO_GENERAL.
|
void |
Individual.printIndividualForHumans(EvolutionState state,
int log,
int verbosity)
Deprecated.
Verbosity no longer used.
|
void |
Population.printPopulation(EvolutionState state,
int log)
Prints an entire population in a form readable by humans but also parseable by the computer using readPopulation(EvolutionState, LineNumberReader), with a verbosity of Output.V_NO_GENERAL.
|
void |
Population.printPopulation(EvolutionState state,
int log,
int verbosity)
Deprecated.
Verbosity no longer has meaning
|
void |
Population.printPopulation(EvolutionState state,
PrintWriter writer)
Prints an entire population in a form readable by humans but also parseable by the computer using readPopulation(EvolutionState, LineNumberReader).
|
void |
Population.printPopulationForHumans(EvolutionState state,
int log)
Prints an entire population in a form readable by humans, with a verbosity of Output.V_NO_GENERAL.
|
void |
Population.printPopulationForHumans(EvolutionState state,
int log,
int verbosity)
Deprecated.
Verbosity no longer has meaning
|
void |
Subpopulation.printSubpopulation(EvolutionState state,
int log)
Prints an entire subpopulation in a form readable by humans but also parseable by the computer using readSubpopulation(EvolutionState, LineNumberReader) with a verbosity of Output.V_NO_GENERAL.
|
void |
Subpopulation.printSubpopulation(EvolutionState state,
int log,
int verbosity)
Deprecated.
Verbosity no longer has meaning
|
void |
Subpopulation.printSubpopulation(EvolutionState state,
PrintWriter writer)
Prints an entire subpopulation in a form readable by humans but also parseable by the computer using readSubpopulation(EvolutionState, LineNumberReader).
|
void |
Subpopulation.printSubpopulationForHumans(EvolutionState state,
int log)
Prints an entire subpopulation in a form readable by humans, with a verbosity of Output.V_NO_GENERAL.
|
void |
Subpopulation.printSubpopulationForHumans(EvolutionState state,
int log,
int verbosity)
Deprecated.
Verbosity no longer has meaning
|
protected Individual |
Exchanger.process(EvolutionState state,
int thread,
String island,
int subpop,
Individual ind)
Typically called by preBreedingExchangePopulation prior to migrating an individual.
|
abstract int |
SelectionMethod.produce(int subpopulation,
EvolutionState state,
int thread)
An alternative form of "produce" special to Selection Methods;
selects an individual from the given subpopulation and
returns its position in that subpopulation.
|
int |
SelectionMethod.produce(int min,
int max,
int start,
int subpopulation,
Individual[] inds,
EvolutionState state,
int thread) |
abstract int |
BreedingSource.produce(int min,
int max,
int start,
int subpopulation,
Individual[] inds,
EvolutionState state,
int thread)
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.
|
boolean |
SelectionMethod.produces(EvolutionState state,
Population newpop,
int subpopulation,
int thread)
A default version of produces -- this method always returns
true under the assumption that the selection method works
with all Fitnesses.
|
abstract boolean |
BreedingSource.produces(EvolutionState state,
Population newpop,
int subpopulation,
int thread)
Returns true if this BreedingSource, when attached to the given
subpopulation, will produce individuals of the subpopulation's species.
|
boolean |
BreedingPipeline.produces(EvolutionState state,
Population newpop,
int subpopulation,
int thread) |
void |
Fitness.readFitness(EvolutionState state,
DataInput dataInput)
Reads the binary form of an individual from a DataInput.
|
void |
Fitness.readFitness(EvolutionState state,
LineNumberReader reader)
Reads in the fitness from a form outputted by fitnessToString() and thus
printFitnessForHumans(...).
|
void |
Individual.readGenotype(EvolutionState state,
DataInput dataInput)
Reads in the genotypic information from a DataInput, erasing the previous genotype
of this Individual.
|
void |
Individual.readIndividual(EvolutionState state,
DataInput dataInput)
Reads the binary form of an individual from a DataInput, erasing the previous
information stored in this Individual.
|
void |
Individual.readIndividual(EvolutionState state,
LineNumberReader reader)
Reads in the individual from a form printed by printIndividual(), erasing the previous
information stored in this Individual.
|
void |
Population.readPopulation(EvolutionState state,
DataInput dataInput)
Reads a population in binary form, from the format generated by writePopulation(...).
|
void |
Population.readPopulation(EvolutionState state,
LineNumberReader reader)
Reads a population from the format generated by printPopulation(....).
|
void |
Subpopulation.readSubpopulation(EvolutionState state,
DataInput dataInput)
Reads a subpopulation in binary form, from the format generated by writeSubpopulation(...).
|
void |
Subpopulation.readSubpopulation(EvolutionState state,
LineNumberReader reader)
Reads a subpopulation from the format generated by printSubpopulation(....).
|
void |
Fitness.readTrials(EvolutionState state,
DataInput dataInput)
Reads trials in from DataInput.
|
void |
Exchanger.reinitializeContacts(EvolutionState state)
Initializes contacts with other processes, if that's what you're doing.
|
void |
Problem.reinitializeContacts(EvolutionState state)
Called to reinitialize remote evaluation network contacts when the run is restarted from checkpoint.
|
void |
Evaluator.reinitializeContacts(EvolutionState state)
Called to reinitialize remote evaluation network contacts when the run is restarted from checkpoint.
|
int |
BreedingPipeline.reproduce(int n,
int start,
int subpopulation,
Individual[] inds,
EvolutionState state,
int thread,
boolean produceChildrenFromSource)
Performs direct cloning of n individuals.
|
abstract String |
Exchanger.runComplete(EvolutionState state)
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.
|
abstract boolean |
Evaluator.runComplete(EvolutionState state)
Returns true if an ideal individual has been found or some
other run result has shortcircuited the run so that it should
end prematurely right now.
|
void |
Fitness.setToBestOf(EvolutionState state,
Fitness[] fitnesses)
Sets the fitness to be the same value as the best of the provided fitnesses.
|
void |
Fitness.setToMeanOf(EvolutionState state,
Fitness[] fitnesses)
Sets the fitness to be the same value as the mean of the provided fitnesses.
|
void |
Fitness.setToMedianOf(EvolutionState state,
Fitness[] fitnesses)
Sets the fitness to be the median of the provided fitnesses.
|
void |
Statistics.setup(EvolutionState state,
Parameter base) |
void |
Problem.setup(EvolutionState state,
Parameter base) |
void |
EvolutionState.setup(EvolutionState state,
Parameter base)
Unlike for other setup() methods, ignore the base; it will always be null.
|
void |
BreedingSource.setup(EvolutionState state,
Parameter base)
Sets up the BreedingPipeline.
|
void |
Prototype.setup(EvolutionState state,
Parameter base)
Sets up the object by reading it from the parameters stored
in state, built off of the parameter base base.
|
void |
Evaluator.setup(EvolutionState state,
Parameter base) |
void |
Individual.setup(EvolutionState state,
Parameter base)
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.
|
void |
Population.setup(EvolutionState state,
Parameter base) |
void |
Setup.setup(EvolutionState state,
Parameter base)
Sets up the object by reading it from the parameters stored
in state, built off of the parameter base base.
|
void |
Species.setup(EvolutionState state,
Parameter base)
The default version of setup(...) loads requested pipelines and calls setup(...) on them and normalizes their probabilities.
|
void |
Subpopulation.setup(EvolutionState state,
Parameter base) |
void |
Fitness.setup(EvolutionState state,
Parameter base) |
void |
BreedingPipeline.setup(EvolutionState state,
Parameter base) |
abstract Population |
Initializer.setupPopulation(EvolutionState state,
int thread)
Loads a Population from the parameter file, sets it up, and returns it.
|
void |
Fitness.writeFitness(EvolutionState state,
DataOutput dataOutput)
Writes the binary form of an individual out to a DataOutput.
|
void |
Individual.writeGenotype(EvolutionState state,
DataOutput dataOutput)
Writes the genotypic information to a DataOutput.
|
void |
Individual.writeIndividual(EvolutionState state,
DataOutput dataOutput)
Writes the binary form of an individual out to a DataOutput.
|
void |
Population.writePopulation(EvolutionState state,
DataOutput dataOutput)
Writes a population in binary form, in a format readable by readPopulation(EvolutionState, DataInput).
|
void |
Subpopulation.writeSubpopulation(EvolutionState state,
DataOutput dataOutput)
Writes a subpopulation in binary form, in a format readable by readSubpopulation(EvolutionState, DataInput).
|
void |
Fitness.writeTrials(EvolutionState state,
DataOutput dataOutput)
Writes trials out to DataOutput
|
| Modifier and Type | Method and Description |
|---|---|
void |
Ant.describe(EvolutionState state,
Individual ind,
int subpopulation,
int threadnum,
int log) |
void |
Ant.evaluate(EvolutionState state,
Individual ind,
int subpopulation,
int threadnum) |
void |
Ant.setup(EvolutionState state,
Parameter base) |
| Modifier and Type | Method and Description |
|---|---|
void |
Left.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
Progn3.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
Move.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
IfFoodAhead.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
Right.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
Progn4.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
Progn2.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
Left.evalPrint(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem,
int[][] map2) |
void |
Progn3.evalPrint(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem,
int[][] map2) |
void |
Move.evalPrint(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem,
int[][] map2)
Just like eval, but it retraces the map and prints out info
|
void |
IfFoodAhead.evalPrint(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem,
int[][] map2) |
void |
Right.evalPrint(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem,
int[][] map2) |
void |
Progn4.evalPrint(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem,
int[][] map2) |
void |
EvalPrint.evalPrint(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem,
int[][] map2) |
void |
Progn2.evalPrint(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem,
int[][] map2) |
| Modifier and Type | Method and Description |
|---|---|
void |
BBOBenchmarks.evaluate(EvolutionState state,
Individual ind,
int subpopulation,
int threadnum) |
void |
BBOBenchmarks.setup(EvolutionState state,
Parameter base) |
| Modifier and Type | Method and Description |
|---|---|
void |
CompetitiveMaxOnes.evaluate(EvolutionState state,
Individual[] ind,
boolean[] updateFitness,
boolean countVictoriesOnly,
int[] subpops,
int threadnum) |
void |
CompetitiveMaxOnes.postprocessPopulation(EvolutionState state,
Population pop,
boolean[] updateFitness,
boolean countVictoriesOnly) |
void |
CompetitiveMaxOnes.preprocessPopulation(EvolutionState state,
Population pop,
boolean[] updateFitness,
boolean countVictoriesOnly) |
| Modifier and Type | Method and Description |
|---|---|
void |
CoevolutionaryECSuite.evaluate(EvolutionState state,
Individual[] ind,
boolean[] updateFitness,
boolean countVictoriesOnly,
int[] subpops,
int threadnum) |
void |
CoevolutionaryECSuite.postprocessPopulation(EvolutionState state,
Population pop,
boolean[] assessFitness,
boolean countVictoriesOnly) |
void |
CoevolutionaryECSuite.preprocessPopulation(EvolutionState state,
Population pop,
boolean[] prepareForAssessment,
boolean countVictoriesOnly) |
void |
CoevolutionaryECSuite.setup(EvolutionState state,
Parameter base) |
| Modifier and Type | Method and Description |
|---|---|
static double[][] |
ECSuite.buildRotationMatrix(EvolutionState state,
long rotationSeed,
int N)
Build an NxN rotation matrix[row][column] with a given seed.
|
void |
ECSuite.checkRange(EvolutionState state,
int problem,
double[] genome) |
void |
ECSuite.evaluate(EvolutionState state,
Individual ind,
int subpopulation,
int threadnum) |
double |
ECSuite.function(EvolutionState state,
int function,
double[] genome,
int threadnum) |
void |
ECSuite.setup(EvolutionState state,
Parameter base) |
| Modifier and Type | Method and Description |
|---|---|
void |
Edge.describe(EvolutionState state,
Individual ind,
int subpopulation,
int threadnum,
int log) |
String |
Edge.describeShortGeneralized(Individual ind,
EvolutionState state,
int subpopulation,
int threadnum) |
void |
Edge.evaluate(EvolutionState state,
Individual ind,
int subpopulation,
int threadnum) |
void |
Edge.fullTest(EvolutionState state,
Individual ind,
int threadnum,
boolean[][] pos,
boolean[][] neg)
Tests an individual, returning its successful positives
in totpos and its successful negatives in totneg.
|
void |
Edge.printBits(EvolutionState state,
boolean[][] bits) |
boolean[][] |
Edge.restrictToSize(int size,
boolean[][] cases,
EvolutionState state,
int thread) |
void |
Edge.setup(EvolutionState state,
Parameter base) |
| Modifier and Type | Method and Description |
|---|---|
void |
BLoop.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
Loop.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
Epsilon.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
BStart.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
Double.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
Start.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
Zero.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
BAccept.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
BBud.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
Bud.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
Accept.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
One.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
Reverse.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
Split.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
| Modifier and Type | Method and Description |
|---|---|
void |
Semantic.describe(EvolutionState state,
Individual ind,
int subpopulation,
int threadnum,
int log) |
void |
Semantic.evaluate(EvolutionState state,
Individual ind,
int subpopulation,
int threadnum) |
void |
Semantic.setup(EvolutionState state,
Parameter base) |
| Modifier and Type | Method and Description |
|---|---|
void |
SemanticNode.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
| Modifier and Type | Method and Description |
|---|---|
void |
SimpleBarChartStatistics.postEvaluationStatistics(EvolutionState state) |
void |
SimpleXYSeriesChartStatistics.postEvaluationStatistics(EvolutionState state) |
void |
SimpleBarChartStatistics.setup(EvolutionState state,
Parameter base) |
void |
SimpleXYSeriesChartStatistics.setup(EvolutionState state,
Parameter base) |
| Modifier and Type | Method and Description |
|---|---|
void |
HIFF.evaluate(EvolutionState state,
Individual ind,
int subpopulation,
int threadnum) |
void |
HIFF.setup(EvolutionState state,
Parameter base) |
| Modifier and Type | Method and Description |
|---|---|
void |
KLandscapes.evaluate(EvolutionState state,
Individual ind,
int subpopulation,
int threadnum) |
void |
KLandscapes.setup(EvolutionState state,
Parameter base) |
| Modifier and Type | Method and Description |
|---|---|
void |
KLandscapeTree.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
| Modifier and Type | Method and Description |
|---|---|
void |
Lawnmower.describe(EvolutionState state,
Individual ind,
int subpopulation,
int threadnum,
int log) |
void |
Lawnmower.evaluate(EvolutionState state,
Individual ind,
int subpopulation,
int threadnum) |
void |
Lawnmower.setup(EvolutionState state,
Parameter base) |
| Modifier and Type | Method and Description |
|---|---|
void |
Left.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
V8a.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
Frog.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
LawnERC.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
Mow.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
Progn2.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
LawnERC.readNode(EvolutionState state,
DataInput dataInput) |
void |
LawnERC.resetNode(EvolutionState state,
int thread) |
void |
LawnERC.setup(EvolutionState state,
Parameter base) |
void |
LawnERC.writeNode(EvolutionState state,
DataOutput dataOutput) |
| Modifier and Type | Method and Description |
|---|---|
void |
Lid.describe(EvolutionState state,
Individual ind,
int subpopulation,
int threadnum,
int log) |
void |
Lid.evaluate(EvolutionState state,
Individual ind,
int subpopulation,
int threadnum) |
void |
Lid.setup(EvolutionState state,
Parameter base) |
| Modifier and Type | Method and Description |
|---|---|
void |
LidX.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
LidJ.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
| Modifier and Type | Method and Description |
|---|---|
void |
MajorityGA.describe(EvolutionState state,
Individual ind,
int subpopulation,
int threadnum,
int log) |
void |
MajorityGP.describe(EvolutionState state,
Individual ind,
int subpopulation,
int threadnum,
int log) |
void |
MajorityGA.evaluate(EvolutionState state,
Individual ind,
int subpopulation,
int threadnum) |
void |
MajorityGP.evaluate(EvolutionState state,
Individual ind,
int subpopulation,
int threadnum) |
void |
MajorityGA.finishEvaluating(EvolutionState state,
int threadnum) |
void |
MajorityGP.finishEvaluating(EvolutionState state,
int threadnum) |
void |
MajorityGA.generateTrials(EvolutionState state,
int thread) |
void |
MajorityGP.generateTrials(EvolutionState state,
int thread) |
(package private) boolean |
MajorityGA.makeTrial(EvolutionState state,
int thread,
int[] trial,
int trialType) |
(package private) boolean |
MajorityGP.makeTrial(EvolutionState state,
int thread,
int[] trial,
int trialType) |
void |
MajorityGA.prepareToEvaluate(EvolutionState state,
int threadnum) |
void |
MajorityGP.prepareToEvaluate(EvolutionState state,
int threadnum) |
void |
CA.randomize(EvolutionState state,
int thread) |
void |
MajorityGA.setup(EvolutionState state,
Parameter base) |
void |
MajorityGP.setup(EvolutionState state,
Parameter base) |
| Modifier and Type | Method and Description |
|---|---|
void |
EEE.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
E.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
Nor.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
Xor.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
And.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
WW.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
EE.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
If.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
Not.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
Nand.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
X.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
Or.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
W.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
WWW.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
| Modifier and Type | Method and Description |
|---|---|
void |
Mona.describe(EvolutionState state,
Individual ind,
int threadnum,
int subpopulation,
int log) |
void |
Mona.evaluate(EvolutionState state,
Individual ind,
int subpopulation,
int threadnum) |
void |
MonaStatistics.finalStatistics(EvolutionState state,
int result)
Logs the best individual of the run.
|
void |
Mona.finishEvaluating(EvolutionState state,
int threadnum) |
void |
MonaStatistics.postEvaluationStatistics(EvolutionState state)
Logs the best individual of the generation.
|
void |
MonaVectorIndividual.reset(EvolutionState state,
int thread) |
void |
Mona.setup(EvolutionState state,
Parameter base) |
| Modifier and Type | Method and Description |
|---|---|
void |
MooSuite.evaluate(EvolutionState state,
Individual ind,
int subpopulation,
int threadnum) |
void |
MooSuite.setup(EvolutionState state,
Parameter base) |
| Modifier and Type | Method and Description |
|---|---|
void |
Multiplexer.evaluate(EvolutionState state,
Individual ind,
int subpopulation,
int threadnum) |
void |
Multiplexer.setup(EvolutionState state,
Parameter base) |
| Modifier and Type | Method and Description |
|---|---|
void |
And.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
D4.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
D1.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
D0.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
D6.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
A2.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
D7.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
If.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
D5.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
Not.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
D3.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
A1.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
A0.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
Or.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
D2.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
| Modifier and Type | Method and Description |
|---|---|
void |
Multiplexer.evaluate(EvolutionState state,
Individual ind,
int subpopulation,
int threadnum) |
void |
Multiplexer.setup(EvolutionState state,
Parameter base) |
| Modifier and Type | Method and Description |
|---|---|
void |
And.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
D4.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
D1.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
D0.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
D6.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
A2.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
D7.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
If.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
D5.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
Not.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
D3.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
A1.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
A0.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
Or.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
D2.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
| Modifier and Type | Method and Description |
|---|---|
void |
NK.evaluate(EvolutionState state,
Individual ind,
int subpopulation,
int threadnum) |
void |
NK.setup(EvolutionState state,
Parameter base) |
| Modifier and Type | Method and Description |
|---|---|
void |
OrderTree.evaluate(EvolutionState state,
Individual ind,
int subpopulation,
int threadnum) |
(package private) double |
OrderTree.fitnessContribution(double value,
EvolutionState state) |
(package private) void |
OrderTree.nodeCal(GPNode p,
EvolutionState state) |
void |
OrderTree.setup(EvolutionState state,
Parameter base) |
| Modifier and Type | Method and Description |
|---|---|
void |
OrderTreeNode.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
| Modifier and Type | Method and Description |
|---|---|
void |
Parity.evaluate(EvolutionState state,
Individual ind,
int subpopulation,
int threadnum) |
void |
Parity.setup(EvolutionState state,
Parameter base) |
| Modifier and Type | Method and Description |
|---|---|
void |
D29.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
D20.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
Nor.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
And.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
D16.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
D14.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
D24.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
D4.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
D1.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
D0.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
D12.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
D6.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
D18.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
D11.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
D28.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
D7.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
D10.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
D22.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
D5.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
D31.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
D23.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
D3.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
D17.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
D8.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
D19.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
D13.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
D30.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
D15.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
D9.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
Nand.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
D21.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
Or.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
D26.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
D25.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
D27.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
D2.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
| Modifier and Type | Method and Description |
|---|---|
void |
Regression.evaluate(EvolutionState state,
Individual ind,
int subpopulation,
int threadnum) |
void |
Regression.setup(EvolutionState state,
Parameter base) |
| Modifier and Type | Method and Description |
|---|---|
(package private) void |
Benchmarks.buildIntervalPoints(EvolutionState state,
ArrayList list,
double[] min,
double[] max,
double[] interval,
double[] current,
int variable,
int threadnum) |
void |
Benchmarks.describe(EvolutionState state,
Individual ind,
int subpopulation,
int threadnum,
int log) |
void |
Regression.evaluate(EvolutionState state,
Individual ind,
int subpopulation,
int threadnum) |
void |
Benchmarks.evaluate(EvolutionState state,
Individual ind,
int subpopulation,
int threadnum) |
double |
Benchmarks.func(EvolutionState state,
double[] xs,
int benchmark)
Return the function applied to the given data by benchmark problem.
|
double[][] |
Benchmarks.generateIntervalSpacedSamples(EvolutionState state,
double[] min,
double[] max,
double[] interval,
int threadnum)
Produce sample points evenly spaced out between min and max in each dimension, with the given spacing interval per-dimension.
|
double[][] |
Benchmarks.generateIntervalSpacedSamples(EvolutionState state,
double min,
double max,
double interval,
int threadnum)
Produce sample points evenly spaced out between min and max in one dimension, with the given spacing interval.
|
double[][] |
Benchmarks.generateRandomSamples(EvolutionState state,
double[] min,
double[] max,
int numPoints,
int threadnum)
Produce random sample points between min and max, inclusive, in each dimension.
|
double[][] |
Benchmarks.generateRandomSamples(EvolutionState state,
double min,
double max,
int numPoints,
int threadnum)
Produce random sample points between min and max, inclusive, in one dimension.
|
void |
Regression.setup(EvolutionState state,
Parameter base) |
void |
Benchmarks.setup(EvolutionState state,
Parameter base) |
double[][] |
Benchmarks.testPoints(EvolutionState state,
int benchmark,
int threadnum,
double[][] trainpoints)
Produce test sample points for a given benchmark problem, to test generalization.
|
double[][] |
Benchmarks.trainPoints(EvolutionState state,
int benchmark,
int threadnum)
Produce sample points for a given benchmark problem.
|
| Modifier and Type | Method and Description |
|---|---|
void |
Inv.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
Cos.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
X5.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
Tan.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
Add.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
VladERCB.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
VladERCC.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
X1.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
VladERCA.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
X3.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
Mul.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
RegERC.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
Sin.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
Square.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
Log.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
X2.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
Sqrt.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
X4.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
NegExp.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
Sub.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
X.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
Cube.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
Tanh.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
Exp.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
Div.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
Neg.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
RegERC.readNode(EvolutionState state,
DataInput dataInput) |
void |
KeijzerERC.resetNode(EvolutionState state,
int thread) |
void |
VladERCA.resetNode(EvolutionState state,
int thread) |
void |
RegERC.resetNode(EvolutionState state,
int thread) |
void |
KornsERC.resetNode(EvolutionState state,
int thread) |
void |
RegERC.writeNode(EvolutionState state,
DataOutput dataOutput) |
| Modifier and Type | Method and Description |
|---|---|
void |
RoyalTree.evaluate(EvolutionState state,
Individual ind,
int subpopulation,
int threadnum) |
(package private) double |
RoyalTree.fitness(GPNode node,
EvolutionState state) |
(package private) boolean |
RoyalTree.isPerfect(char parent,
GPNode node,
EvolutionState state)
Calculate whether the tree rooted at n is a perfect subtree
of the appropriate type given the current parent.
|
(package private) boolean |
RoyalTree.isSuccessor(char p,
char q,
EvolutionState state) |
| Modifier and Type | Method and Description |
|---|---|
void |
RoyalTreeNode.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
| Modifier and Type | Method and Description |
|---|---|
void |
SAT.evaluate(EvolutionState state,
Individual ind,
int subpopulation,
int threadnum)
Evalutes the individual using the MAXSAT fitness function.
|
void |
SAT.setup(EvolutionState state,
Parameter base) |
| Modifier and Type | Method and Description |
|---|---|
void |
Sum.evaluate(EvolutionState state,
Individual ind,
int subpopulation,
int threadnum) |
| Modifier and Type | Method and Description |
|---|---|
void |
MaxOnes.evaluate(EvolutionState state,
Individual ind,
int subpopulation,
int threadnum) |
| Modifier and Type | Method and Description |
|---|---|
void |
AddSubtract.evaluate(EvolutionState state,
Individual ind,
int subpopulation,
int threadnum) |
int |
OurMutatorPipeline.produce(int min,
int max,
int start,
int subpopulation,
Individual[] inds,
EvolutionState state,
int thread) |
| Modifier and Type | Method and Description |
|---|---|
void |
OddRosenbrock.evaluate(EvolutionState state,
Individual ind,
int subpopulation,
int threadnum) |
void |
MyStatistics.postEvaluationStatistics(EvolutionState state) |
int |
OurSelection.produce(int subpopulation,
EvolutionState state,
int thread) |
void |
OurSelection.setup(EvolutionState state,
Parameter base) |
void |
MyStatistics.setup(EvolutionState state,
Parameter base) |
void |
OddRosenbrock.setup(EvolutionState state,
Parameter base) |
| Modifier and Type | Method and Description |
|---|---|
void |
Add.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
Mul.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
Sub.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
X.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
Y.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
MultiValuedRegression.evaluate(EvolutionState state,
Individual ind,
int subpopulation,
int threadnum) |
void |
MultiValuedRegression.setup(EvolutionState state,
Parameter base) |
| Modifier and Type | Method and Description |
|---|---|
void |
TwoBox.evaluate(EvolutionState state,
Individual ind,
int subpopulation,
int threadnum) |
void |
TwoBox.setup(EvolutionState state,
Parameter base) |
| Modifier and Type | Method and Description |
|---|---|
void |
L1.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
W0.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
H1.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
H0.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
Add.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
L0.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
Mul.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
W1.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
Sub.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
Div.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
| Modifier and Type | Method and Description |
|---|---|
boolean |
CheckingPipeline.allValid(Individual[] inds,
int numInds,
int subpopulation,
EvolutionState state,
int thread) |
void |
BufferedBreedingPipeline.prepareToProduce(EvolutionState state,
int subpopulation,
int thread) |
int |
InitializationPipeline.produce(int min,
int max,
int start,
int subpopulation,
Individual[] inds,
EvolutionState state,
int thread) |
int |
BufferedBreedingPipeline.produce(int min,
int max,
int start,
int subpopulation,
Individual[] inds,
EvolutionState state,
int thread) |
int |
CheckingPipeline.produce(int min,
int max,
int start,
int subpopulation,
Individual[] inds,
EvolutionState state,
int thread) |
int |
ReproductionPipeline.produce(int min,
int max,
int start,
int subpopulation,
Individual[] inds,
EvolutionState state,
int thread) |
int |
GenerationSwitchPipeline.produce(int min,
int max,
int start,
int subpopulation,
Individual[] inds,
EvolutionState state,
int thread) |
int |
ForceBreedingPipeline.produce(int min,
int max,
int start,
int subpopulation,
Individual[] inds,
EvolutionState state,
int thread) |
int |
MultiBreedingPipeline.produce(int min,
int max,
int start,
int subpopulation,
Individual[] inds,
EvolutionState state,
int thread) |
void |
InitializationPipeline.setup(EvolutionState state,
Parameter base) |
void |
BufferedBreedingPipeline.setup(EvolutionState state,
Parameter base) |
void |
CheckingPipeline.setup(EvolutionState state,
Parameter base) |
void |
ReproductionPipeline.setup(EvolutionState state,
Parameter base) |
void |
GenerationSwitchPipeline.setup(EvolutionState state,
Parameter base) |
void |
ForceBreedingPipeline.setup(EvolutionState state,
Parameter base) |
void |
MultiBreedingPipeline.setup(EvolutionState state,
Parameter base) |
| Modifier and Type | Field and Description |
|---|---|
EvolutionState |
CompetitiveEvaluatorThread.state |
| Modifier and Type | Method and Description |
|---|---|
protected void |
MultiPopCoevolutionaryEvaluator.afterCoevolutionaryEvaluation(EvolutionState state,
Population population,
GroupedProblemForm prob) |
protected void |
MultiPopCoevolutionaryEvaluator.beforeCoevolutionaryEvaluation(EvolutionState state,
Population population,
GroupedProblemForm prob) |
void |
CompetitiveEvaluator.evalNRandomOneWay(EvolutionState state,
int[] from,
int[] numinds,
Individual[] individuals,
int subpop,
GroupedProblemForm prob) |
void |
CompetitiveEvaluator.evalNRandomOneWayPopChunk(EvolutionState state,
int from,
int numinds,
int threadnum,
Individual[] individuals,
int subpop,
GroupedProblemForm prob) |
void |
CompetitiveEvaluator.evalNRandomTwoWay(EvolutionState state,
int[] from,
int[] numinds,
Individual[] individuals,
int subpop,
GroupedProblemForm prob) |
void |
CompetitiveEvaluator.evalNRandomTwoWayPopChunk(EvolutionState state,
int from,
int numinds,
int threadnum,
Individual[] individuals,
int subpop,
GroupedProblemForm prob) |
void |
CompetitiveEvaluator.evalRoundRobin(EvolutionState state,
int[] from,
int[] numinds,
Individual[] individuals,
int subpop,
GroupedProblemForm prob) |
void |
CompetitiveEvaluator.evalRoundRobinPopChunk(EvolutionState state,
int from,
int numinds,
int threadnum,
Individual[] individuals,
int subpop,
GroupedProblemForm prob)
A private helper function for evalutatePopulation which evaluates a chunk
of individuals in a subpopulation for a given thread.
|
void |
CompetitiveEvaluator.evalSingleElimination(EvolutionState state,
Individual[] individuals,
int subpop,
GroupedProblemForm prob) |
void |
GroupedProblemForm.evaluate(EvolutionState state,
Individual[] ind,
boolean[] updateFitness,
boolean countVictoriesOnly,
int[] subpops,
int threadnum)
Evaluates the individuals found in ind together.
|
void |
CompetitiveEvaluator.evaluatePopulation(EvolutionState state)
An evaluator that performs coevolutionary evaluation.
|
void |
MultiPopCoevolutionaryEvaluator.evaluatePopulation(EvolutionState state) |
(package private) void |
MultiPopCoevolutionaryEvaluator.loadElites(EvolutionState state,
int whichSubpop) |
void |
MultiPopCoevolutionaryEvaluator.performCoevolutionaryEvaluation(EvolutionState state,
Population population,
GroupedProblemForm prob) |
void |
GroupedProblemForm.postprocessPopulation(EvolutionState state,
Population pop,
boolean[] assessFitness,
boolean countVictoriesOnly)
Finish processing the population (such as fitness information) after evaluation.
|
void |
GroupedProblemForm.preprocessPopulation(EvolutionState state,
Population pop,
boolean[] prepareForFitnessAssessment,
boolean countVictoriesOnly)
Set up the population pop (such as fitness information) prior to evaluation.
|
protected Individual |
MultiPopCoevolutionaryEvaluator.produceCurrent(int subpopulation,
EvolutionState state,
int thread)
Selects one individual from the given subpopulation.
|
protected Individual |
MultiPopCoevolutionaryEvaluator.producePrevious(int subpopulation,
EvolutionState state,
int thread)
Selects one individual from the previous subpopulation.
|
void |
CompetitiveEvaluator.randomizeOrder(EvolutionState state,
Individual[] individuals) |
boolean |
CompetitiveEvaluator.runComplete(EvolutionState state) |
boolean |
MultiPopCoevolutionaryEvaluator.runComplete(EvolutionState state) |
void |
CompetitiveEvaluator.setup(EvolutionState state,
Parameter base) |
void |
MultiPopCoevolutionaryEvaluator.setup(EvolutionState state,
Parameter base) |
boolean |
MultiPopCoevolutionaryEvaluator.shouldEvaluateSubpop(EvolutionState state,
int subpop,
int threadnum)
Returns true if the subpopulation should be evaluated.
|
protected void |
MultiPopCoevolutionaryEvaluator.shuffle(EvolutionState state,
int[] a) |
| Modifier and Type | Method and Description |
|---|---|
Population |
DEBreeder.breedPopulation(EvolutionState state) |
DoubleVectorIndividual |
Best1BinDEBreeder.createIndividual(EvolutionState state,
int subpop,
int index,
int thread) |
DoubleVectorIndividual |
DEBreeder.createIndividual(EvolutionState state,
int subpop,
int index,
int thread) |
DoubleVectorIndividual |
Rand1EitherOrDEBreeder.createIndividual(EvolutionState state,
int subpop,
int index,
int thread) |
DoubleVectorIndividual |
DEBreeder.crossover(EvolutionState state,
DoubleVectorIndividual target,
DoubleVectorIndividual child,
int thread)
Crosses over child with target, storing the result in child and returning it.
|
void |
DEEvaluator.evaluatePopulation(EvolutionState state) |
void |
DEBreeder.prepareDEBreeder(EvolutionState state) |
void |
Best1BinDEBreeder.setup(EvolutionState state,
Parameter base) |
void |
DEBreeder.setup(EvolutionState state,
Parameter base) |
void |
Rand1EitherOrDEBreeder.setup(EvolutionState state,
Parameter base) |
| Modifier and Type | Field and Description |
|---|---|
(package private) EvolutionState |
Console.state |
| Modifier and Type | Method and Description |
|---|---|
void |
SubpopulationPanel.setup(EvolutionState state,
Parameter base) |
void |
StatisticsChartPane.setup(EvolutionState state,
Parameter base) |
| Modifier and Type | Method and Description |
|---|---|
void |
BarChartStatistics.setup(EvolutionState state,
Parameter base) |
void |
XYSeriesChartStatistics.setup(EvolutionState state,
Parameter base) |
void |
ChartableStatistics.setup(EvolutionState state,
Parameter base) |
| Modifier and Type | Method and Description |
|---|---|
void |
SimpleIndividualPortrayal.portrayIndividual(EvolutionState state,
Individual individual) |
abstract void |
IndividualPortrayal.portrayIndividual(EvolutionState state,
Individual individual) |
void |
SimpleIndividualPortrayal.setup(EvolutionState state,
Parameter base) |
| Modifier and Type | Field and Description |
|---|---|
EvolutionState |
MuLambdaBreederThread.state |
| Modifier and Type | Method and Description |
|---|---|
void |
MuCommaLambdaBreeder.breedPopChunk(Population newpop,
EvolutionState state,
int[] numinds,
int[] from,
int threadnum)
A private helper function for breedPopulation which breeds a chunk
of individuals in a subpopulation for a given thread.
|
Population |
MuCommaLambdaBreeder.breedPopulation(EvolutionState state) |
Population |
MuCommaLambdaBreeder.postProcess(Population newpop,
Population oldpop,
EvolutionState state)
A hook for Mu+Lambda, not used in Mu,Lambda
|
Population |
MuPlusLambdaBreeder.postProcess(Population newpop,
Population oldpop,
EvolutionState state) |
void |
ESSelection.prepareToProduce(EvolutionState state,
int subpopulation,
int thread) |
int |
ESSelection.produce(int subpopulation,
EvolutionState state,
int thread) |
int |
ESSelection.produce(int min,
int max,
int start,
int subpopulation,
Individual[] inds,
EvolutionState state,
int thread) |
Population |
MuCommaLambdaBreeder.setToLambda(Population pop,
EvolutionState state)
Sets all subpopulations in pop to the expected lambda size.
|
Population |
MuPlusLambdaBreeder.setToMuPlusLambda(Population pop,
EvolutionState state)
Sets all subpopulations in pop to the expected mu+lambda size.
|
void |
MuCommaLambdaBreeder.setup(EvolutionState state,
Parameter base) |
| Modifier and Type | Field and Description |
|---|---|
EvolutionState |
SlaveMonitor.state |
(package private) EvolutionState |
SlaveConnection.state |
| Modifier and Type | Method and Description |
|---|---|
void |
MasterProblem.closeContacts(EvolutionState state,
int result)
Gracefully close contacts with the slaves
|
void |
MetaProblem.combine(EvolutionState state,
Fitness[] runs,
Fitness finalFitness)
Combines fitness results from multiple runs into a final Fitness.
|
(package private) void |
Job.copyIndividualsBack(EvolutionState state) |
void |
MetaProblem.describe(EvolutionState state,
Individual ind,
int subpopulation,
int threadnum,
int log) |
void |
MasterProblem.describe(EvolutionState state,
Individual ind,
int subpopulation,
int threadnum,
int log) |
void |
MasterProblem.evaluate(EvolutionState state,
Individual[] inds,
boolean[] updateFitness,
boolean countVictoriesOnly,
int[] subpops,
int threadnum) |
(package private) void |
MasterProblem.evaluate(EvolutionState state,
Individual[] inds,
int[] subpopulations,
int threadnum) |
void |
MetaProblem.evaluate(EvolutionState state,
Individual ind,
int subpopulation,
int threadnum) |
void |
MasterProblem.evaluate(EvolutionState state,
Individual ind,
int subpopulation,
int threadnum) |
static void |
Slave.evaluateGroupedProblemForm(EvolutionState state,
boolean returnIndividuals,
DataInputStream dataIn,
DataOutputStream dataOut) |
static void |
Slave.evaluateSimpleProblemForm(EvolutionState state,
boolean returnIndividuals,
DataInputStream dataIn,
DataOutputStream dataOut,
String[] args) |
void |
MasterProblem.finishEvaluating(EvolutionState state,
int threadnum) |
(package private) void |
MasterProblem.flush(EvolutionState state,
int threadnum) |
void |
MasterProblem.initializeContacts(EvolutionState state)
Initialize contacts with the slaves
|
protected void |
MetaProblem.loadDomain(EvolutionState state,
Parameter base) |
protected String |
MetaProblem.map(EvolutionState state,
double[] genome,
FloatVectorSpecies species,
int index) |
void |
MetaProblem.modifyParameters(EvolutionState state,
ParameterDatabase database,
int run,
Individual metaIndividual)
Override this method to revise the provided parameter database to reflect the "parameters" specified in the
given meta-individual.
|
(package private) void |
SlaveMonitor.notifySlaveAvailability(SlaveConnection slave,
Job job,
EvolutionState state)
Notifies the monitor that the particular slave has finished performing a job, and it (probably) is
available for other jobs.
|
void |
MasterProblem.postprocessPopulation(EvolutionState state,
Population pop,
boolean[] assessFitness,
boolean countVictoriesOnly) |
void |
MasterProblem.prepareToEvaluate(EvolutionState state,
int threadnum) |
void |
MasterProblem.preprocessPopulation(EvolutionState state,
Population pop,
boolean[] prepareForFitnessAssessment,
boolean countVictoriesOnly) |
void |
MasterProblem.receiveAdditionalData(EvolutionState state,
DataInputStream dataIn)
This method is called on a MasterProblem by the Slave.
|
boolean |
SlaveMonitor.registerSlave(EvolutionState state,
String name,
Socket socket,
DataOutputStream out,
DataInputStream in)
Registers a new slave with the monitor.
|
void |
MasterProblem.reinitializeContacts(EvolutionState state)
Reinitialize contacts with the slaves
|
(package private) void |
SlaveConnection.rescheduleJobs(EvolutionState state)
Reschedules the jobs in this job queue to other slaves in the system.
|
(package private) static void |
Slave.returnIndividualsToMaster(EvolutionState state,
Individual[] inds,
boolean[] updateFitness,
DataOutputStream dataOut,
boolean returnIndividuals,
int individualInQuestion) |
void |
SlaveMonitor.scheduleJobForEvaluation(EvolutionState state,
Job job)
Schedules a job for execution on one of the available slaves.
|
void |
MasterProblem.sendAdditionalData(EvolutionState state,
DataOutputStream dataOut)
This method is called from the SlaveMonitor's accept() thread to optionally send additional data to the
Slave via the dataOut stream.
|
void |
MetaProblem.setup(EvolutionState state,
Parameter base) |
void |
MasterProblem.setup(EvolutionState state,
Parameter base) |
protected void |
SlaveConnection.shutdown(EvolutionState state) |
void |
MasterProblem.transferAdditionalData(EvolutionState state)
This method is called by a Slave to transfer data previously loaded via receiveAdditionalData() to
a running EvolutionState at the beginning of evolution.
|
void |
SlaveMonitor.waitForAllSlavesToFinishEvaluating(EvolutionState state)
This method returns only when all slaves have finished the jobs that they were assigned.
|
| Constructor and Description |
|---|
SlaveConnection(EvolutionState state,
String slaveName,
Socket evalSocket,
DataOutputStream dataOut,
DataInputStream dataIn,
SlaveMonitor slaveMonitor)
The constructor also creates the queue storing the jobs that the slave
has been asked to evaluate.
|
SlaveMonitor(EvolutionState state,
boolean showDebugInfo,
MasterProblem problemPrototype)
Simple constructor that initializes the data structures for keeping track of the state of each slave.
|
| Modifier and Type | Method and Description |
|---|---|
(package private) void |
RandomRestarts.possiblyRestart(EvolutionState state) |
void |
RandomRestarts.preEvaluationStatistics(EvolutionState state)
Checks the clock; if it's time to restart, we repopulate the population.
|
(package private) void |
RandomRestarts.resetClock(EvolutionState state) |
void |
RandomRestarts.setup(EvolutionState state,
Parameter base)
Gets the clock ticking.
|
| Modifier and Type | Field and Description |
|---|---|
(package private) EvolutionState |
IslandExchangeServer.state |
(package private) EvolutionState |
IslandExchangeMailbox.state |
| Modifier and Type | Method and Description |
|---|---|
void |
InterPopulationExchange.closeContacts(EvolutionState state,
int result)
Closes contacts with other processes, if that's what you're doing.
|
void |
IslandExchange.closeContacts(EvolutionState state,
int result)
Closes contacts with other processes, if that's what you're doing.
|
void |
IslandExchange.fireUpServer(EvolutionState state,
Parameter serverBase)
Fires up the server.
|
int |
IslandExchangeServer.getIslandIndex(EvolutionState state,
String id)
Looks up the island id in the parameter database, assuming something like
exch.island.1.id = GilligansIsland
Then returns the index number (in the example before, this would be 1).
|
void |
InterPopulationExchange.initializeContacts(EvolutionState state)
Initializes contacts with other processes, if that's what you're doing.
|
void |
IslandExchange.initializeContacts(EvolutionState state)
Initializes contacts with other processes, if that's what you're doing.
|
Population |
InterPopulationExchange.postBreedingExchangePopulation(EvolutionState state) |
Population |
IslandExchange.postBreedingExchangePopulation(EvolutionState state) |
Population |
InterPopulationExchange.preBreedingExchangePopulation(EvolutionState state) |
Population |
IslandExchange.preBreedingExchangePopulation(EvolutionState state) |
void |
InterPopulationExchange.reinitializeContacts(EvolutionState state)
Initializes contacts with other processes, if that's what you're doing.
|
void |
IslandExchange.reinitializeContacts(EvolutionState state)
Initializes contacts with other processes, if that's what you're doing.
|
String |
InterPopulationExchange.runComplete(EvolutionState state)
Called after preBreedingExchangePopulation(...) to evaluate whether or not
the exchanger wishes the run to shut down (with ec.EvolutionState.R_FAILURE).
|
String |
IslandExchange.runComplete(EvolutionState state)
Called after preBreedingExchangePopulation(...) to evaluate whether or not
the exchanger wishes the run to shut down (with ec.EvolutionState.R_FAILURE).
|
void |
InterPopulationExchange.setup(EvolutionState state,
Parameter _base) |
void |
IslandExchange.setup(EvolutionState state,
Parameter _base) |
void |
IslandExchangeServer.setupServerFromDatabase(EvolutionState state_p,
Parameter base)
This setup should get called from the IslandExchange setup method.
|
| Constructor and Description |
|---|
IslandExchangeMailbox(EvolutionState state_p,
int port,
int n_incoming_p,
int how_many,
String _myId,
boolean chatty,
boolean _compressedCommunication)
Public constructor used to initialize most of the parameters of the mailbox:
state_p : the EvolutionState, used mainly for displaying messages
port : the port used to listen for incoming messages
n_incoming_p : the number of islands that will send messages to the current island
how_many : how many immigrants to manage in the queue-like storage for each of the subpopulations
|
| Modifier and Type | Method and Description |
|---|---|
void |
GPTree.buildTree(EvolutionState state,
int thread)
Builds a new randomly-generated rooted tree and attaches it to the GPTree.
|
void |
GPNode.checkConstraints(EvolutionState state,
int tree,
GPIndividual typicalIndividual,
Parameter individualBase)
You ought to override this method to check to make sure that the
constraints are valid as best you can tell.
|
void |
ADF.checkConstraints(EvolutionState state,
int tree,
GPIndividual typicalIndividual,
Parameter individualBase)
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).
|
private void |
GPTreeConstraints.checkFunctionSetValidity(EvolutionState state,
Hashtable done,
GPType type) |
static GPNodeConstraints |
GPNodeConstraints.constraintsFor(String constraintsName,
EvolutionState state)
You must guarantee that after calling constraintsFor(...) one or
several times, you call state.output.exitIfErrors() once.
|
static GPTreeConstraints |
GPTreeConstraints.constraintsFor(String constraintsName,
EvolutionState state)
You must guarantee that after calling constraintsFor(...) one or
several times, you call state.output.exitIfErrors() once.
|
protected void |
GPNodeBuilder.errorAboutNoNodeWithType(GPType type,
EvolutionState state)
Issues a fatal error that no node (nonterminal or terminal) was found with a return type of the given type, and that an algorithm
had requested one.
|
void |
ADFArgument.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
ADM.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
abstract void |
GPNode.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem)
Evaluates the node with the given thread, state, individual, problem, and stack.
|
void |
ADF.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
ADFContext.evaluate(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem,
int argument)
Evaluates the argument number in the current context
|
static GPFunctionSet |
GPFunctionSet.functionSetFor(String functionSetName,
EvolutionState state)
Returns the function set for a given name.
|
void |
ERC.mutateERC(EvolutionState state,
int thread)
Mutates the node's "value".
|
Individual |
GPSpecies.newIndividual(EvolutionState state,
DataInput dataInput) |
Individual |
GPSpecies.newIndividual(EvolutionState state,
int thread) |
Individual |
GPSpecies.newIndividual(EvolutionState state,
LineNumberReader reader) |
abstract GPNode |
GPNodeBuilder.newRootedTree(EvolutionState state,
GPType type,
int thread,
GPNodeParent parent,
GPFunctionSet set,
int argposition,
int requestedSize) |
void |
GPIndividual.parseGenotype(EvolutionState state,
LineNumberReader reader) |
GPNode |
GPNodeSelector.pickNode(EvolutionState s,
int subpopulation,
int thread,
GPIndividual ind,
GPTree tree)
Picks a node at random from tree and returns it.
|
int |
GPNodeBuilder.pickSize(EvolutionState state,
int thread)
Assuming that either minSize and maxSize, or sizeDistribution, is defined,
picks a random size from minSize...maxSize inclusive, or randomly
from sizeDistribution.
|
void |
GPIndividual.printIndividual(EvolutionState state,
int log) |
void |
GPIndividual.printIndividual(EvolutionState state,
PrintWriter writer) |
void |
GPIndividual.printIndividualForHumans(EvolutionState state,
int log) |
int |
GPNode.printNode(EvolutionState state,
int log)
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()).
|
int |
GPNode.printNode(EvolutionState state,
int log,
int verbosity)
Deprecated.
Verbosity no longer has an effect.
|
int |
GPNode.printNode(EvolutionState state,
PrintWriter writer)
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()).
|
int |
GPNode.printNodeForHumans(EvolutionState state,
int log)
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()).
|
int |
GPNode.printNodeForHumans(EvolutionState state,
int log,
int verbosity)
Deprecated.
Verbosity no longer has an effect.
|
int |
GPNode.printRootedTree(EvolutionState state,
int log,
int printbytes)
Prints out the tree on a single line, with no ending \n, in a fashion that can
be read in later by computer.
|
int |
GPNode.printRootedTree(EvolutionState state,
int log,
int verbosity,
int printbytes)
Deprecated.
Verbosity no longer has an effect.
|
int |
GPNode.printRootedTree(EvolutionState state,
PrintWriter writer,
int printbytes)
Prints out the tree on a single line, with no ending \n, in a fashion that can
be read in later by computer.
|
int |
GPNode.printRootedTreeForHumans(EvolutionState state,
int log,
int tablevel,
int printbytes)
Prints out the tree in a readable Lisp-like multi-line fashion.
|
int |
GPNode.printRootedTreeForHumans(EvolutionState state,
int log,
int verbosity,
int tablevel,
int printbytes)
Deprecated.
Verbosity no longer has an effect.
|
void |
GPTree.printTree(EvolutionState state,
int log)
Prints out the tree in single-line fashion suitable for reading
in later by computer.
|
void |
GPTree.printTree(EvolutionState state,
int log,
int verbosity)
Deprecated.
Verbosity no longer has an effect
|
void |
GPTree.printTree(EvolutionState state,
PrintWriter writer)
Prints out the tree in single-line fashion suitable for reading
in later by computer.
|
void |
GPTree.printTreeForHumans(EvolutionState state,
int log)
Prints out the tree in a readable Lisp-like fashion.
|
void |
GPTree.printTreeForHumans(EvolutionState state,
int log,
int verbosity)
Deprecated.
Verbosity no longer has an effect.
|
void |
GPIndividual.printTrees(EvolutionState state,
int log)
Prints just the trees of the GPIndividual.
|
boolean |
GPBreedingPipeline.produces(EvolutionState state,
Population newpop,
int subpopulation,
int thread)
Returns true if s is a GPSpecies.
|
void |
GPIndividual.readGenotype(EvolutionState state,
DataInput dataInput)
Overridden for the GPIndividual genotype.
|
void |
ERC.readNode(EvolutionState state,
DataInput dataInput)
To successfully read from a DataOutput, you must override this to read your specific ERC data in.
|
void |
ADFArgument.readNode(EvolutionState state,
DataInput dataInput) |
void |
GPNode.readNode(EvolutionState state,
DataInput dataInput)
Override this to read any additional node-specific information from dataInput besides: the number of arguments,
the specific node class, the children, and the parent.
|
void |
ADF.readNode(EvolutionState state,
DataInput dataInput) |
static GPNode |
GPNode.readRootedTree(EvolutionState state,
DataInput dataInput,
GPType expectedType,
GPFunctionSet set,
GPNodeParent parent,
int argposition) |
static GPNode |
GPNode.readRootedTree(int linenumber,
DecodeReturn dret,
GPType expectedType,
GPFunctionSet set,
GPNodeParent parent,
int argposition,
EvolutionState state)
Reads the node and its children from the form printed out by printRootedTree.
|
void |
GPTree.readTree(EvolutionState state,
DataInput dataInput) |
void |
GPTree.readTree(EvolutionState state,
LineNumberReader reader)
Reads in the tree from a form printed by printTree.
|
abstract void |
ERC.resetNode(EvolutionState state,
int thread)
Remember to override this to randomize your ERC after it has been cloned.
|
void |
GPNode.resetNode(EvolutionState state,
int thread)
Starts a node in a new life immediately after it has been cloned.
|
void |
GPData.setup(EvolutionState state,
Parameter base) |
void |
GPFunctionSet.setup(EvolutionState state,
Parameter base)
Must be done after GPType and GPNodeConstraints have been set up
|
void |
GPNodeConstraints.setup(EvolutionState state,
Parameter base)
This must be called after the GPTypes have been set up.
|
void |
GPNodeBuilder.setup(EvolutionState state,
Parameter base) |
void |
GPSetType.setup(EvolutionState state,
Parameter base) |
void |
ADFContext.setup(EvolutionState state,
Parameter base) |
void |
GPIndividual.setup(EvolutionState state,
Parameter base)
Sets up a prototypical GPIndividual with those features which it
shares with other GPIndividuals in its species, and nothing more.
|
void |
ADFArgument.setup(EvolutionState state,
Parameter base) |
void |
GPSpecies.setup(EvolutionState state,
Parameter base) |
void |
GPTreeConstraints.setup(EvolutionState state,
Parameter base)
This must be called after the GPTypes and GPFunctionSets
have been set up.
|
void |
ADFStack.setup(EvolutionState state,
Parameter base) |
void |
GPNode.setup(EvolutionState state,
Parameter base)
Sets up a prototypical GPNode with those features all nodes of that
prototype share, and nothing more.
|
void |
GPTree.setup(EvolutionState state,
Parameter base)
Sets up a prototypical GPTree with those features it shares with
other GPTrees in its position in its GPIndividual, and nothhing more.
|
void |
GPInitializer.setup(EvolutionState state,
Parameter base) |
void |
GPType.setup(EvolutionState state,
Parameter base) |
void |
ADF.setup(EvolutionState state,
Parameter base) |
void |
GPProblem.setup(EvolutionState state,
Parameter base) |
void |
GPInitializer.setupFunctionSets(EvolutionState state,
Parameter base) |
void |
GPInitializer.setupNodeConstraints(EvolutionState state,
Parameter base)
Sets up all the GPNodeConstraints, loading them from the parameter
file.
|
void |
GPInitializer.setupTreeConstraints(EvolutionState state,
Parameter base)
Sets up all the GPTreeConstraints, loading them from the parameter
file.
|
void |
GPInitializer.setupTypes(EvolutionState state,
Parameter base)
Sets up all the types, loading them from the parameter file.
|
static GPType |
GPType.typeFor(String typeName,
EvolutionState state)
Returns a type for a given name.
|
void |
GPIndividual.verify(EvolutionState state)
Verification of validity of the GPIndividual -- strictly for debugging purposes only
|
void |
GPTree.verify(EvolutionState state)
Verification of validity of the tree -- strictly for debugging purposes only
|
(package private) int |
GPNode.verify(EvolutionState state,
GPFunctionSet set,
int index)
Verification of validity of the node in the tree -- strictly for debugging purposes only
|
protected boolean |
GPNodeBuilder.warnAboutNonterminal(boolean test,
GPType type,
boolean fail,
EvolutionState state)
If the given test is true, issues a warning that no terminal was found with a return type of the given type, and that an algorithm
had requested one.
|
protected void |
GPNodeBuilder.warnAboutNonTerminalWithType(GPType type,
boolean fail,
EvolutionState state)
Issues a warning that no nonterminal was found with a return type of the given type, and that an algorithm
had requested one.
|
protected void |
GPNodeBuilder.warnAboutNoTerminalWithType(GPType type,
boolean fail,
EvolutionState state)
Issues a warning that no terminal was found with a return type of the given type, and that an algorithm
had requested one.
|
void |
GPIndividual.writeGenotype(EvolutionState state,
DataOutput dataOutput)
Overridden for the GPIndividual genotype.
|
void |
ERC.writeNode(EvolutionState state,
DataOutput dataOutput)
To successfully write to a DataOutput, you must override this to write your specific ERC data out.
|
void |
ADFArgument.writeNode(EvolutionState state,
DataOutput dataOutput) |
void |
GPNode.writeNode(EvolutionState state,
DataOutput dataOutput)
Override this to write any additional node-specific information to dataOutput besides: the number of arguments,
the specific node class, the children, and the parent.
|
void |
ADF.writeNode(EvolutionState state,
DataOutput dataOutput) |
void |
GPNode.writeRootedTree(EvolutionState state,
GPType expectedType,
GPFunctionSet set,
DataOutput dataOutput) |
void |
GPTree.writeTree(EvolutionState state,
DataOutput dataOutput) |
| Modifier and Type | Method and Description |
|---|---|
private void |
MutateDemotePipeline._demoteSomething(GPNode node,
EvolutionState state,
int thread,
GPFunctionSet set) |
private void |
MutateDemotePipeline._demoteSomethingTypeless(GPNode node,
EvolutionState state,
int thread,
GPFunctionSet set) |
private void |
MutateSwapPipeline._swapSomething(GPNode node,
EvolutionState state,
int thread) |
private void |
MutateSwapPipeline._swapSomethingTypeless(GPNode node,
EvolutionState state,
int thread) |
private void |
MutateDemotePipeline.demoteSomething(GPNode node,
EvolutionState state,
int thread,
GPFunctionSet set) |
protected GPNode |
SizeFairCrossoverPipeline.findFairSizeNode(ArrayList nodeToSubtrees,
HashMap sizeToNodes,
GPNode parent1SelectedNode,
GPTree tree2,
EvolutionState state,
int thread)
This method finds a node using the logic given in the langdon paper.
|
private GPNode |
MutateAllNodesPipeline.generateCompatibleTree(GPNode original,
GPFunctionSet set,
EvolutionState state,
GPType returntype,
int thread)
Returns a brand-new tree which is swap-compatible with returntype, created by making nodes "compatible" with the equivalent nodes in the tree rooted at original.
|
void |
MutateERCPipeline.mutateERCs(GPNode node,
EvolutionState state,
int thread) |
private GPNode |
MutateAllNodesPipeline.pickCompatibleNode(GPNode original,
GPFunctionSet set,
EvolutionState state,
GPType returntype,
int thread)
Returns a node which is swap-compatible with returntype, and whose arguments are swap-compatible with the current children of original.
|
private GPNode |
MutateOneNodePipeline.pickCompatibleNode(GPNode original,
GPFunctionSet set,
EvolutionState state,
GPType returntype,
int thread)
Returns a node which is swap-compatible with returntype, and whose arguments are swap-compatible with the current children of original.
|
int |
MutatePromotePipeline.produce(int min,
int max,
int start,
int subpopulation,
Individual[] inds,
EvolutionState state,
int thread) |
int |
MutateAllNodesPipeline.produce(int min,
int max,
int start,
int subpopulation,
Individual[] inds,
EvolutionState state,
int thread) |
int |
InternalCrossoverPipeline.produce(int min,
int max,
int start,
int subpopulation,
Individual[] inds,
EvolutionState state,
int thread) |
int |
MutateOneNodePipeline.produce(int min,
int max,
int start,
int subpopulation,
Individual[] inds,
EvolutionState state,
int thread) |
int |
MutateDemotePipeline.produce(int min,
int max,
int start,
int subpopulation,
Individual[] inds,
EvolutionState state,
int thread) |
int |
SizeFairCrossoverPipeline.produce(int min,
int max,
int start,
int subpopulation,
Individual[] inds,
EvolutionState state,
int thread) |
int |
RehangPipeline.produce(int min,
int max,
int start,
int subpopulation,
Individual[] inds,
EvolutionState state,
int thread) |
int |
MutateERCPipeline.produce(int min,
int max,
int start,
int subpopulation,
Individual[] inds,
EvolutionState state,
int thread) |
int |
MutateSwapPipeline.produce(int min,
int max,
int start,
int subpopulation,
Individual[] inds,
EvolutionState state,
int thread) |
private void |
RehangPipeline.rehang(EvolutionState state,
int thread,
GPNode pivot,
GPNode root) |
int |
SizeFairCrossoverPipeline.RouletteWheelSelector.roulette(EvolutionState state,
int thread) |
void |
MutatePromotePipeline.setup(EvolutionState state,
Parameter base) |
void |
MutateAllNodesPipeline.setup(EvolutionState state,
Parameter base) |
void |
InternalCrossoverPipeline.setup(EvolutionState state,
Parameter base) |
void |
MutateOneNodePipeline.setup(EvolutionState state,
Parameter base) |
void |
MutateDemotePipeline.setup(EvolutionState state,
Parameter base) |
void |
SizeFairCrossoverPipeline.setup(EvolutionState state,
Parameter base) |
void |
RehangPipeline.setup(EvolutionState state,
Parameter base) |
void |
MutateERCPipeline.setup(EvolutionState state,
Parameter base) |
void |
MutateSwapPipeline.setup(EvolutionState state,
Parameter base) |
private void |
MutateSwapPipeline.swapSomething(GPNode node,
EvolutionState state,
int thread) |
| Modifier and Type | Method and Description |
|---|---|
String |
RandTree.buildDyckWord(int requestedSize,
int[] arities,
int[] s,
EvolutionState state,
int thread) |
(package private) GPNode |
RandTree.buildTree(EvolutionState state,
int thread,
GPNodeParent parent,
int argposition,
GPFunctionSet set,
String dyckWord) |
(package private) GPNode |
Uniform.createTreeOfType(EvolutionState state,
int thread,
GPInitializer initializer,
int functionset,
int type,
int size,
MersenneTwisterFast mt) |
(package private) void |
Uniform.fillNodeWithChildren(EvolutionState state,
int thread,
GPInitializer initializer,
int functionset,
GPNode parent,
GPNode parentc,
int pickchild,
int outof,
MersenneTwisterFast mt) |
GPNode |
RandTree.newRootedTree(EvolutionState state,
GPType type,
int thread,
GPNodeParent parent,
GPFunctionSet set,
int argposition,
int requestedSize) |
GPNode |
Uniform.newRootedTree(EvolutionState state,
GPType type,
int thread,
GPNodeParent parent,
GPFunctionSet set,
int argposition,
int requestedSize) |
GPNode |
PTC1.newRootedTree(EvolutionState state,
GPType type,
int thread,
GPNodeParent parent,
GPFunctionSet set,
int argposition,
int requestedSize) |
GPNode |
RandomBranch.newRootedTree(EvolutionState state,
GPType type,
int thread,
GPNodeParent parent,
GPFunctionSet set,
int argposition,
int requestedSize) |
GPNode |
PTC2.newRootedTree(EvolutionState state,
GPType type,
int thread,
GPNodeParent parent,
GPFunctionSet set,
int argposition,
int requestedSize) |
int |
Uniform.pickSize(EvolutionState state,
int thread,
int functionset,
int type) |
void |
Uniform.preprocess(EvolutionState state,
int _maxtreesize) |
private GPNode |
PTC1.ptc1(EvolutionState state,
int current,
GPType type,
int thread,
GPNodeParent parent,
int argposition,
GPFunctionSet set,
PTCFunctionSetForm pset,
double[] nonterminalSelectionProbabilities)
A private function which recursively returns a GROW tree to newRootedTree(...)
|
private GPNode |
RandomBranch.randomBranch(EvolutionState state,
GPType type,
int maxLength,
int thread,
GPNodeParent parent,
int argposition,
GPFunctionSet set) |
private void |
PTC2.randomDequeue(EvolutionState state,
int thread) |
void |
RandTree.setup(EvolutionState state,
Parameter base) |
void |
Uniform.setup(EvolutionState state,
Parameter base) |
void |
PTC1.setup(EvolutionState state,
Parameter base) |
void |
RandomBranch.setup(EvolutionState state,
Parameter base) |
void |
PTCFunctionSet.setup(EvolutionState state,
Parameter base) |
void |
PTC2.setup(EvolutionState state,
Parameter base) |
void |
RandTree.setupArities(EvolutionState state,
GPFunctionSet set) |
| Modifier and Type | Method and Description |
|---|---|
void |
GEProblem.closeContacts(EvolutionState state,
int result) |
int |
GESpecies.consumed(EvolutionState state,
GEIndividual ind,
int threadnum)
Returns the number of elements consumed from the GEIndividual array to produce
the tree, else returns -1 if an error occurs, specifically if all elements were
consumed and the tree had still not been completed.
|
void |
GEProblem.describe(EvolutionState state,
Individual ind,
int subpopulation,
int threadnum,
int log) |
void |
GEProblem.evaluate(EvolutionState state,
Individual[] ind,
boolean[] updateFitness,
boolean countVictoriesOnly,
int[] subpops,
int threadnum)
Default version assumes that every individual is a GEIndividual.
|
void |
GEProblem.evaluate(EvolutionState state,
Individual ind,
int subpopulation,
int threadnum) |
void |
GEProblem.finishEvaluating(EvolutionState state,
int threadnum) |
List |
GESpecies.flattenSexp(EvolutionState state,
int threadnum,
GPTree tree)
Flattens an S-expression
|
List |
GESpecies.gatherNodeString(EvolutionState state,
int threadnum,
GPNode node,
int index)
Used by the above function
|
String |
GESpecies.getKeyFromNode(EvolutionState state,
int threadnum,
GPNode node,
int index) |
void |
GEProblem.initializeContacts(EvolutionState state) |
(package private) GPNode |
GESpecies.makeSubtree(int[] index,
int[] genome,
EvolutionState es,
GPFunctionSet gpfs,
GrammarRuleNode rule,
int treeNum,
int threadnum,
HashMap ercMapsForFancyPrint,
GPNodeParent parent,
byte argposition) |
int |
GESpecies.makeTree(EvolutionState state,
int[] genome,
GPTree tree,
int position,
int treeNum,
int threadnum,
HashMap ercMapsForFancyPrint)
makeTree, edits the tree that its given by adding a root (and all subtrees attached)
|
int |
GESpecies.makeTrees(EvolutionState state,
GEIndividual ind,
GPTree[] trees,
int threadnum,
HashMap ercMapsForFancyPrint)
creates all of an individual's trees
|
int |
GESpecies.makeTrees(EvolutionState state,
int[] genome,
GPTree[] trees,
int threadnum,
HashMap ercMapsForFancyPrint) |
GPIndividual |
GESpecies.map(EvolutionState state,
GEIndividual ind,
int threadnum,
HashMap ercMapsForFancyPrint)
Returns a dummy GPIndividual with a single tree which was built by mapping
over the elements of the given GEIndividual.
|
Individual |
GESpecies.newIndividual(EvolutionState state,
int thread)
This is an ugly hack to simulate the "Sensible Initialization",
First we create a GPIndividual, then reverse-map it to GEIndividuals,
We do not need to call IntegerVectorSpecies.newIndividual() since it is overriden
by the GPSpecies.newIndividual();
Moreover, as in the case for non-identical representations (i,e, GP-GE island
models etc,), the grammar rules, tree constraints, ERC's etc, are supposed to be
identical across all islands, so we are using the same "gpspecies" inside this class.
|
GPNode |
GESpecies.obtainERC(EvolutionState state,
int genomeVal,
int threadnum,
GPNode node,
HashMap ercMapsForFancyPrint)
Loads an ERC from the ERCBank given the value in the genome.
|
(package private) void |
GrammarParser.parseProductions(EvolutionState state,
GrammarRuleNode retResult,
Lexer lexer,
GPFunctionSet gpfs) |
(package private) GrammarRuleNode |
GrammarParser.parseRule(EvolutionState state,
Lexer lexer,
GPFunctionSet gpfs) |
GrammarRuleNode |
GrammarParser.parseRules(EvolutionState state,
BufferedReader reader,
GPFunctionSet gpfs)
Parses the rules from a grammar and returns the resulting GrammarRuleNode root.
|
void |
GEProblem.postprocessPopulation(EvolutionState state,
Population pop,
boolean[] assessFitness,
boolean countVictoriesOnly) |
void |
GEProblem.prepareToEvaluate(EvolutionState state,
int threadnum) |
void |
GEProblem.preprocessPopulation(EvolutionState state,
Population pop,
boolean[] prepareForFitnessAssessment,
boolean countVictoriesOnly) |
void |
GEIndividual.printIndividualForHumans(EvolutionState state,
int log) |
void |
GEProblem.reinitializeContacts(EvolutionState state) |
GEIndividual |
GESpecies.reverseMap(EvolutionState state,
GPIndividual ind,
int threadnum)
Reverse of the original map() function, takes a GPIndividual and returns
a corresponding GEIndividual; The GPIndividual may contain more than one trees,
and such cases are handled accordingly, see the 3rd bullet below --
NOTE:
This reverse mapping is only valid for S-expression trees ;
This procedure supports ERC for the current population (not for population
/subpopulation from other islands); However, that could be done by merging
all ERCBanks from all the sub-populations but that is not done yet ;
Support for the ADF's are done as follows -- suppose in one GPIndividual,
there are N trees -- T1, T2, ,,, Tn and each of them follows n different
grammars G1, G2, ,,, Gn respectively; now if they are reverse-mapped to
int arrays, there will be n int arrays A1[], A2[], ,,, An[]; and suppose
the i-th tree Ti is reverse mapped to int array Ai[] and morevoer Ai[] is
the longest among all the arrays (Bj[]s); so Bi[] is sufficient to build
all ADF trees Tjs.
|
void |
GrammarParser.setup(EvolutionState state,
Parameter base) |
void |
GEProblem.setup(EvolutionState state,
Parameter base) |
void |
GESpecies.setup(EvolutionState state,
Parameter base) |
| Modifier and Type | Method and Description |
|---|---|
Object |
GECrossoverPipeline.computeValidationData(EvolutionState state,
VectorIndividual[] parents,
int thread) |
int |
GETruncationPipeline.produce(int min,
int max,
int start,
int subpopulation,
Individual[] inds,
EvolutionState state,
int thread) |
| Modifier and Type | Method and Description |
|---|---|
protected GPNode |
KozaBuilder.fullNode(EvolutionState state,
int current,
int max,
GPType type,
int thread,
GPNodeParent parent,
int argposition,
GPFunctionSet set)
A private recursive method which builds a FULL-style tree for newRootedTree(...)
|
protected void |
KozaShortStatistics.gatherExtraSubpopStatistics(EvolutionState state,
int subpop,
int individual) |
protected GPNode |
KozaBuilder.growNode(EvolutionState state,
int current,
int max,
GPType type,
int thread,
GPNodeParent parent,
int argposition,
GPFunctionSet set)
A private function which recursively returns a GROW tree to newRootedTree(...)
|
GPNode |
HalfBuilder.newRootedTree(EvolutionState state,
GPType type,
int thread,
GPNodeParent parent,
GPFunctionSet set,
int argposition,
int requestedSize) |
GPNode |
GrowBuilder.newRootedTree(EvolutionState state,
GPType type,
int thread,
GPNodeParent parent,
GPFunctionSet set,
int argposition,
int requestedSize) |
GPNode |
FullBuilder.newRootedTree(EvolutionState state,
GPType type,
int thread,
GPNodeParent parent,
GPFunctionSet set,
int argposition,
int requestedSize) |
GPNode |
KozaNodeSelector.pickNode(EvolutionState s,
int subpopulation,
int thread,
GPIndividual ind,
GPTree tree) |
void |
KozaShortStatistics.postInitializationStatistics(EvolutionState state) |
protected void |
KozaShortStatistics.prepareStatistics(EvolutionState state) |
protected void |
KozaShortStatistics.printExtraPopStatisticsBefore(EvolutionState state) |
protected void |
KozaShortStatistics.printExtraSubpopStatisticsBefore(EvolutionState state,
int subpop) |
int |
CrossoverPipeline.produce(int min,
int max,
int start,
int subpopulation,
Individual[] inds,
EvolutionState state,
int thread) |
int |
MutationPipeline.produce(int min,
int max,
int start,
int subpopulation,
Individual[] inds,
EvolutionState state,
int thread) |
void |
KozaFitness.readFitness(EvolutionState state,
DataInput dataInput) |
void |
KozaFitness.readFitness(EvolutionState state,
LineNumberReader reader) |
void |
KozaFitness.setFitness(EvolutionState state,
double _f)
Deprecated.
|
void |
KozaFitness.setStandardizedFitness(EvolutionState state,
double _f)
Set the standardized fitness in the half-open interval [0.0,infinity)
which is defined (NOTE: DIFFERENT FROM fitness()!!!) as 0.0
being the IDEAL and infinity being worse than the worst possible.
|
void |
KozaFitness.setToMeanOf(EvolutionState state,
Fitness[] fitnesses) |
void |
CrossoverPipeline.setup(EvolutionState state,
Parameter base) |
void |
KozaNodeSelector.setup(EvolutionState state,
Parameter base) |
void |
HalfBuilder.setup(EvolutionState state,
Parameter base) |
void |
MutationPipeline.setup(EvolutionState state,
Parameter base) |
void |
KozaShortStatistics.setup(EvolutionState state,
Parameter base) |
void |
KozaBuilder.setup(EvolutionState state,
Parameter base) |
void |
KozaFitness.setup(EvolutionState state,
Parameter base) |
void |
KozaFitness.writeFitness(EvolutionState state,
DataOutput dataOutput) |
| Modifier and Type | Method and Description |
|---|---|
void |
Nonterminal.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
void |
Terminal.eval(EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem) |
Interpreter |
PushProblem.getInterpreter(EvolutionState state,
GPIndividual ind,
int threadnum)
Builds a Push Interpreter suitable for interpreting the Program given in getProgram().
|
Program |
PushProblem.getProgram(EvolutionState state,
GPIndividual ind)
Produces a Push Program from the provided GP Individual's tree.
|
GPNode |
PushBuilder.newRootedTree(EvolutionState state,
GPType type,
int thread,
GPNodeParent parent,
GPFunctionSet set,
int argposition,
int requestedSize) |
void |
Terminal.resetNode(EvolutionState state,
int thread) |
void |
PushInstruction.setup(EvolutionState state,
Parameter base) |
void |
Terminal.setup(EvolutionState state,
Parameter base) |
void |
PushBuilder.setup(EvolutionState state,
Parameter base) |
GPNode[] |
PushBuilder.shuffle(GPNode[] objs,
EvolutionState state,
int thread) |
| Modifier and Type | Method and Description |
|---|---|
void |
MultiObjectiveStatistics.finalStatistics(EvolutionState state,
int result)
Logs the best individual of the run.
|
void |
MultiObjectiveFitness.readFitness(EvolutionState state,
DataInput dataInput) |
void |
MultiObjectiveFitness.readFitness(EvolutionState state,
LineNumberReader reader) |
void |
MultiObjectiveFitness.setObjectives(EvolutionState state,
double[] newObjectives) |
void |
MultiObjectiveFitness.setToBestOf(EvolutionState state,
Fitness[] fitnesses) |
void |
MultiObjectiveFitness.setToMeanOf(EvolutionState state,
Fitness[] fitnesses) |
void |
MultiObjectiveFitness.setToMedianOf(EvolutionState state,
Fitness[] fitnesses) |
void |
MultiObjectiveFitness.setup(EvolutionState state,
Parameter base)
Sets up.
|
void |
MultiObjectiveStatistics.setup(EvolutionState state,
Parameter base) |
void |
MultiObjectiveFitness.writeFitness(EvolutionState state,
DataOutput dataOutput) |
| Modifier and Type | Method and Description |
|---|---|
Population |
NSGA2Breeder.breedPopulation(EvolutionState state)
Override breedPopulation().
|
Individual[] |
NSGA2Evaluator.buildArchive(EvolutionState state,
int subpop)
Build the auxiliary fitness data and reduce the subpopulation to just the archive, which is
returned.
|
void |
NSGA2Evaluator.evaluatePopulation(EvolutionState state)
Evaluates the population, then builds the archive and reduces the population to just the archive.
|
void |
NSGA2MultiObjectiveFitness.readFitness(EvolutionState state,
DataInput dataInput) |
void |
NSGA2MultiObjectiveFitness.readFitness(EvolutionState state,
LineNumberReader reader) |
void |
NSGA2Breeder.setup(EvolutionState state,
Parameter base) |
void |
NSGA2Evaluator.setup(EvolutionState state,
Parameter base) |
void |
NSGA2MultiObjectiveFitness.writeFitness(EvolutionState state,
DataOutput dataOutput) |
| Modifier and Type | Method and Description |
|---|---|
void |
SPEA2Breeder.buildArchive(EvolutionState state,
Individual[] oldInds,
Individual[] newInds,
int archiveSize) |
double[][] |
SPEA2Evaluator.calculateDistances(EvolutionState state,
Individual[] inds)
Returns a matrix of sum squared distances from each individual to each other individual.
|
void |
SPEA2Evaluator.computeAuxiliaryData(EvolutionState state,
Individual[] inds)
Computes the strength of individuals, then the raw fitness (wimpiness) and kth-closest sparsity
measure.
|
void |
SPEA2Evaluator.evaluatePopulation(EvolutionState state) |
int |
SPEA2TournamentSelection.getRandomIndividual(int number,
int subpopulation,
EvolutionState state,
int thread) |
protected void |
SPEA2Breeder.loadElites(EvolutionState state,
Population newpop) |
void |
SPEA2MultiObjectiveFitness.readFitness(EvolutionState state,
DataInput dataInput) |
void |
SPEA2MultiObjectiveFitness.readFitness(EvolutionState state,
LineNumberReader reader) |
void |
SPEA2Breeder.setup(EvolutionState state,
Parameter base) |
void |
SPEA2MultiObjectiveFitness.writeFitness(EvolutionState state,
DataOutput dataOutput) |
| Modifier and Type | Method and Description |
|---|---|
boolean |
LexicographicTournamentSelection.betterThan(Individual first,
Individual second,
int subpopulation,
EvolutionState state,
int thread) |
boolean |
ProportionalTournamentSelection.betterThan(Individual first,
Individual second,
int subpopulation,
EvolutionState state,
int thread) |
int |
DoubleTournamentSelection.make(int subpopulation,
EvolutionState state,
int thread)
Produces the index of a person selected from among several by a tournament.
|
void |
TarpeianStatistics.preEvaluationStatistics(EvolutionState state)
Marks a proportion (killProportion) of individuals with above-average size (within their own subpopulation) to a minimum value.
|
void |
RatioBucketTournamentSelection.prepareToProduce(EvolutionState state,
int subpopulation,
int thread)
Prepare to produce: create the buckets!!!!
|
void |
BucketTournamentSelection.prepareToProduce(EvolutionState state,
int subpopulation,
int thread)
Prepare to produce: create the buckets!!!!
|
int |
RatioBucketTournamentSelection.produce(int subpopulation,
EvolutionState state,
int thread) |
int |
BucketTournamentSelection.produce(int subpopulation,
EvolutionState state,
int thread) |
int |
DoubleTournamentSelection.produce(int subpopulation,
EvolutionState state,
int thread)
Produces the index of a person selected from among several by a tournament.
|
void |
TarpeianStatistics.setMinimumFitness(EvolutionState state,
int subpopulation,
Individual ind)
Sets the fitness of an individual to the minimum fitness possible.
|
void |
RatioBucketTournamentSelection.setup(EvolutionState state,
Parameter base) |
void |
BucketTournamentSelection.setup(EvolutionState state,
Parameter base) |
void |
DoubleTournamentSelection.setup(EvolutionState state,
Parameter base) |
void |
TarpeianStatistics.setup(EvolutionState state,
Parameter base) |
void |
ProportionalTournamentSelection.setup(EvolutionState state,
Parameter base) |
| Modifier and Type | Method and Description |
|---|---|
Population |
PSOBreeder.breedPopulation(EvolutionState state) |
(package private) int[] |
Particle.createRandomPattern(int myIndex,
boolean includeSelf,
int popsize,
int neighborhoodSize,
EvolutionState state,
int threadnum) |
void |
Particle.printIndividual(EvolutionState state,
int log) |
void |
Particle.printIndividual(EvolutionState state,
PrintWriter writer) |
void |
Particle.readIndividual(EvolutionState state,
DataInput dataInput) |
void |
Particle.readIndividual(EvolutionState state,
LineNumberReader reader) |
void |
Particle.reset(EvolutionState state,
int thread) |
void |
PSOBreeder.setup(EvolutionState state,
Parameter base) |
void |
Particle.setup(EvolutionState state,
Parameter base) |
void |
Particle.tweak(EvolutionState state,
double[] globalBest,
double velocityCoeff,
double personalCoeff,
double informantCoeff,
double globalCoeff,
int thread) |
void |
Particle.update(EvolutionState state,
int subpop,
int myindex,
int thread) |
void |
Particle.writeIndividual(EvolutionState state,
DataOutput dataOutput) |
| Modifier and Type | Method and Description |
|---|---|
void |
RuleSet.addRandomRule(EvolutionState state,
int thread)
Add a random rule to the rule set
|
static RuleSetConstraints |
RuleSetConstraints.constraintsFor(String constraintsName,
EvolutionState state)
You must guarantee that after calling constraintsFor(...) one or
several times, you call state.output.exitIfErrors() once.
|
static RuleConstraints |
RuleConstraints.constraintsFor(String constraintsName,
EvolutionState state)
You must guarantee that after calling constraintsFor(...) one or
several times, you call state.output.exitIfErrors() once.
|
void |
RuleIndividual.mutate(EvolutionState state,
int thread)
Mutates the Individual.
|
void |
Rule.mutate(EvolutionState state,
int thread)
Mutate the rule.
|
void |
RuleSet.mutate(EvolutionState state,
int thread)
Mutates rules in the RuleSet independently with the given probability.
|
Individual |
RuleSpecies.newIndividual(EvolutionState state,
int thread) |
int |
RuleSetConstraints.numRulesForReset(RuleSet ruleset,
EvolutionState state,
int thread)
Returns a stochastic value picked to specify the number of rules
to generate when calling reset() on this kind of Rule.
|
void |
RuleIndividual.parseGenotype(EvolutionState state,
LineNumberReader reader)
Overridden for the RuleIndividual genotype.
|
int |
RuleSetConstraints.pickSize(EvolutionState state,
int thread)
Assuming that either resetMinSize and resetMaxSize, or sizeDistribution, is defined,
picks a random size from resetMinSize...resetMaxSize inclusive, or randomly
from sizeDistribution.
|
void |
RuleIndividual.postprocessIndividual(EvolutionState state,
int thread)
Called by pipelines after they've modified the individual and
it might need to be "fixed" -- basically a hook for you to override.
|
void |
RuleSet.postprocessRules(EvolutionState state,
int thread)
Should be called by pipelines to "fix up" the rulesets after they have been
mutated or crossed over.
|
void |
RuleIndividual.preprocessIndividual(EvolutionState state,
int thread)
Called by pipelines before they've modified the individual and
it might need to be "fixed" -- basically a hook for you to override.
|
void |
RuleSet.preprocessRules(EvolutionState state,
int thread)
Should be called by pipelines to "fix up" the rulesets before they have been
mutated or crossed over.
|
void |
RuleIndividual.printIndividual(EvolutionState state,
int log) |
void |
RuleIndividual.printIndividual(EvolutionState state,
PrintWriter writer)
Overridden for the RuleIndividual genotype, writing each ruleset in turn.
|
void |
RuleIndividual.printIndividualForHumans(EvolutionState state,
int log) |
void |
Rule.printRule(EvolutionState state,
int log)
Prints the rule in a way that can be read by readRule().
|
void |
Rule.printRule(EvolutionState state,
int log,
int verbosity)
Deprecated.
Verbosity no longer has an effect
|
void |
Rule.printRule(EvolutionState state,
PrintWriter writer)
Prints the rule in a way that can be read by readRule().
|
void |
Rule.printRuleForHumans(EvolutionState state,
int log)
Nice printing.
|
void |
Rule.printRuleForHumans(EvolutionState state,
int log,
int verbosity)
Deprecated.
Verbosity no longer has an effect
|
void |
RuleSet.printRuleSet(EvolutionState state,
int log)
Prints the rule set such that the computer can read it later
|
void |
RuleSet.printRuleSet(EvolutionState state,
int log,
int verbosity)
Deprecated.
Verbosity no longer has an effect
|
void |
RuleSet.printRuleSet(EvolutionState state,
PrintWriter writer)
Prints the rule set such that the computer can read it later
|
void |
RuleSet.printRuleSetForHumans(EvolutionState state,
int log)
Prints out the rule set in a readable fashion.
|
void |
RuleSet.printRuleSetForHumans(EvolutionState state,
int log,
int verbosity)
Deprecated.
Verbosity no longer has an effect
|
String |
Rule.printRuleToString(EvolutionState state)
Deprecated.
|
void |
RuleSet.randomizeRulesOrder(EvolutionState state,
int thread)
Randomizes the order of the rules in the rule set.
|
void |
RuleIndividual.readGenotype(EvolutionState state,
DataInput dataInput)
Overridden for the RuleIndividual genotype.
|
void |
Rule.readRule(EvolutionState state,
DataInput dataInput)
Override this if you need to read rules in from a binary stream
|
void |
Rule.readRule(EvolutionState state,
LineNumberReader reader)
Reads a rule printed by printRule(...).
|
void |
Rule.readRuleFromString(String string,
EvolutionState state)
Reads a rule from a string, which may contain a final '\n'.
|
void |
RuleSet.readRuleSet(EvolutionState state,
DataInput dataInput)
Reads RuleSets in from a binary stream
|
void |
RuleSet.readRuleSet(EvolutionState state,
LineNumberReader reader)
Reads the rule set
|
Rule |
RuleSet.removeRandomRule(EvolutionState state,
int thread)
Removes a randomly-chosen rule from the rule set and returns it.
|
void |
RuleIndividual.reset(EvolutionState state,
int thread) |
abstract void |
Rule.reset(EvolutionState state,
int thread)
The reset method randomly reinitializes the rule.
|
void |
RuleSet.reset(EvolutionState state,
int thread)
A reset method for randomly reinitializing the RuleSet
|
void |
RuleIndividual.setup(EvolutionState state,
Parameter base) |
void |
RuleSpecies.setup(EvolutionState state,
Parameter base) |
void |
RuleSetConstraints.setup(EvolutionState state,
Parameter base) |
void |
RuleConstraints.setup(EvolutionState state,
Parameter base) |
void |
Rule.setup(EvolutionState state,
Parameter base) |
void |
RuleInitializer.setup(EvolutionState state,
Parameter base)
Sets up the RuleConstraints and RuleSetConstraints cliques.
|
void |
RuleSet.setup(EvolutionState state,
Parameter base) |
void |
RuleInitializer.setupConstraints(EvolutionState state,
Parameter base)
Sets up all the RuleConstraints, loading them from the parameter
file.
|
void |
RuleInitializer.setupRuleSetConstraints(EvolutionState state,
Parameter base) |
RuleSet[] |
RuleSet.split(EvolutionState state,
int thread,
RuleSet[] sets)
Splits the rule set into a number of disjoint rule sets, copying the rules and adding
them to the sets as appropriate.
|
RuleSet[] |
RuleSet.splitIntoTwo(EvolutionState state,
int thread,
RuleSet[] sets,
double prob)
Splits the rule set into a two disjoint rule sets, copying the rules and adding
them to the sets as appropriate.
|
void |
RuleIndividual.writeGenotype(EvolutionState state,
DataOutput dataOutput)
Overridden for the RuleIndividual genotype, writing each ruleset in turn.
|
void |
Rule.writeRule(EvolutionState state,
DataOutput dataOutput)
Override this if you need to write rules out to a binary stream
|
void |
RuleSet.writeRuleSet(EvolutionState state,
DataOutput dataOutput)
Writes RuleSets out to a binary stream
|
| Modifier and Type | Method and Description |
|---|---|
int |
RuleCrossoverPipeline.produce(int min,
int max,
int start,
int subpopulation,
Individual[] inds,
EvolutionState state,
int thread) |
int |
RuleMutationPipeline.produce(int min,
int max,
int start,
int subpopulation,
Individual[] inds,
EvolutionState state,
int thread) |
void |
RuleCrossoverPipeline.setup(EvolutionState state,
Parameter base) |
| Modifier and Type | Method and Description |
|---|---|
boolean |
TournamentSelection.betterThan(Individual first,
Individual second,
int subpopulation,
EvolutionState state,
int thread)
Returns true if *first* is a better (fitter, whatever) individual than *second*.
|
(package private) double |
BoltzmannSelection.boltzmannExpectedValue(double fitness,
EvolutionState s) |
void |
FitProportionateSelection.finishProducing(EvolutionState s,
int subpopulation,
int thread) |
void |
BestSelection.finishProducing(EvolutionState s,
int subpopulation,
int thread) |
void |
GreedyOverselection.finishProducing(EvolutionState s,
int subpopulation,
int thread) |
int |
TournamentSelection.getRandomIndividual(int number,
int subpopulation,
EvolutionState state,
int thread)
Produces the index of a (typically uniformly distributed) randomly chosen individual
to fill the tournament.
|
void |
BoltzmannSelection.prepareToProduce(EvolutionState s,
int subpopulation,
int thread) |
void |
MultiSelection.prepareToProduce(EvolutionState s,
int subpopulation,
int thread) |
void |
FitProportionateSelection.prepareToProduce(EvolutionState s,
int subpopulation,
int thread) |
void |
SUSSelection.prepareToProduce(EvolutionState s,
int subpopulation,
int thread) |
void |
BestSelection.prepareToProduce(EvolutionState s,
int subpopulation,
int thread) |
void |
GreedyOverselection.prepareToProduce(EvolutionState s,
int subpopulation,
int thread) |
void |
SigmaScalingSelection.prepareToProduce(EvolutionState s,
int subpopulation,
int thread) |
int |
MultiSelection.produce(int subpopulation,
EvolutionState state,
int thread) |
int |
RandomSelection.produce(int subpopulation,
EvolutionState state,
int thread) |
int |
FirstSelection.produce(int subpopulation,
EvolutionState state,
int thread) |
int |
FitProportionateSelection.produce(int subpopulation,
EvolutionState state,
int thread) |
int |
SUSSelection.produce(int subpopulation,
EvolutionState state,
int thread) |
int |
BestSelection.produce(int subpopulation,
EvolutionState state,
int thread) |
int |
GreedyOverselection.produce(int subpopulation,
EvolutionState state,
int thread) |
int |
TournamentSelection.produce(int subpopulation,
EvolutionState state,
int thread) |
int |
MultiSelection.produce(int min,
int max,
int start,
int subpopulation,
Individual[] inds,
EvolutionState state,
int thread) |
int |
RandomSelection.produce(int min,
int max,
int start,
int subpopulation,
Individual[] inds,
EvolutionState state,
int thread) |
int |
FirstSelection.produce(int min,
int max,
int start,
int subpopulation,
Individual[] inds,
EvolutionState state,
int thread) |
boolean |
MultiSelection.produces(EvolutionState state,
Population newpop,
int subpopulation,
int thread) |
void |
BoltzmannSelection.setup(EvolutionState state,
Parameter base) |
void |
MultiSelection.setup(EvolutionState state,
Parameter base) |
void |
SUSSelection.setup(EvolutionState state,
Parameter base) |
void |
BestSelection.setup(EvolutionState state,
Parameter base) |
void |
GreedyOverselection.setup(EvolutionState state,
Parameter base) |
void |
TournamentSelection.setup(EvolutionState state,
Parameter base) |
void |
SigmaScalingSelection.setup(EvolutionState state,
Parameter base) |
private double |
SigmaScalingSelection.sigmaScaledValue(double fitness,
double meanFitness,
double sigma,
EvolutionState s) |
| Modifier and Type | Class and Description |
|---|---|
class |
SimpleEvolutionState
A SimpleEvolutionState is an EvolutionState which implements a simple form
of generational evolution.
|
| Modifier and Type | Field and Description |
|---|---|
EvolutionState |
SimpleBreederThread.state |
EvolutionState |
SimpleEvaluator.SimpleEvaluatorThread.state |
| Modifier and Type | Method and Description |
|---|---|
protected void |
SimpleBreeder.breedPopChunk(Population newpop,
EvolutionState state,
int[] numinds,
int[] from,
int threadnum)
A private helper function for breedPopulation which breeds a chunk
of individuals in a subpopulation for a given thread.
|
Population |
SimpleBreeder.breedPopulation(EvolutionState state)
A simple breeder that doesn't attempt to do any cross-
population breeding.
|
protected void |
SimpleStatistics.bypassFinalStatistics(EvolutionState state,
int result)
Allows MultiObjectiveStatistics etc.
|
void |
SimpleExchanger.closeContacts(EvolutionState state,
int result)
Doesn't do anything.
|
(package private) int |
SimpleEvaluator.computeChunkSizeForSubpopulation(EvolutionState state,
int subpop,
int threadnum) |
int |
SimpleBreeder.computeSubpopulationLength(EvolutionState state,
Population newpop,
int subpopulation,
int threadnum)
Elites are often stored in the top part of the subpopulation; this function returns what
part of the subpopulation contains individuals to replace with newly-bred ones
(up to but not including the elites).
|
(package private) void |
SimpleEvaluator.contract(EvolutionState state) |
void |
SimpleProblemForm.describe(EvolutionState state,
Individual ind,
int subpopulation,
int threadnum,
int log)
"Reevaluates" an individual,
for the purpose of printing out
interesting facts about the individual in the context of the
Problem, and logs the results.
|
protected void |
SimpleEvaluator.evalPopChunk(EvolutionState state,
int[] numinds,
int[] from,
int threadnum,
SimpleProblemForm p)
A private helper function for evaluatePopulation which evaluates a chunk
of individuals in a subpopulation for a given thread.
|
void |
SimpleProblemForm.evaluate(EvolutionState state,
Individual ind,
int subpopulation,
int threadnum)
Evaluates the individual in ind, if necessary (perhaps
not evaluating them if their evaluated flags are true),
and sets their fitness appropriately.
|
void |
SimpleEvaluator.evaluatePopulation(EvolutionState state)
A simple evaluator that doesn't do any coevolutionary
evaluation.
|
(package private) void |
SimpleEvaluator.expand(EvolutionState state) |
void |
SimpleStatistics.finalStatistics(EvolutionState state,
int result)
Logs the best individual of the run.
|
void |
SimpleFinisher.finishPopulation(EvolutionState state,
int result)
Doesn't do anything.
|
protected void |
SimpleShortStatistics.gatherExtraPopStatistics(EvolutionState state,
int subpop) |
protected void |
SimpleShortStatistics.gatherExtraSubpopStatistics(EvolutionState state,
int subpop,
int individual) |
void |
SimpleExchanger.initializeContacts(EvolutionState state)
Doesn't do anything.
|
Population |
SimpleInitializer.initialPopulation(EvolutionState state,
int thread)
Creates, populates, and returns a new population by making a new
population, calling setup(...) on it, and calling populate(...)
on it, assuming an unthreaded environment (thread 0).
|
protected void |
SimpleBreeder.loadElites(EvolutionState state,
Population newpop)
A private helper function for breedPopulation which loads elites into
a subpopulation.
|
int |
SimpleBreeder.numElites(EvolutionState state,
int subpopulation) |
Population |
SimpleExchanger.postBreedingExchangePopulation(EvolutionState state)
Simply returns state.population.
|
void |
SimpleShortStatistics.postBreedingStatistics(EvolutionState state) |
void |
SimpleShortStatistics.postEvaluationStatistics(EvolutionState state)
Prints out the statistics, but does not end with a println --
this lets overriding methods print additional statistics on the same line
|
void |
SimpleStatistics.postEvaluationStatistics(EvolutionState state)
Logs the best individual of the generation.
|
void |
SimpleShortStatistics.postInitializationStatistics(EvolutionState state) |
void |
SimpleStatistics.postInitializationStatistics(EvolutionState state) |
Population |
SimpleExchanger.preBreedingExchangePopulation(EvolutionState state)
Simply returns state.population.
|
void |
SimpleShortStatistics.preBreedingStatistics(EvolutionState state) |
void |
SimpleShortStatistics.preEvaluationStatistics(EvolutionState state) |
void |
SimpleShortStatistics.preInitializationStatistics(EvolutionState state) |
protected void |
SimpleShortStatistics.prepareStatistics(EvolutionState state) |
protected void |
SimpleShortStatistics.printExtraPopStatisticsAfter(EvolutionState state) |
protected void |
SimpleShortStatistics.printExtraPopStatisticsBefore(EvolutionState state) |
protected void |
SimpleShortStatistics.printExtraSubpopStatisticsAfter(EvolutionState state,
int subpop) |
protected void |
SimpleShortStatistics.printExtraSubpopStatisticsBefore(EvolutionState state,
int subpop) |
void |
SimpleFitness.readFitness(EvolutionState state,
DataInput dataInput) |
void |
SimpleFitness.readFitness(EvolutionState state,
LineNumberReader reader)
Presently does not decode the fact that the fitness is ideal or not
|
void |
SimpleExchanger.reinitializeContacts(EvolutionState state)
Doesn't do anything.
|
boolean |
SimpleEvaluator.runComplete(EvolutionState state)
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.
|
String |
SimpleExchanger.runComplete(EvolutionState state)
Always returns null
|
void |
SimpleFitness.setFitness(EvolutionState state,
double _f)
Deprecated.
|
void |
SimpleFitness.setFitness(EvolutionState state,
double _f,
boolean _isIdeal) |
void |
SimpleFitness.setToMeanOf(EvolutionState state,
Fitness[] fitnesses) |
void |
SimpleShortStatistics.setup(EvolutionState state,
Parameter base) |
void |
SimpleFinisher.setup(EvolutionState state,
Parameter base) |
void |
SimpleEvaluator.setup(EvolutionState state,
Parameter base) |
void |
SimpleBreeder.setup(EvolutionState state,
Parameter base) |
void |
SimpleStatistics.setup(EvolutionState state,
Parameter base) |
void |
SimpleInitializer.setup(EvolutionState state,
Parameter base) |
void |
SimpleFitness.setup(EvolutionState state,
Parameter base) |
void |
SimpleExchanger.setup(EvolutionState state,
Parameter base) |
Population |
SimpleInitializer.setupPopulation(EvolutionState state,
int thread) |
boolean |
SimpleBreeder.shouldBreedSubpop(EvolutionState state,
int subpop,
int threadnum)
Returns true if we're doing sequential breeding and it's the subpopulation's turn (round robin,
one subpopulation per generation).
|
protected void |
SimpleBreeder.unmarkElitesEvaluated(EvolutionState state,
Population newpop) |
void |
SimpleFitness.writeFitness(EvolutionState state,
DataOutput dataOutput) |
| Modifier and Type | Method and Description |
|---|---|
protected void |
SpatialBreeder.breedPopChunk(Population newpop,
EvolutionState state,
int[] numinds,
int[] from,
int threadnum) |
int |
Spatial1DSubpopulation.getIndexRandomNeighbor(EvolutionState state,
int threadnum,
int distance)
Returns a the index of a random neighbor.
|
int |
Space.getIndexRandomNeighbor(EvolutionState state,
int threadnum,
int distance)
Input: the maximum distance for neighbors.
|
int |
SpatialTournamentSelection.getRandomIndividual(int number,
int subpopulation,
EvolutionState state,
int thread) |
protected Individual |
SpatialMultiPopCoevolutionaryEvaluator.produce(SelectionMethod method,
int subpopulation,
int individual,
EvolutionState state,
int thread) |
void |
SpatialTournamentSelection.setup(EvolutionState state,
Parameter base) |
void |
SpatialBreeder.setup(EvolutionState state,
Parameter base) |
void |
Spatial1DSubpopulation.setup(EvolutionState state,
Parameter base)
Read additional parameters for the spatially-embedded subpopulation.
|
| Modifier and Type | Class and Description |
|---|---|
class |
SteadyStateEvolutionState
This subclass of EvolutionState implements basic Steady-State Evolution and (in distributed form)
Asynchronous Evolution.
|
| Modifier and Type | Method and Description |
|---|---|
Individual |
SteadyStateBreeder.breedIndividual(EvolutionState state,
int subpop,
int thread) |
(package private) void |
SteadyStateEvolutionState.checkStatistics(EvolutionState state,
Statistics stat,
Parameter base) |
void |
SteadyStateEvaluator.evaluateIndividual(EvolutionState state,
Individual ind,
int subpop)
Submits an individual to be evaluated by the Problem, and adds it and its subpopulation to the queue.
|
void |
SteadyStateStatisticsForm.finalStatistics(EvolutionState state,
int result)
Called immediately after the run has completed.
|
void |
SteadyStateBreeder.finishPipelines(EvolutionState state) |
void |
SteadyStateStatisticsForm.generationBoundaryStatistics(EvolutionState state)
Called when the generation count increments
|
void |
SteadyStateStatisticsForm.postCheckpointStatistics(EvolutionState state)
Called immediately after checkpointing occurs.
|
void |
SteadyStateStatisticsForm.postPostBreedingExchangeStatistics(EvolutionState state)
Called immediately after the post-breeding exchange occurs.
|
void |
SteadyStateStatisticsForm.postPreBreedingExchangeStatistics(EvolutionState state)
Called immediately after the pre-breeding exchange occurs.
|
void |
SteadyStateStatisticsForm.preCheckpointStatistics(EvolutionState state)
Called immediately before checkpointing occurs.
|
void |
SteadyStateBreeder.prepareToBreed(EvolutionState state,
int thread) |
void |
SteadyStateEvaluator.prepareToEvaluate(EvolutionState state,
int thread) |
void |
SteadyStateStatisticsForm.prePostBreedingExchangeStatistics(EvolutionState state)
Called immediately before the post-breeding exchange occurs.
|
void |
SteadyStateStatisticsForm.prePreBreedingExchangeStatistics(EvolutionState state)
Called immediately before the pre-breeding exchange occurs.
|
void |
SteadyStateBreeder.setup(EvolutionState state,
Parameter base) |
void |
SteadyStateEvaluator.setup(EvolutionState state,
Parameter base) |
void |
SteadyStateEvolutionState.setup(EvolutionState state,
Parameter base) |
| Modifier and Type | Method and Description |
|---|---|
static EvolutionState |
Checkpoint.restoreFromCheckpoint(String checkpoint)
Returns an EvolutionState object read from a checkpoint file
whose filename is checkpoint
|
| Modifier and Type | Method and Description |
|---|---|
static DecodeReturn |
Code.checkPreamble(String preamble,
EvolutionState state,
LineNumberReader reader)
Finds the next nonblank line, then trims the line and checks the preamble.
|
static boolean |
Code.readBooleanWithPreamble(String preamble,
EvolutionState state,
LineNumberReader reader)
Finds the next nonblank line, skips past an expected preamble, and reads in a boolean value ("true" or "false") if there is one, and returns it.
|
static byte |
Code.readByteWithPreamble(String preamble,
EvolutionState state,
LineNumberReader reader)
Finds the next nonblank line, skips past an expected preamble, and reads in a byte if there is one, and returns it.
|
static char |
Code.readCharacterWithPreamble(String preamble,
EvolutionState state,
LineNumberReader reader)
Finds the next nonblank line, skips past an expected preamble, and reads in a character if there is one, and returns it.
|
static double |
Code.readDoubleWithPreamble(String preamble,
EvolutionState state,
LineNumberReader reader)
Finds the next nonblank line, skips past an expected preamble, and reads in a double if there is one, and returns it.
|
static float |
Code.readFloatWithPreamble(String preamble,
EvolutionState state,
LineNumberReader reader)
Finds the next nonblank line, skips past an expected preamble, and reads in a float if there is one, and returns it.
|
static int |
Code.readIntegerWithPreamble(String preamble,
EvolutionState state,
LineNumberReader reader)
Finds the next nonblank line, skips past an expected preamble, and reads in an integer if there is one, and returns it.
|
static long |
Code.readLongWithPreamble(String preamble,
EvolutionState state,
LineNumberReader reader)
Finds the next nonblank line, skips past an expected preamble, and reads in a long if there is one, and returns it.
|
static short |
Code.readShortWithPreamble(String preamble,
EvolutionState state,
LineNumberReader reader)
Finds the next nonblank line, skips past an expected preamble, and reads in a short if there is one, and returns it.
|
static String |
Code.readStringWithPreamble(String preamble,
EvolutionState state,
LineNumberReader reader)
Finds the next nonblank line, skips past an expected preamble, and reads in a string if there is one, and returns it.
|
static void |
Checkpoint.setCheckpoint(EvolutionState state)
Writes the evolution state out to a file.
|
| Modifier and Type | Method and Description |
|---|---|
void |
BitVectorIndividual.defaultCrossover(EvolutionState state,
int thread,
VectorIndividual ind) |
void |
LongVectorIndividual.defaultCrossover(EvolutionState state,
int thread,
VectorIndividual ind) |
void |
ByteVectorIndividual.defaultCrossover(EvolutionState state,
int thread,
VectorIndividual ind) |
void |
IntegerVectorIndividual.defaultCrossover(EvolutionState state,
int thread,
VectorIndividual ind) |
void |
GeneVectorIndividual.defaultCrossover(EvolutionState state,
int thread,
VectorIndividual ind) |
void |
VectorIndividual.defaultCrossover(EvolutionState state,
int thread,
VectorIndividual ind)
Destructively crosses over the individual with another in some default manner.
|
void |
ShortVectorIndividual.defaultCrossover(EvolutionState state,
int thread,
VectorIndividual ind) |
void |
FloatVectorIndividual.defaultCrossover(EvolutionState state,
int thread,
VectorIndividual ind) |
void |
DoubleVectorIndividual.defaultCrossover(EvolutionState state,
int thread,
VectorIndividual ind) |
void |
BitVectorIndividual.defaultMutate(EvolutionState state,
int thread)
Destructively mutates the individual in some default manner.
|
void |
LongVectorIndividual.defaultMutate(EvolutionState state,
int thread)
Destructively mutates the individual in some default manner.
|
void |
ByteVectorIndividual.defaultMutate(EvolutionState state,
int thread)
Destructively mutates the individual in some default manner.
|
void |
IntegerVectorIndividual.defaultMutate(EvolutionState state,
int thread)
Destructively mutates the individual in some default manner.
|
void |
GeneVectorIndividual.defaultMutate(EvolutionState state,
int thread)
Destructively mutates the individual in some default manner.
|
void |
VectorIndividual.defaultMutate(EvolutionState state,
int thread)
Destructively mutates the individual in some default manner.
|
void |
ShortVectorIndividual.defaultMutate(EvolutionState state,
int thread)
Destructively mutates the individual in some default manner.
|
void |
FloatVectorIndividual.defaultMutate(EvolutionState state,
int thread)
Destructively mutates the individual in some default manner.
|
void |
DoubleVectorIndividual.defaultMutate(EvolutionState state,
int thread)
Destructively mutates the individual in some default manner.
|
(package private) void |
FloatVectorIndividual.gaussianMutation(EvolutionState state,
MersenneTwisterFast random,
FloatVectorSpecies species,
int index) |
(package private) void |
DoubleVectorIndividual.gaussianMutation(EvolutionState state,
MersenneTwisterFast random,
FloatVectorSpecies species,
int index) |
protected void |
VectorSpecies.initializeGenomeSegmentsByEndIndices(EvolutionState state,
Parameter base,
Parameter def,
int numSegments)
Looks up genome segments using end indices.
|
protected void |
VectorSpecies.initializeGenomeSegmentsByStartIndices(EvolutionState state,
Parameter base,
Parameter def,
int numSegments)
Looks up genome segments using start indices.
|
protected void |
FloatVectorSpecies.loadParametersForGene(EvolutionState state,
int index,
Parameter base,
Parameter def,
String postfix) |
protected void |
VectorSpecies.loadParametersForGene(EvolutionState state,
int index,
Parameter base,
Parameter def,
String postfix)
Called when VectorSpecies is setting up per-gene and per-segment parameters.
|
protected void |
BitVectorSpecies.loadParametersForGene(EvolutionState state,
int index,
Parameter base,
Parameter def,
String postfix)
Called when VectorSpecies is setting up per-gene and per-segment parameters.
|
protected void |
IntegerVectorSpecies.loadParametersForGene(EvolutionState state,
int index,
Parameter base,
Parameter def,
String postfix) |
void |
Gene.mutate(EvolutionState state,
int thread)
Mutate the gene.
|
Individual |
VectorSpecies.newIndividual(EvolutionState state,
int thread) |
void |
FloatVectorSpecies.outOfRangeRetryLimitReached(EvolutionState state) |
protected void |
BitVectorIndividual.parseGenotype(EvolutionState state,
LineNumberReader reader) |
protected void |
LongVectorIndividual.parseGenotype(EvolutionState state,
LineNumberReader reader) |
protected void |
ByteVectorIndividual.parseGenotype(EvolutionState state,
LineNumberReader reader) |
protected void |
IntegerVectorIndividual.parseGenotype(EvolutionState state,
LineNumberReader reader) |
protected void |
GeneVectorIndividual.parseGenotype(EvolutionState state,
LineNumberReader reader) |
protected void |
ShortVectorIndividual.parseGenotype(EvolutionState state,
LineNumberReader reader) |
protected void |
FloatVectorIndividual.parseGenotype(EvolutionState state,
LineNumberReader reader) |
protected void |
DoubleVectorIndividual.parseGenotype(EvolutionState state,
LineNumberReader reader) |
void |
DoubleVectorIndividual.polynomialMutate(EvolutionState state,
MersenneTwisterFast random,
double eta_m,
boolean alternativePolynomialVersion,
boolean mutationIsBounded)
This function is broken out to keep it identical to NSGA-II's mutation.c code.
|
void |
FloatVectorIndividual.polynomialMutate(EvolutionState state,
MersenneTwisterFast random,
float eta_m,
boolean alternativePolynomialVersion,
boolean mutationIsBounded)
This function is broken out to keep it identical to NSGA-II's mutation.c code.
|
(package private) void |
FloatVectorIndividual.polynomialMutation(EvolutionState state,
MersenneTwisterFast random,
FloatVectorSpecies species,
int index) |
(package private) void |
DoubleVectorIndividual.polynomialMutation(EvolutionState state,
MersenneTwisterFast random,
FloatVectorSpecies species,
int index) |
void |
Gene.printGene(EvolutionState state,
int verbosity,
int log)
Prints the gene in a way that can be read by readGene().
|
void |
Gene.printGene(EvolutionState state,
PrintWriter writer)
Prints the gene in a way that can be read by readGene().
|
void |
Gene.printGeneForHumans(EvolutionState state,
int verbosity,
int log)
Nice printing.
|
void |
Gene.readGene(EvolutionState state,
DataInput dataInput)
Override this if you need to read rules in from a binary stream
|
void |
Gene.readGene(EvolutionState state,
LineNumberReader reader)
Reads a gene printed by printGene(...).
|
void |
Gene.readGeneFromString(String string,
EvolutionState state)
Reads a gene from a string, which may contain a final '\n'.
|
void |
BitVectorIndividual.readGenotype(EvolutionState state,
DataInput dataInput) |
void |
LongVectorIndividual.readGenotype(EvolutionState state,
DataInput dataInput) |
void |
ByteVectorIndividual.readGenotype(EvolutionState state,
DataInput dataInput) |
void |
IntegerVectorIndividual.readGenotype(EvolutionState state,
DataInput dataInput) |
void |
GeneVectorIndividual.readGenotype(EvolutionState state,
DataInput dataInput) |
void |
ShortVectorIndividual.readGenotype(EvolutionState state,
DataInput dataInput) |
void |
FloatVectorIndividual.readGenotype(EvolutionState state,
DataInput dataInput) |
void |
DoubleVectorIndividual.readGenotype(EvolutionState state,
DataInput dataInput) |
void |
BitVectorIndividual.reset(EvolutionState state,
int thread)
Initializes the individual by randomly flipping the bits
|
void |
LongVectorIndividual.reset(EvolutionState state,
int thread)
Initializes the individual by randomly choosing Longs uniformly from mingene to maxgene.
|
void |
ByteVectorIndividual.reset(EvolutionState state,
int thread)
Initializes the individual by randomly choosing Integers uniformly from mingene to maxgene.
|
void |
IntegerVectorIndividual.reset(EvolutionState state,
int thread)
Initializes the individual by randomly choosing Integers uniformly from mingene to maxgene.
|
abstract void |
Gene.reset(EvolutionState state,
int thread)
The reset method randomly reinitializes the gene.
|
void |
GeneVectorIndividual.reset(EvolutionState state,
int thread)
Initializes the individual by calling reset(...) on each gene.
|
abstract void |
VectorIndividual.reset(EvolutionState state,
int thread)
Initializes the individual.
|
void |
ShortVectorIndividual.reset(EvolutionState state,
int thread)
Initializes the individual by randomly choosing Integers uniformly from mingene to maxgene.
|
void |
FloatVectorIndividual.reset(EvolutionState state,
int thread)
Initializes the individual by randomly choosing floats uniformly from
mingene to maxgene.
|
void |
DoubleVectorIndividual.reset(EvolutionState state,
int thread)
Initializes the individual by randomly choosing doubles uniformly from
mingene to maxgene.
|
void |
VectorIndividual.reset(EvolutionState state,
int thread,
int newSize)
Initializes the individual to a new size.
|
void |
GeneVectorSpecies.setup(EvolutionState state,
Parameter base) |
void |
BitVectorIndividual.setup(EvolutionState state,
Parameter base) |
void |
LongVectorIndividual.setup(EvolutionState state,
Parameter base) |
void |
FloatVectorSpecies.setup(EvolutionState state,
Parameter base) |
void |
ByteVectorIndividual.setup(EvolutionState state,
Parameter base) |
void |
VectorSpecies.setup(EvolutionState state,
Parameter base) |
void |
IntegerVectorIndividual.setup(EvolutionState state,
Parameter base) |
void |
Gene.setup(EvolutionState state,
Parameter base) |
void |
GeneVectorIndividual.setup(EvolutionState state,
Parameter base) |
void |
BitVectorSpecies.setup(EvolutionState state,
Parameter base) |
void |
ShortVectorIndividual.setup(EvolutionState state,
Parameter base) |
void |
IntegerVectorSpecies.setup(EvolutionState state,
Parameter base) |
void |
FloatVectorIndividual.setup(EvolutionState state,
Parameter base) |
void |
DoubleVectorIndividual.setup(EvolutionState state,
Parameter base) |
protected void |
VectorSpecies.setupGenome(EvolutionState state,
Parameter base) |
void |
Gene.writeGene(EvolutionState state,
DataOutput dataOutput)
Override this if you need to write rules out to a binary stream
|
void |
BitVectorIndividual.writeGenotype(EvolutionState state,
DataOutput dataOutput) |
void |
LongVectorIndividual.writeGenotype(EvolutionState state,
DataOutput dataOutput) |
void |
ByteVectorIndividual.writeGenotype(EvolutionState state,
DataOutput dataOutput) |
void |
IntegerVectorIndividual.writeGenotype(EvolutionState state,
DataOutput dataOutput) |
void |
GeneVectorIndividual.writeGenotype(EvolutionState state,
DataOutput dataOutput) |
void |
ShortVectorIndividual.writeGenotype(EvolutionState state,
DataOutput dataOutput) |
void |
FloatVectorIndividual.writeGenotype(EvolutionState state,
DataOutput dataOutput) |
void |
DoubleVectorIndividual.writeGenotype(EvolutionState state,
DataOutput dataOutput) |
| Modifier and Type | Method and Description |
|---|---|
Object |
ListCrossoverPipeline.computeValidationData(EvolutionState state,
VectorIndividual[] parents,
int thread)
A hook called by ListCrossoverPipeline to allow subclasses to prepare for additional validation testing.
|
int |
MultipleVectorCrossoverPipeline.multipleBitVectorCrossover(int min,
int max,
int start,
int subpopulation,
Individual[] inds,
EvolutionState state,
int thread)
Crosses over the Bit Vector Individuals using a
uniform crossover method.
|
int |
MultipleVectorCrossoverPipeline.multipleByteVectorCrossover(int min,
int max,
int start,
int subpopulation,
Individual[] inds,
EvolutionState state,
int thread)
Crosses over the Byte Vector Individuals using a
uniform crossover method.
|
int |
MultipleVectorCrossoverPipeline.multipleDoubleVectorCrossover(int min,
int max,
int start,
int subpopulation,
Individual[] inds,
EvolutionState state,
int thread)
Crosses over the Double Vector Individuals using a
uniform crossover method.
|
int |
MultipleVectorCrossoverPipeline.multipleFloatVectorCrossover(int min,
int max,
int start,
int subpopulation,
Individual[] inds,
EvolutionState state,
int thread)
Crosses over the Float Vector Individuals using a
uniform crossover method.
|
int |
MultipleVectorCrossoverPipeline.multipleGeneVectorCrossover(int min,
int max,
int start,
int subpopulation,
Individual[] inds,
EvolutionState state,
int thread)
Crosses over the Gene Vector Individuals using a
uniform crossover method.
|
int |
MultipleVectorCrossoverPipeline.multipleIntegerVectorCrossover(int min,
int max,
int start,
int subpopulation,
Individual[] inds,
EvolutionState state,
int thread)
Crosses over the Integer Vector Individuals using a uniform crossover method.
|
int |
MultipleVectorCrossoverPipeline.multipleLongVectorCrossover(int min,
int max,
int start,
int subpopulation,
Individual[] inds,
EvolutionState state,
int thread)
Crosses over the Long Vector Individuals using a
uniform crossover method.
|
int |
MultipleVectorCrossoverPipeline.multipleShortVectorCrossover(int min,
int max,
int start,
int subpopulation,
Individual[] inds,
EvolutionState state,
int thread)
Crosses over the Short Vector Individuals using a
uniform crossover method.
|
int |
ListCrossoverPipeline.produce(int min,
int max,
int start,
int subpopulation,
Individual[] inds,
EvolutionState state,
int thread) |
int |
MultipleVectorCrossoverPipeline.produce(int min,
int max,
int start,
int subpopulation,
Individual[] inds,
EvolutionState state,
int thread) |
int |
GeneDuplicationPipeline.produce(int min,
int max,
int start,
int subpopulation,
Individual[] inds,
EvolutionState state,
int thread) |
int |
VectorCrossoverPipeline.produce(int min,
int max,
int start,
int subpopulation,
Individual[] inds,
EvolutionState state,
int thread) |
int |
VectorMutationPipeline.produce(int min,
int max,
int start,
int subpopulation,
Individual[] inds,
EvolutionState state,
int thread) |
void |
ListCrossoverPipeline.setup(EvolutionState state,
Parameter base) |
void |
MultipleVectorCrossoverPipeline.setup(EvolutionState state,
Parameter base) |
void |
VectorCrossoverPipeline.setup(EvolutionState state,
Parameter base) |
Copyright © 2014 Evolutionary Computation Laboratory at George Mason University. All rights reserved.