public TerminationOperator()
: base() {
Parameters.Add(new LookupParameter<ITerminator>("Terminator", "The termination criteria which sould be checked."));
Parameters.Add(new LookupParameter<BoolValue>("Terminate", "The parameter which will be set to determine if execution should be terminated or schould continue."));
Parameters.Add(new OperatorParameter("ContinueBranch", "The operator which is executed if no termination criteria has met."));
Parameters.Add(new OperatorParameter("TerminateBranch", "The operator which is executed if any termination criteria has met."));
var assigner = new Assigner() { Name = "Terminate = false" };
assigner.LeftSideParameter.ActualName = TerminateParameter.Name;
assigner.RightSideParameter.Value = new BoolValue(false);
var placeholder = new Placeholder() { Name = "Check termination criteria (Placeholder)" };
placeholder.OperatorParameter.ActualName = TerminatorParameter.Name;
BeforeExecutionOperators.Add(assigner);
BeforeExecutionOperators.Add(placeholder);
}
public RealVectorParticleCreator()
: base() {
Parameters.Add(new LookupParameter<IntValue>("ProblemSize", "The dimension of the problem."));
Parameters.Add(new ValueLookupParameter<DoubleMatrix>("Bounds", "The lower and upper bounds in each dimension."));
Parameters.Add(new LookupParameter<RealVector>("RealVector", "Particle's current solution"));
Parameters.Add(new LookupParameter<RealVector>("PersonalBest", "Particle's personal best solution."));
Parameters.Add(new LookupParameter<RealVector>("Velocity", "Particle's current velocity."));
UniformRandomRealVectorCreator realVectorCreater = new UniformRandomRealVectorCreator();
Assigner personalBestPositionAssigner = new Assigner();
OperatorGraph.InitialOperator = realVectorCreater;
realVectorCreater.RealVectorParameter.ActualName = RealVectorParameter.Name;
realVectorCreater.LengthParameter.ActualName = ProblemSizeParameter.Name;
realVectorCreater.BoundsParameter.ActualName = BoundsParameter.Name;
realVectorCreater.Successor = personalBestPositionAssigner;
personalBestPositionAssigner.LeftSideParameter.ActualName = PersonalBestParameter.Name;
personalBestPositionAssigner.RightSideParameter.ActualName = RealVectorParameter.Name;
personalBestPositionAssigner.Successor = null;
}
public ParticleSwarmOptimization()
: base() {
Parameters.Add(new ValueParameter<IntValue>("Seed", "The random seed used to initialize the new pseudo random number generator.", new IntValue(0)));
Parameters.Add(new ValueParameter<BoolValue>("SetSeedRandomly", "True if the random seed should be set to a random value, otherwise false.", new BoolValue(true)));
Parameters.Add(new ValueParameter<IntValue>("SwarmSize", "Size of the particle swarm.", new IntValue(10)));
Parameters.Add(new ValueParameter<IntValue>("MaxIterations", "Maximal number of iterations.", new IntValue(1000)));
Parameters.Add(new ValueParameter<MultiAnalyzer>("Analyzer", "The operator used to analyze each generation.", new MultiAnalyzer()));
Parameters.Add(new ValueParameter<DoubleValue>("Inertia", "Inertia weight on a particle's movement (omega).", new DoubleValue(1)));
Parameters.Add(new ValueParameter<DoubleValue>("PersonalBestAttraction", "Weight for particle's pull towards its personal best soution (phi_p).", new DoubleValue(-0.01)));
Parameters.Add(new ValueParameter<DoubleValue>("NeighborBestAttraction", "Weight for pull towards the neighborhood best solution or global best solution in case of a totally connected topology (phi_g).", new DoubleValue(3.7)));
Parameters.Add(new ConstrainedValueParameter<IParticleCreator>("ParticleCreator", "Operator that creates a new particle."));
Parameters.Add(new ConstrainedValueParameter<IParticleUpdater>("ParticleUpdater", "Operator that updates a particle."));
Parameters.Add(new OptionalConstrainedValueParameter<ITopologyInitializer>("TopologyInitializer", "Creates neighborhood description vectors."));
Parameters.Add(new OptionalConstrainedValueParameter<ITopologyUpdater>("TopologyUpdater", "Updates the neighborhood description vectors."));
Parameters.Add(new OptionalConstrainedValueParameter<IDiscreteDoubleValueModifier>("InertiaUpdater", "Updates the omega parameter."));
Parameters.Add(new ConstrainedValueParameter<ISwarmUpdater>("SwarmUpdater", "Encoding-specific parameter which is provided by the problem. May provide additional encoding-specific parameters, such as velocity bounds for real valued problems"));
ParticleUpdaterParameter.Hidden = true;
RandomCreator randomCreator = new RandomCreator();
VariableCreator variableCreator = new VariableCreator();
Assigner currentInertiaAssigner = new Assigner();
solutionsCreator = new SolutionsCreator();
SubScopesCounter subScopesCounter = new SubScopesCounter();
Placeholder topologyInitializerPlaceholder = new Placeholder();
mainLoop = new ParticleSwarmOptimizationMainLoop();
OperatorGraph.InitialOperator = randomCreator;
randomCreator.SetSeedRandomlyParameter.Value = null;
randomCreator.SeedParameter.Value = null;
randomCreator.Successor = variableCreator;
variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("Iterations", new IntValue(0)));
variableCreator.Successor = currentInertiaAssigner;
currentInertiaAssigner.Name = "CurrentInertia := Inertia";
currentInertiaAssigner.LeftSideParameter.ActualName = "CurrentInertia";
currentInertiaAssigner.RightSideParameter.ActualName = "Inertia";
currentInertiaAssigner.Successor = solutionsCreator;
solutionsCreator.NumberOfSolutionsParameter.ActualName = "SwarmSize";
ParameterizeSolutionsCreator();
solutionsCreator.Successor = subScopesCounter;
subScopesCounter.Name = "Initialize EvaluatedSolutions";
subScopesCounter.ValueParameter.ActualName = "EvaluatedSolutions";
subScopesCounter.Successor = topologyInitializerPlaceholder;
topologyInitializerPlaceholder.Name = "(TopologyInitializer)";
topologyInitializerPlaceholder.OperatorParameter.ActualName = "TopologyInitializer";
topologyInitializerPlaceholder.Successor = mainLoop;
mainLoop.AnalyzerParameter.ActualName = AnalyzerParameter.Name;
mainLoop.InertiaParameter.ActualName = "CurrentInertia";
mainLoop.MaxIterationsParameter.ActualName = MaxIterationsParameter.Name;
mainLoop.NeighborBestAttractionParameter.ActualName = NeighborBestAttractionParameter.Name;
mainLoop.InertiaUpdaterParameter.ActualName = InertiaUpdaterParameter.Name;
mainLoop.ParticleUpdaterParameter.ActualName = ParticleUpdaterParameter.Name;
mainLoop.PersonalBestAttractionParameter.ActualName = PersonalBestAttractionParameter.Name;
mainLoop.RandomParameter.ActualName = randomCreator.RandomParameter.ActualName;
mainLoop.SwarmSizeParameter.ActualName = SwarmSizeParameter.Name;
mainLoop.TopologyUpdaterParameter.ActualName = TopologyUpdaterParameter.Name;
mainLoop.RandomParameter.ActualName = randomCreator.RandomParameter.ActualName;
mainLoop.ResultsParameter.ActualName = "Results";
InitializeAnalyzers();
InitializeParticleCreator();
InitializeSwarmUpdater();
ParameterizeSolutionsCreator();
UpdateAnalyzers();
UpdateInertiaUpdater();
InitInertiaUpdater();
UpdateTopologyInitializer();
Initialize();
ParameterizeMainLoop();
}
public AlpsGeneticAlgorithm()
: base() {
#region Add parameters
Parameters.Add(new ValueParameter<IntValue>("Seed", "The random seed used to initialize the new pseudo random number generator.", new IntValue(0)));
Parameters.Add(new ValueParameter<BoolValue>("SetSeedRandomly", "True if the random seed should be set to a random value, otherwise false.", new BoolValue(true)));
Parameters.Add(new FixedValueParameter<MultiAnalyzer>("Analyzer", "The operator used to analyze all individuals from all layers combined.", new MultiAnalyzer()));
Parameters.Add(new FixedValueParameter<MultiAnalyzer>("LayerAnalyzer", "The operator used to analyze each layer.", new MultiAnalyzer()));
Parameters.Add(new ValueParameter<IntValue>("NumberOfLayers", "The number of layers.", new IntValue(10)));
Parameters.Add(new ValueParameter<IntValue>("PopulationSize", "The size of the population of solutions in each layer.", new IntValue(100)));
Parameters.Add(new ConstrainedValueParameter<ISelector>("Selector", "The operator used to select solutions for reproduction."));
Parameters.Add(new ConstrainedValueParameter<ICrossover>("Crossover", "The operator used to cross solutions."));
Parameters.Add(new OptionalConstrainedValueParameter<IManipulator>("Mutator", "The operator used to mutate solutions."));
Parameters.Add(new ValueParameter<PercentValue>("MutationProbability", "The probability that the mutation operator is applied on a solution.", new PercentValue(0.05)));
Parameters.Add(new ValueParameter<IntValue>("Elites", "The numer of elite solutions which are kept in each generation.", new IntValue(1)));
Parameters.Add(new FixedValueParameter<BoolValue>("ReevaluateElites", "Flag to determine if elite individuals should be reevaluated (i.e., if stochastic fitness functions are used.)", new BoolValue(false)) { Hidden = true });
Parameters.Add(new ValueParameter<BoolValue>("PlusSelection", "Include the parents in the selection of the invividuals for the next generation.", new BoolValue(false)));
Parameters.Add(new ValueParameter<EnumValue<AgingScheme>>("AgingScheme", "The aging scheme for setting the age-limits for the layers.", new EnumValue<AgingScheme>(ALPS.AgingScheme.Polynomial)));
Parameters.Add(new ValueParameter<IntValue>("AgeGap", "The frequency of reseeding the lowest layer and scaling factor for the age-limits for the layers.", new IntValue(20)));
Parameters.Add(new ValueParameter<DoubleValue>("AgeInheritance", "A weight that determines the age of a child after crossover based on the older (1.0) and younger (0.0) parent.", new DoubleValue(1.0)) { Hidden = true });
Parameters.Add(new ValueParameter<IntArray>("AgeLimits", "The maximum age an individual is allowed to reach in a certain layer.", new IntArray(new int[0])) { Hidden = true });
Parameters.Add(new ValueParameter<IntValue>("MatingPoolRange", "The range of layers used for creating a mating pool. (1 = current + previous layer)", new IntValue(1)) { Hidden = true });
Parameters.Add(new ValueParameter<BoolValue>("ReduceToPopulationSize", "Reduce the CurrentPopulationSize after elder migration to PopulationSize", new BoolValue(true)) { Hidden = true });
Parameters.Add(new ValueParameter<MultiTerminator>("Terminator", "The termination criteria that defines if the algorithm should continue or stop.", new MultiTerminator()));
#endregion
#region Create operators
var globalRandomCreator = new RandomCreator();
var layer0Creator = new SubScopesCreator() { Name = "Create Layer Zero" };
var layer0Processor = new SubScopesProcessor();
var localRandomCreator = new LocalRandomCreator();
var layerSolutionsCreator = new SolutionsCreator();
var initializeAgeProcessor = new UniformSubScopesProcessor();
var initializeAge = new VariableCreator() { Name = "Initialize Age" };
var initializeCurrentPopulationSize = new SubScopesCounter() { Name = "Initialize CurrentPopulationCounter" };
var initializeLocalEvaluatedSolutions = new Assigner() { Name = "Initialize LayerEvaluatedSolutions" };
var initializeGlobalEvaluatedSolutions = new DataReducer() { Name = "Initialize EvaluatedSolutions" };
var resultsCollector = new ResultsCollector();
var mainLoop = new AlpsGeneticAlgorithmMainLoop();
#endregion
#region Create and parameterize operator graph
OperatorGraph.InitialOperator = globalRandomCreator;
globalRandomCreator.RandomParameter.ActualName = "GlobalRandom";
globalRandomCreator.SeedParameter.Value = null;
globalRandomCreator.SeedParameter.ActualName = SeedParameter.Name;
globalRandomCreator.SetSeedRandomlyParameter.Value = null;
globalRandomCreator.SetSeedRandomlyParameter.ActualName = SetSeedRandomlyParameter.Name;
globalRandomCreator.Successor = layer0Creator;
layer0Creator.NumberOfSubScopesParameter.Value = new IntValue(1);
layer0Creator.Successor = layer0Processor;
layer0Processor.Operators.Add(localRandomCreator);
layer0Processor.Successor = initializeGlobalEvaluatedSolutions;
localRandomCreator.Successor = layerSolutionsCreator;
layerSolutionsCreator.NumberOfSolutionsParameter.ActualName = PopulationSizeParameter.Name;
layerSolutionsCreator.Successor = initializeAgeProcessor;
initializeAgeProcessor.Operator = initializeAge;
initializeAgeProcessor.Successor = initializeCurrentPopulationSize;
initializeCurrentPopulationSize.ValueParameter.ActualName = "CurrentPopulationSize";
initializeCurrentPopulationSize.Successor = initializeLocalEvaluatedSolutions;
initializeAge.CollectedValues.Add(new ValueParameter<DoubleValue>("Age", new DoubleValue(0)));
initializeAge.Successor = null;
initializeLocalEvaluatedSolutions.LeftSideParameter.ActualName = "LayerEvaluatedSolutions";
initializeLocalEvaluatedSolutions.RightSideParameter.ActualName = "CurrentPopulationSize";
initializeLocalEvaluatedSolutions.Successor = null;
initializeGlobalEvaluatedSolutions.ReductionOperation.Value.Value = ReductionOperations.Sum;
initializeGlobalEvaluatedSolutions.TargetOperation.Value.Value = ReductionOperations.Assign;
initializeGlobalEvaluatedSolutions.ParameterToReduce.ActualName = "LayerEvaluatedSolutions";
initializeGlobalEvaluatedSolutions.TargetParameter.ActualName = "EvaluatedSolutions";
initializeGlobalEvaluatedSolutions.Successor = resultsCollector;
resultsCollector.CollectedValues.Add(new LookupParameter<IntValue>("Evaluated Solutions", null, "EvaluatedSolutions"));
resultsCollector.Successor = mainLoop;
mainLoop.GlobalRandomParameter.ActualName = "GlobalRandom";
mainLoop.LocalRandomParameter.ActualName = localRandomCreator.LocalRandomParameter.Name;
mainLoop.EvaluatedSolutionsParameter.ActualName = "EvaluatedSolutions";
mainLoop.AnalyzerParameter.ActualName = AnalyzerParameter.Name;
mainLoop.LayerAnalyzerParameter.ActualName = LayerAnalyzerParameter.Name;
mainLoop.NumberOfLayersParameter.ActualName = NumberOfLayersParameter.Name;
mainLoop.PopulationSizeParameter.ActualName = PopulationSizeParameter.Name;
mainLoop.CurrentPopulationSizeParameter.ActualName = "CurrentPopulationSize";
mainLoop.SelectorParameter.ActualName = SelectorParameter.Name;
mainLoop.CrossoverParameter.ActualName = CrossoverParameter.Name;
mainLoop.MutatorParameter.ActualName = MutatorParameter.Name;
mainLoop.MutationProbabilityParameter.ActualName = MutationProbabilityParameter.Name;
mainLoop.ElitesParameter.ActualName = ElitesParameter.Name;
mainLoop.ReevaluateElitesParameter.ActualName = ReevaluateElitesParameter.Name;
mainLoop.PlusSelectionParameter.ActualName = PlusSelectionParameter.Name;
mainLoop.AgeParameter.ActualName = "Age";
mainLoop.AgeGapParameter.ActualName = AgeGapParameter.Name;
mainLoop.AgeInheritanceParameter.ActualName = AgeInheritanceParameter.Name;
mainLoop.AgeLimitsParameter.ActualName = AgeLimitsParameter.Name;
mainLoop.MatingPoolRangeParameter.ActualName = MatingPoolRangeParameter.Name;
mainLoop.ReduceToPopulationSizeParameter.ActualName = ReduceToPopulationSizeParameter.Name;
mainLoop.TerminatorParameter.ActualName = TerminatorParameter.Name;
#endregion
#region Set selectors
foreach (var selector in ApplicationManager.Manager.GetInstances<ISelector>().Where(s => !(s is IMultiObjectiveSelector)).OrderBy(s => Name))
SelectorParameter.ValidValues.Add(selector);
var defaultSelector = SelectorParameter.ValidValues.OfType<GeneralizedRankSelector>().FirstOrDefault();
if (defaultSelector != null) {
defaultSelector.PressureParameter.Value = new DoubleValue(4.0);
SelectorParameter.Value = defaultSelector;
}
#endregion
#region Create analyzers
qualityAnalyzer = new BestAverageWorstQualityAnalyzer();
layerQualityAnalyzer = new BestAverageWorstQualityAnalyzer();
ageAnalyzer = new OldestAverageYoungestAgeAnalyzer();
layerAgeAnalyzer = new OldestAverageYoungestAgeAnalyzer();
ageDistributionAnalyzer = new AgeDistributionAnalyzer();
layerAgeDistributionAnalyzer = new AgeDistributionAnalyzer();
#endregion
#region Create terminators
generationsTerminator = new ComparisonTerminator<IntValue>("Generations", ComparisonType.Less, new IntValue(1000)) { Name = "Generations" };
evaluationsTerminator = new ComparisonTerminator<IntValue>("EvaluatedSolutions", ComparisonType.Less, new IntValue(int.MaxValue)) { Name = "Evaluations" };
qualityTerminator = new SingleObjectiveQualityTerminator() { Name = "Quality" };
executionTimeTerminator = new ExecutionTimeTerminator(this, new TimeSpanValue(TimeSpan.FromMinutes(5)));
#endregion
#region Parameterize
UpdateAnalyzers();
ParameterizeAnalyzers();
ParameterizeSelectors();
UpdateTerminators();
ParameterizeAgeLimits();
#endregion
Initialize();
}
private CombinedOperator CreateLayerOpener() {
var layerOpener = new CombinedOperator() { Name = "Open new Layer if needed" };
var maxLayerReached = new Comparator() { Name = "MaxLayersReached = OpenLayers >= NumberOfLayers" };
var maxLayerReachedBranch = new ConditionalBranch() { Name = "MaxLayersReached?" };
var openNewLayerCalculator = new ExpressionCalculator() { Name = "OpenNewLayer = Generations >= AgeLimits[OpenLayers - 1]" };
var openNewLayerBranch = new ConditionalBranch() { Name = "OpenNewLayer?" };
var layerCreator = new LastLayerCloner() { Name = "Create Layer" };
var updateLayerNumber = new Assigner() { Name = "Layer = OpenLayers" };
var historyWiper = new ResultsHistoryWiper() { Name = "Clear History in Results" };
var createChildrenViaCrossover = new AlpsOffspringSelectionGeneticAlgorithmMainOperator();
var incrEvaluatedSolutionsForNewLayer = new SubScopesCounter() { Name = "Update EvaluatedSolutions" };
var incrOpenLayers = new IntCounter() { Name = "Incr. OpenLayers" };
var newLayerResultsCollector = new ResultsCollector() { Name = "Collect new Layer Results" };
layerOpener.OperatorGraph.InitialOperator = maxLayerReached;
maxLayerReached.LeftSideParameter.ActualName = "OpenLayers";
maxLayerReached.RightSideParameter.ActualName = NumberOfLayersParameter.Name;
maxLayerReached.ResultParameter.ActualName = "MaxLayerReached";
maxLayerReached.Comparison = new Comparison(ComparisonType.GreaterOrEqual);
maxLayerReached.Successor = maxLayerReachedBranch;
maxLayerReachedBranch.ConditionParameter.ActualName = "MaxLayerReached";
maxLayerReachedBranch.FalseBranch = openNewLayerCalculator;
openNewLayerCalculator.CollectedValues.Add(new LookupParameter<IntArray>(AgeLimitsParameter.Name));
openNewLayerCalculator.CollectedValues.Add(new LookupParameter<IntValue>("Generations"));
openNewLayerCalculator.CollectedValues.Add(new LookupParameter<IntValue>(NumberOfLayersParameter.Name));
openNewLayerCalculator.CollectedValues.Add(new LookupParameter<IntValue>("OpenLayers"));
openNewLayerCalculator.ExpressionResultParameter.ActualName = "OpenNewLayer";
openNewLayerCalculator.ExpressionParameter.Value = new StringValue("Generations 1 + AgeLimits OpenLayers 1 - [] >");
openNewLayerCalculator.Successor = openNewLayerBranch;
openNewLayerBranch.ConditionParameter.ActualName = "OpenNewLayer";
openNewLayerBranch.TrueBranch = layerCreator;
layerCreator.NewLayerOperator = updateLayerNumber;
layerCreator.Successor = incrOpenLayers;
updateLayerNumber.LeftSideParameter.ActualName = "Layer";
updateLayerNumber.RightSideParameter.ActualName = "OpenLayers";
updateLayerNumber.Successor = historyWiper;
historyWiper.ResultsParameter.ActualName = "LayerResults";
historyWiper.Successor = createChildrenViaCrossover;
// Maybe use only crossover and no elitism instead of "default operator"
createChildrenViaCrossover.RandomParameter.ActualName = LocalRandomParameter.Name;
createChildrenViaCrossover.EvaluatorParameter.ActualName = EvaluatorParameter.Name;
createChildrenViaCrossover.EvaluatedSolutionsParameter.ActualName = "LayerEvaluatedSolutions";
createChildrenViaCrossover.QualityParameter.ActualName = QualityParameter.Name;
createChildrenViaCrossover.MaximizationParameter.ActualName = MaximizationParameter.Name;
createChildrenViaCrossover.PopulationSizeParameter.ActualName = PopulationSizeParameter.Name;
createChildrenViaCrossover.SelectorParameter.ActualName = SelectorParameter.Name;
createChildrenViaCrossover.CrossoverParameter.ActualName = CrossoverParameter.Name;
createChildrenViaCrossover.MutatorParameter.ActualName = MutatorParameter.ActualName;
createChildrenViaCrossover.MutationProbabilityParameter.ActualName = MutationProbabilityParameter.Name;
createChildrenViaCrossover.ElitesParameter.ActualName = ElitesParameter.Name;
createChildrenViaCrossover.ReevaluateElitesParameter.ActualName = ReevaluateElitesParameter.Name;
createChildrenViaCrossover.ComparisonFactorParameter.ActualName = ComparisonFactorParameter.Name;
createChildrenViaCrossover.SuccessRatioParameter.ActualName = SuccessRatioParameter.Name;
createChildrenViaCrossover.CurrentSuccessRatioParameter.ActualName = "CurrentSuccessRatio";
createChildrenViaCrossover.SelectionPressureParameter.ActualName = "SelectionPressure";
createChildrenViaCrossover.MaximumSelectionPressureParameter.ActualName = MaximumSelectionPressureParameter.Name;
createChildrenViaCrossover.OffspringSelectionBeforeMutationParameter.ActualName = OffspringSelectionBeforeMutationParameter.Name;
createChildrenViaCrossover.FillPopulationWithParentsParameter.ActualName = FillPopulationWithParentsParameter.Name;
createChildrenViaCrossover.AgeParameter.ActualName = AgeParameter.Name;
createChildrenViaCrossover.AgeInheritanceParameter.ActualName = AgeInheritanceParameter.Name;
createChildrenViaCrossover.AgeIncrementParameter.Value = new DoubleValue(0.0);
createChildrenViaCrossover.Successor = incrEvaluatedSolutionsForNewLayer;
incrEvaluatedSolutionsForNewLayer.ValueParameter.ActualName = EvaluatedSolutionsParameter.Name;
incrEvaluatedSolutionsForNewLayer.AccumulateParameter.Value = new BoolValue(true);
incrOpenLayers.ValueParameter.ActualName = "OpenLayers";
incrOpenLayers.Increment = new IntValue(1);
incrOpenLayers.Successor = newLayerResultsCollector;
newLayerResultsCollector.CollectedValues.Add(new ScopeTreeLookupParameter<ResultCollection>("LayerResults", "Result set for each layer", "LayerResults"));
newLayerResultsCollector.CopyValue = new BoolValue(false);
newLayerResultsCollector.Successor = null;
return layerOpener;
}
public AlpsOffspringSelectionGeneticAlgorithmMainLoop()
: base() {
Parameters.Add(new ValueLookupParameter<IRandom>("GlobalRandom", "A pseudo random number generator."));
Parameters.Add(new ValueLookupParameter<IRandom>("LocalRandom", "A pseudo random number generator."));
Parameters.Add(new ValueLookupParameter<IOperator>("Evaluator", "The operator used to evaluate solutions. This operator is executed in parallel, if an engine is used which supports parallelization."));
Parameters.Add(new ValueLookupParameter<IntValue>("EvaluatedSolutions", "The number of times solutions have been evaluated."));
Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("Quality", "The value which represents the quality of a solution."));
Parameters.Add(new ValueLookupParameter<BoolValue>("Maximization", "True if the problem is a maximization problem, otherwise false."));
Parameters.Add(new ValueLookupParameter<IOperator>("Analyzer", "The operator used to analyze all individuals from all layers combined."));
Parameters.Add(new ValueLookupParameter<IOperator>("LayerAnalyzer", "The operator used to analyze each layer."));
Parameters.Add(new ValueLookupParameter<IntValue>("NumberOfLayers", "The number of layers."));
Parameters.Add(new ValueLookupParameter<IntValue>("PopulationSize", "The size of the population of solutions in each layer."));
Parameters.Add(new LookupParameter<IntValue>("CurrentPopulationSize", "The current size of the population."));
Parameters.Add(new ValueLookupParameter<IOperator>("Selector", "The operator used to select solutions for reproduction."));
Parameters.Add(new ValueLookupParameter<IOperator>("Crossover", "The operator used to cross solutions."));
Parameters.Add(new ValueLookupParameter<IOperator>("Mutator", "The operator used to mutate solutions."));
Parameters.Add(new ValueLookupParameter<PercentValue>("MutationProbability", "The probability that the mutation operator is applied on a solution."));
Parameters.Add(new ValueLookupParameter<IntValue>("Elites", "The numer of elite solutions which are kept in each generation."));
Parameters.Add(new ValueLookupParameter<BoolValue>("ReevaluateElites", "Flag to determine if elite individuals should be reevaluated (i.e., if stochastic fitness functions are used.)"));
Parameters.Add(new ValueLookupParameter<DoubleValue>("SuccessRatio", "The ratio of successful to total children that should be achieved."));
Parameters.Add(new ValueLookupParameter<DoubleValue>("ComparisonFactor", "The comparison factor is used to determine whether the offspring should be compared to the better parent, the worse parent or a quality value linearly interpolated between them. It is in the range [0;1]."));
Parameters.Add(new ValueLookupParameter<DoubleValue>("MaximumSelectionPressure", "The maximum selection pressure that terminates the algorithm."));
Parameters.Add(new ValueLookupParameter<BoolValue>("OffspringSelectionBeforeMutation", "True if the offspring selection step should be applied before mutation, false if it should be applied after mutation."));
Parameters.Add(new ValueLookupParameter<BoolValue>("FillPopulationWithParents", "True if the population should be filled with parent individual or false if worse children should be used when the maximum selection pressure is exceeded."));
Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("Age", "The age of individuals."));
Parameters.Add(new ValueLookupParameter<IntValue>("AgeGap", "The frequency of reseeding the lowest layer and scaling factor for the age-limits for the layers."));
Parameters.Add(new ValueLookupParameter<DoubleValue>("AgeInheritance", "A weight that determines the age of a child after crossover based on the older (1.0) and younger (0.0) parent."));
Parameters.Add(new ValueLookupParameter<IntArray>("AgeLimits", "The maximum age an individual is allowed to reach in a certain layer."));
Parameters.Add(new ValueLookupParameter<IntValue>("MatingPoolRange", "The range of sub - populations used for creating a mating pool. (1 = current + previous sub-population)"));
Parameters.Add(new ValueLookupParameter<BoolValue>("ReduceToPopulationSize", "Reduce the CurrentPopulationSize after elder migration to PopulationSize"));
Parameters.Add(new ValueLookupParameter<IOperator>("Terminator", "The termination criteria that defines if the algorithm should continue or stop"));
var variableCreator = new VariableCreator() { Name = "Initialize" };
var initLayerAnalyzerProcessor = new SubScopesProcessor();
var layerVariableCreator = new VariableCreator() { Name = "Initialize Layer" };
var initLayerAnalyzerPlaceholder = new Placeholder() { Name = "LayerAnalyzer (Placeholder)" };
var layerResultCollector = new ResultsCollector() { Name = "Collect layer results" };
var initAnalyzerPlaceholder = new Placeholder() { Name = "Analyzer (Placeholder)" };
var resultsCollector = new ResultsCollector();
var matingPoolCreator = new MatingPoolCreator() { Name = "Create Mating Pools" };
var matingPoolProcessor = new UniformSubScopesProcessor() { Name = "Process Mating Pools" };
var initializeLayer = new Assigner() { Name = "Reset LayerEvaluatedSolutions" };
var mainOperator = new AlpsOffspringSelectionGeneticAlgorithmMainOperator();
var generationsIcrementor = new IntCounter() { Name = "Increment Generations" };
var evaluatedSolutionsReducer = new DataReducer() { Name = "Increment EvaluatedSolutions" };
var eldersEmigrator = CreateEldersEmigrator();
var layerOpener = CreateLayerOpener();
var layerReseeder = CreateReseeder();
var layerAnalyzerProcessor = new UniformSubScopesProcessor();
var layerAnalyzerPlaceholder = new Placeholder() { Name = "LayerAnalyzer (Placeholder)" };
var analyzerPlaceholder = new Placeholder() { Name = "Analyzer (Placeholder)" };
var termination = new TerminationOperator();
OperatorGraph.InitialOperator = variableCreator;
variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("Generations", new IntValue(0)));
variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("OpenLayers", new IntValue(1)));
variableCreator.Successor = initLayerAnalyzerProcessor;
initLayerAnalyzerProcessor.Operators.Add(layerVariableCreator);
initLayerAnalyzerProcessor.Successor = initAnalyzerPlaceholder;
layerVariableCreator.CollectedValues.Add(new ValueParameter<IntValue>("Layer", new IntValue(0)));
layerVariableCreator.CollectedValues.Add(new ValueParameter<ResultCollection>("LayerResults"));
layerVariableCreator.CollectedValues.Add(new ValueParameter<DoubleValue>("SelectionPressure", new DoubleValue(0)));
layerVariableCreator.CollectedValues.Add(new ValueParameter<DoubleValue>("CurrentSuccessRatio", new DoubleValue(0)));
layerVariableCreator.Successor = initLayerAnalyzerPlaceholder;
initLayerAnalyzerPlaceholder.OperatorParameter.ActualName = LayerAnalyzerParameter.Name;
initLayerAnalyzerPlaceholder.Successor = layerResultCollector;
layerResultCollector.ResultsParameter.ActualName = "LayerResults";
layerResultCollector.CollectedValues.Add(new LookupParameter<DoubleValue>("Current Selection Pressure", "Displays the rising selection pressure during a generation.", "SelectionPressure"));
layerResultCollector.CollectedValues.Add(new LookupParameter<DoubleValue>("Current Success Ratio", "Indicates how many successful children were already found during a generation (relative to the population size).", "CurrentSuccessRatio"));
layerResultCollector.Successor = null;
initAnalyzerPlaceholder.OperatorParameter.ActualName = AnalyzerParameter.Name;
initAnalyzerPlaceholder.Successor = resultsCollector;
resultsCollector.CollectedValues.Add(new LookupParameter<IntValue>("Generations"));
resultsCollector.CollectedValues.Add(new ScopeTreeLookupParameter<ResultCollection>("LayerResults", "Result set for each Layer", "LayerResults"));
resultsCollector.CollectedValues.Add(new LookupParameter<IntValue>("OpenLayers"));
resultsCollector.CopyValue = new BoolValue(false);
resultsCollector.Successor = matingPoolCreator;
matingPoolCreator.MatingPoolRangeParameter.Value = null;
matingPoolCreator.MatingPoolRangeParameter.ActualName = MatingPoolRangeParameter.Name;
matingPoolCreator.Successor = matingPoolProcessor;
matingPoolProcessor.Parallel.Value = true;
matingPoolProcessor.Operator = initializeLayer;
matingPoolProcessor.Successor = generationsIcrementor;
initializeLayer.LeftSideParameter.ActualName = "LayerEvaluatedSolutions";
initializeLayer.RightSideParameter.Value = new IntValue(0);
initializeLayer.Successor = mainOperator;
mainOperator.RandomParameter.ActualName = LocalRandomParameter.Name;
mainOperator.EvaluatorParameter.ActualName = EvaluatorParameter.Name;
mainOperator.EvaluatedSolutionsParameter.ActualName = "LayerEvaluatedSolutions";
mainOperator.QualityParameter.ActualName = QualityParameter.Name;
mainOperator.MaximizationParameter.ActualName = MaximizationParameter.Name;
mainOperator.PopulationSizeParameter.ActualName = PopulationSizeParameter.Name;
mainOperator.SelectorParameter.ActualName = SelectorParameter.Name;
mainOperator.CrossoverParameter.ActualName = CrossoverParameter.Name;
mainOperator.MutatorParameter.ActualName = MutatorParameter.ActualName;
mainOperator.MutationProbabilityParameter.ActualName = MutationProbabilityParameter.Name;
mainOperator.ElitesParameter.ActualName = ElitesParameter.Name;
mainOperator.ReevaluateElitesParameter.ActualName = ReevaluateElitesParameter.Name;
mainOperator.ComparisonFactorParameter.ActualName = ComparisonFactorParameter.Name;
mainOperator.SuccessRatioParameter.ActualName = SuccessRatioParameter.Name;
mainOperator.CurrentSuccessRatioParameter.ActualName = "CurrentSuccessRatio";
mainOperator.SelectionPressureParameter.ActualName = "SelectionPressure";
mainOperator.MaximumSelectionPressureParameter.ActualName = MaximumSelectionPressureParameter.Name;
mainOperator.OffspringSelectionBeforeMutationParameter.ActualName = OffspringSelectionBeforeMutationParameter.Name;
mainOperator.FillPopulationWithParentsParameter.ActualName = FillPopulationWithParentsParameter.Name;
mainOperator.AgeParameter.ActualName = AgeParameter.Name;
mainOperator.AgeInheritanceParameter.ActualName = AgeInheritanceParameter.Name;
mainOperator.AgeIncrementParameter.Value = new DoubleValue(1.0);
mainOperator.Successor = null;
generationsIcrementor.ValueParameter.ActualName = "Generations";
generationsIcrementor.Increment = new IntValue(1);
generationsIcrementor.Successor = evaluatedSolutionsReducer;
evaluatedSolutionsReducer.ParameterToReduce.ActualName = "LayerEvaluatedSolutions";
evaluatedSolutionsReducer.TargetParameter.ActualName = EvaluatedSolutionsParameter.Name;
evaluatedSolutionsReducer.ReductionOperation.Value = new ReductionOperation(ReductionOperations.Sum);
evaluatedSolutionsReducer.TargetOperation.Value = new ReductionOperation(ReductionOperations.Sum);
evaluatedSolutionsReducer.Successor = eldersEmigrator;
eldersEmigrator.Successor = layerOpener;
layerOpener.Successor = layerReseeder;
layerReseeder.Successor = layerAnalyzerProcessor;
layerAnalyzerProcessor.Operator = layerAnalyzerPlaceholder;
layerAnalyzerProcessor.Successor = analyzerPlaceholder;
layerAnalyzerPlaceholder.OperatorParameter.ActualName = LayerAnalyzerParameter.Name;
analyzerPlaceholder.OperatorParameter.ActualName = AnalyzerParameter.Name;
analyzerPlaceholder.Successor = termination;
termination.TerminatorParameter.ActualName = TerminatorParameter.Name;
termination.ContinueBranch = matingPoolCreator;
}
private void Initialize() {
#region Create parameters
Parameters.Add(new ValueLookupParameter<IRandom>("Random", "A pseudo random number generator."));
Parameters.Add(new ValueLookupParameter<BoolValue>("Maximization", "True if the problem is a maximization problem, otherwise false."));
Parameters.Add(new LookupParameter<DoubleValue>("Quality", "The value which represents the quality of a solution."));
Parameters.Add(new LookupParameter<DoubleValue>("BestLocalQuality", "The value which represents the best quality found so far."));
Parameters.Add(new ValueLookupParameter<DoubleValue>("BestKnownQuality", "The problem's best known quality value found so far."));
Parameters.Add(new LookupParameter<DoubleValue>("MoveQuality", "The value which represents the quality of a move."));
Parameters.Add(new LookupParameter<IntValue>("Iterations", "The number of iterations performed."));
Parameters.Add(new ValueLookupParameter<IntValue>("MaximumIterations", "The maximum number of generations which should be processed."));
Parameters.Add(new ValueLookupParameter<VariableCollection>("Results", "The variable collection where results should be stored."));
Parameters.Add(new ValueLookupParameter<IOperator>("MoveGenerator", "The operator that generates the moves."));
Parameters.Add(new ValueLookupParameter<IOperator>("MoveMaker", "The operator that performs a move and updates the quality."));
Parameters.Add(new ValueLookupParameter<IOperator>("MoveEvaluator", "The operator that evaluates a move."));
Parameters.Add(new ValueLookupParameter<IOperator>("Analyzer", "The operator used to analyze the solution and moves."));
Parameters.Add(new LookupParameter<IntValue>("EvaluatedMoves", "The number of evaluated moves."));
#endregion
#region Create operators
SubScopesProcessor subScopesProcessor0 = new SubScopesProcessor();
Assigner bestQualityInitializer = new Assigner();
Placeholder analyzer1 = new Placeholder();
ResultsCollector resultsCollector1 = new ResultsCollector();
SubScopesProcessor mainProcessor = new SubScopesProcessor();
Placeholder moveGenerator = new Placeholder();
UniformSubScopesProcessor moveEvaluationProcessor = new UniformSubScopesProcessor();
Placeholder moveEvaluator = new Placeholder();
SubScopesCounter subScopesCounter = new SubScopesCounter();
BestSelector bestSelector = new BestSelector();
SubScopesProcessor moveMakingProcessor = new SubScopesProcessor();
UniformSubScopesProcessor selectedMoveMakingProcessor = new UniformSubScopesProcessor();
QualityComparator qualityComparator = new QualityComparator();
ConditionalBranch improvesQualityBranch = new ConditionalBranch();
Placeholder moveMaker = new Placeholder();
Assigner bestQualityUpdater = new Assigner();
ResultsCollector resultsCollector2 = new ResultsCollector();
MergingReducer mergingReducer = new MergingReducer();
Placeholder analyzer2 = new Placeholder();
SubScopesRemover subScopesRemover = new SubScopesRemover();
IntCounter iterationsCounter = new IntCounter();
Comparator iterationsComparator = new Comparator();
ConditionalBranch iterationsTermination = new ConditionalBranch();
bestQualityInitializer.Name = "Initialize BestQuality";
bestQualityInitializer.LeftSideParameter.ActualName = BestLocalQualityParameter.Name;
bestQualityInitializer.RightSideParameter.ActualName = QualityParameter.Name;
analyzer1.Name = "Analyzer (placeholder)";
analyzer1.OperatorParameter.ActualName = AnalyzerParameter.Name;
resultsCollector1.CopyValue = new BoolValue(false);
resultsCollector1.CollectedValues.Add(new LookupParameter<IntValue>(IterationsParameter.Name));
resultsCollector1.CollectedValues.Add(new LookupParameter<DoubleValue>(BestLocalQualityParameter.Name, null, BestLocalQualityParameter.Name));
resultsCollector1.ResultsParameter.ActualName = ResultsParameter.Name;
moveGenerator.Name = "MoveGenerator (placeholder)";
moveGenerator.OperatorParameter.ActualName = MoveGeneratorParameter.Name;
moveEvaluationProcessor.Parallel = new BoolValue(true);
moveEvaluator.Name = "MoveEvaluator (placeholder)";
moveEvaluator.OperatorParameter.ActualName = MoveEvaluatorParameter.Name;
subScopesCounter.Name = "Increment EvaluatedMoves";
subScopesCounter.ValueParameter.ActualName = EvaluatedMovesParameter.Name;
bestSelector.CopySelected = new BoolValue(false);
bestSelector.MaximizationParameter.ActualName = MaximizationParameter.Name;
bestSelector.NumberOfSelectedSubScopesParameter.Value = new IntValue(1);
bestSelector.QualityParameter.ActualName = MoveQualityParameter.Name;
qualityComparator.LeftSideParameter.ActualName = MoveQualityParameter.Name;
qualityComparator.RightSideParameter.ActualName = QualityParameter.Name;
qualityComparator.ResultParameter.ActualName = "IsBetter";
improvesQualityBranch.ConditionParameter.ActualName = "IsBetter";
moveMaker.Name = "MoveMaker (placeholder)";
moveMaker.OperatorParameter.ActualName = MoveMakerParameter.Name;
bestQualityUpdater.Name = "Update BestQuality";
bestQualityUpdater.LeftSideParameter.ActualName = BestLocalQualityParameter.Name;
bestQualityUpdater.RightSideParameter.ActualName = QualityParameter.Name;
resultsCollector2.CopyValue = new BoolValue(false);
resultsCollector2.CollectedValues.Add(new LookupParameter<DoubleValue>(BestLocalQualityParameter.Name, null, BestLocalQualityParameter.Name));
resultsCollector2.ResultsParameter.ActualName = ResultsParameter.Name;
analyzer2.Name = "Analyzer (placeholder)";
analyzer2.OperatorParameter.ActualName = AnalyzerParameter.Name;
subScopesRemover.RemoveAllSubScopes = true;
iterationsCounter.Name = "Iterations Counter";
iterationsCounter.Increment = new IntValue(1);
iterationsCounter.ValueParameter.ActualName = IterationsParameter.Name;
iterationsComparator.Name = "Iterations >= MaximumIterations";
iterationsComparator.Comparison = new Comparison(ComparisonType.GreaterOrEqual);
iterationsComparator.LeftSideParameter.ActualName = IterationsParameter.Name;
iterationsComparator.RightSideParameter.ActualName = MaximumIterationsParameter.Name;
iterationsComparator.ResultParameter.ActualName = "Terminate";
iterationsTermination.Name = "Iterations Termination Condition";
iterationsTermination.ConditionParameter.ActualName = "Terminate";
#endregion
#region Create operator graph
OperatorGraph.InitialOperator = subScopesProcessor0; // don't change this without adapting the constructor of LocalSearchImprovementOperator
subScopesProcessor0.Operators.Add(bestQualityInitializer);
subScopesProcessor0.Successor = resultsCollector1;
bestQualityInitializer.Successor = analyzer1;
analyzer1.Successor = null;
resultsCollector1.Successor = mainProcessor;
mainProcessor.Operators.Add(moveGenerator);
mainProcessor.Successor = iterationsCounter;
moveGenerator.Successor = moveEvaluationProcessor;
moveEvaluationProcessor.Operator = moveEvaluator;
moveEvaluationProcessor.Successor = subScopesCounter;
moveEvaluator.Successor = null;
subScopesCounter.Successor = bestSelector;
bestSelector.Successor = moveMakingProcessor;
moveMakingProcessor.Operators.Add(new EmptyOperator());
moveMakingProcessor.Operators.Add(selectedMoveMakingProcessor);
moveMakingProcessor.Successor = mergingReducer;
selectedMoveMakingProcessor.Operator = qualityComparator;
qualityComparator.Successor = improvesQualityBranch;
improvesQualityBranch.TrueBranch = moveMaker;
improvesQualityBranch.FalseBranch = null;
improvesQualityBranch.Successor = null;
moveMaker.Successor = bestQualityUpdater;
bestQualityUpdater.Successor = null;
mergingReducer.Successor = analyzer2;
analyzer2.Successor = subScopesRemover;
subScopesRemover.Successor = null;
iterationsCounter.Successor = iterationsComparator;
iterationsComparator.Successor = iterationsTermination;
iterationsTermination.TrueBranch = null;
iterationsTermination.FalseBranch = mainProcessor;
#endregion
}
private void Initialize() {
#region Create parameters
Parameters.Add(new ValueLookupParameter<IRandom>("Random", "A pseudo random number generator."));
Parameters.Add(new ValueLookupParameter<BoolValue>("Maximization", "True if the problem is a maximization problem, otherwise false."));
Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("Quality", "The value which represents the quality of a solution."));
Parameters.Add(new ValueLookupParameter<IOperator>("Selector", "The operator used to select solutions for reproduction."));
Parameters.Add(new ValueLookupParameter<IOperator>("Crossover", "The operator used to cross solutions."));
Parameters.Add(new ValueLookupParameter<PercentValue>("MutationProbability", "The probability that the mutation operator is applied on a solution."));
Parameters.Add(new ValueLookupParameter<IOperator>("Mutator", "The operator used to mutate solutions."));
Parameters.Add(new ValueLookupParameter<IOperator>("Evaluator", "The operator used to evaluate solutions. This operator is executed in parallel, if an engine is used which supports parallelization."));
Parameters.Add(new ValueLookupParameter<IntValue>("Elites", "The numer of elite solutions which are kept in each generation."));
Parameters.Add(new ValueLookupParameter<BoolValue>("ReevaluateElites", "Flag to determine if elite individuals should be reevaluated (i.e., if stochastic fitness functions are used.)"));
Parameters.Add(new ValueLookupParameter<IntValue>("MaximumGenerations", "The maximum number of generations which should be processed."));
Parameters.Add(new ValueLookupParameter<VariableCollection>("Results", "The variable collection where results should be stored."));
Parameters.Add(new ValueLookupParameter<IOperator>("Analyzer", "The operator used to analyze each generation."));
Parameters.Add(new ValueLookupParameter<IntValue>("EvaluatedSolutions", "The number of times solutions have been evaluated."));
Parameters.Add(new ValueLookupParameter<IntValue>("PopulationSize", "The size of the population."));
Parameters.Add(new ValueLookupParameter<IntValue>("MinimumPopulationSize", "The minimum size of the population of solutions."));
Parameters.Add(new ValueLookupParameter<IntValue>("MaximumPopulationSize", "The maximum size of the population of solutions."));
Parameters.Add(new ValueLookupParameter<DoubleValue>("ComparisonFactor", "The comparison factor."));
Parameters.Add(new ValueLookupParameter<IntValue>("Effort", "The maximum number of offspring created in each generation."));
Parameters.Add(new ValueLookupParameter<IntValue>("BatchSize", "The number of children that should be created during one iteration of the offspring creation process."));
Parameters.Add(new ValueLookupParameter<ISolutionSimilarityCalculator>("SimilarityCalculator", "The operator used to calculate the similarity between two solutions."));
Parameters.Add(new ScopeParameter("CurrentScope", "The current scope which represents a population of solutions on which the genetic algorithm should be applied."));
#endregion
#region Create operators
VariableCreator variableCreator = new VariableCreator();
Assigner assigner1 = new Assigner();
ResultsCollector resultsCollector = new ResultsCollector();
Placeholder analyzer1 = new Placeholder();
Placeholder selector = new Placeholder();
SubScopesProcessor subScopesProcessor1 = new SubScopesProcessor();
ChildrenCreator childrenCreator = new ChildrenCreator();
UniformSubScopesProcessor uniformSubScopesProcessor = new UniformSubScopesProcessor();
Placeholder crossover = new Placeholder();
StochasticBranch stochasticBranch = new StochasticBranch();
Placeholder mutator = new Placeholder();
Placeholder evaluator = new Placeholder();
WeightedParentsQualityComparator weightedParentsQualityComparator = new WeightedParentsQualityComparator();
SubScopesRemover subScopesRemover = new SubScopesRemover();
IntCounter intCounter1 = new IntCounter();
IntCounter intCounter2 = new IntCounter();
ConditionalSelector conditionalSelector = new ConditionalSelector();
RightReducer rightReducer1 = new RightReducer();
DuplicatesSelector duplicateSelector = new DuplicatesSelector();
LeftReducer leftReducer1 = new LeftReducer();
ProgressiveOffspringPreserver progressiveOffspringSelector = new ProgressiveOffspringPreserver();
SubScopesCounter subScopesCounter2 = new SubScopesCounter();
ExpressionCalculator calculator1 = new ExpressionCalculator();
ConditionalBranch conditionalBranch1 = new ConditionalBranch();
Comparator comparator1 = new Comparator();
ConditionalBranch conditionalBranch2 = new ConditionalBranch();
LeftReducer leftReducer2 = new LeftReducer();
SubScopesProcessor subScopesProcessor2 = new SubScopesProcessor();
BestSelector bestSelector = new BestSelector();
RightReducer rightReducer2 = new RightReducer();
ScopeCleaner scopeCleaner = new ScopeCleaner();
ScopeRestorer scopeRestorer = new ScopeRestorer();
MergingReducer mergingReducer = new MergingReducer();
IntCounter intCounter3 = new IntCounter();
SubScopesCounter subScopesCounter3 = new SubScopesCounter();
ExpressionCalculator calculator2 = new ExpressionCalculator();
Comparator comparator2 = new Comparator();
ConditionalBranch conditionalBranch3 = new ConditionalBranch();
Placeholder analyzer2 = new Placeholder();
Comparator comparator3 = new Comparator();
ConditionalBranch conditionalBranch4 = new ConditionalBranch();
Comparator comparator4 = new Comparator();
ConditionalBranch conditionalBranch5 = new ConditionalBranch();
Assigner assigner3 = new Assigner();
Assigner assigner4 = new Assigner();
Assigner assigner5 = new Assigner();
ConditionalBranch reevaluateElitesBranch = new ConditionalBranch();
UniformSubScopesProcessor uniformSubScopesProcessor2 = new UniformSubScopesProcessor();
Placeholder evaluator2 = new Placeholder();
SubScopesCounter subScopesCounter4 = new SubScopesCounter();
variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("Generations", new IntValue(0))); // Class RAPGA expects this to be called Generations
variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("CurrentPopulationSize", new IntValue(0)));
variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("NumberOfCreatedOffspring", new IntValue(0)));
variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("NumberOfSuccessfulOffspring", new IntValue(0)));
variableCreator.CollectedValues.Add(new ValueParameter<ScopeList>("OffspringList", new ScopeList()));
assigner1.Name = "Initialize CurrentPopulationSize";
assigner1.LeftSideParameter.ActualName = "CurrentPopulationSize";
assigner1.RightSideParameter.ActualName = PopulationSizeParameter.Name;
resultsCollector.CollectedValues.Add(new LookupParameter<IntValue>("Generations"));
resultsCollector.CollectedValues.Add(new LookupParameter<IntValue>("CurrentPopulationSize"));
resultsCollector.ResultsParameter.ActualName = "Results";
analyzer1.Name = "Analyzer";
analyzer1.OperatorParameter.ActualName = "Analyzer";
selector.Name = "Selector";
selector.OperatorParameter.ActualName = "Selector";
childrenCreator.ParentsPerChild = new IntValue(2);
uniformSubScopesProcessor.Parallel.Value = true;
crossover.Name = "Crossover";
crossover.OperatorParameter.ActualName = "Crossover";
stochasticBranch.ProbabilityParameter.ActualName = "MutationProbability";
stochasticBranch.RandomParameter.ActualName = "Random";
mutator.Name = "Mutator";
mutator.OperatorParameter.ActualName = "Mutator";
evaluator.Name = "Evaluator";
evaluator.OperatorParameter.ActualName = "Evaluator";
weightedParentsQualityComparator.ComparisonFactorParameter.ActualName = ComparisonFactorParameter.Name;
weightedParentsQualityComparator.LeftSideParameter.ActualName = QualityParameter.Name;
weightedParentsQualityComparator.MaximizationParameter.ActualName = MaximizationParameter.Name;
weightedParentsQualityComparator.RightSideParameter.ActualName = QualityParameter.Name;
weightedParentsQualityComparator.ResultParameter.ActualName = "SuccessfulOffspring";
subScopesRemover.RemoveAllSubScopes = true;
intCounter1.Name = "Increment NumberOfCreatedOffspring";
intCounter1.ValueParameter.ActualName = "NumberOfCreatedOffspring";
intCounter1.Increment = null;
intCounter1.IncrementParameter.ActualName = BatchSizeParameter.Name;
intCounter2.Name = "Increment EvaluatedSolutions";
intCounter2.ValueParameter.ActualName = EvaluatedSolutionsParameter.Name;
intCounter2.Increment = null;
intCounter2.IncrementParameter.ActualName = BatchSizeParameter.Name;
conditionalSelector.ConditionParameter.ActualName = "SuccessfulOffspring";
conditionalSelector.ConditionParameter.Depth = 1;
conditionalSelector.CopySelected.Value = false;
duplicateSelector.CopySelected.Value = false;
progressiveOffspringSelector.OffspringListParameter.ActualName = "OffspringList";
progressiveOffspringSelector.ElitesParameter.ActualName = ElitesParameter.Name;
progressiveOffspringSelector.MaximumPopulationSizeParameter.ActualName = MaximumPopulationSizeParameter.Name;
subScopesCounter2.Name = "Count Successful Offspring";
subScopesCounter2.ValueParameter.ActualName = "NumberOfSuccessfulOffspring";
calculator1.Name = "NumberOfSuccessfulOffspring == MaximumPopulationSize - Elites";
calculator1.CollectedValues.Add(new ValueLookupParameter<IntValue>("NumberOfSuccessfulOffspring"));
calculator1.CollectedValues.Add(new ValueLookupParameter<IntValue>("MaximumPopulationSize"));
calculator1.CollectedValues.Add(new ValueLookupParameter<IntValue>("Elites"));
calculator1.ExpressionParameter.Value = new StringValue("NumberOfSuccessfulOffspring MaximumPopulationSize Elites - ==");
calculator1.ExpressionResultParameter.ActualName = "Break";
conditionalBranch1.Name = "Break?";
conditionalBranch1.ConditionParameter.ActualName = "Break";
comparator1.Name = "NumberOfCreatedOffspring >= Effort";
comparator1.Comparison = new Comparison(ComparisonType.GreaterOrEqual);
comparator1.LeftSideParameter.ActualName = "NumberOfCreatedOffspring";
comparator1.RightSideParameter.ActualName = EffortParameter.Name;
comparator1.ResultParameter.ActualName = "Break";
conditionalBranch2.Name = "Break?";
conditionalBranch2.ConditionParameter.ActualName = "Break";
bestSelector.CopySelected = new BoolValue(false);
bestSelector.MaximizationParameter.ActualName = MaximizationParameter.Name;
bestSelector.NumberOfSelectedSubScopesParameter.ActualName = "Elites";
bestSelector.QualityParameter.ActualName = QualityParameter.Name;
intCounter3.Name = "Increment Generations";
intCounter3.Increment = new IntValue(1);
intCounter3.ValueParameter.ActualName = "Generations";
subScopesCounter3.Name = "Update CurrentPopulationSize";
subScopesCounter3.ValueParameter.ActualName = "CurrentPopulationSize";
subScopesCounter3.AccumulateParameter.Value = new BoolValue(false);
calculator2.Name = "Evaluate ActualSelectionPressure";
calculator2.CollectedValues.Add(new ValueLookupParameter<IntValue>("NumberOfCreatedOffspring"));
calculator2.CollectedValues.Add(new ValueLookupParameter<IntValue>("Elites"));
calculator2.CollectedValues.Add(new ValueLookupParameter<IntValue>("CurrentPopulationSize"));
calculator2.ExpressionParameter.Value = new StringValue("NumberOfCreatedOffspring Elites + CurrentPopulationSize /");
calculator2.ExpressionResultParameter.ActualName = "ActualSelectionPressure";
comparator2.Name = "CurrentPopulationSize < 1";
comparator2.Comparison = new Comparison(ComparisonType.Less);
comparator2.LeftSideParameter.ActualName = "CurrentPopulationSize";
comparator2.RightSideParameter.Value = new IntValue(1);
comparator2.ResultParameter.ActualName = "Terminate";
conditionalBranch3.Name = "Terminate?";
conditionalBranch3.ConditionParameter.ActualName = "Terminate";
analyzer2.Name = "Analyzer";
analyzer2.OperatorParameter.ActualName = "Analyzer";
comparator3.Name = "Generations >= MaximumGenerations";
comparator3.Comparison = new Comparison(ComparisonType.GreaterOrEqual);
comparator3.LeftSideParameter.ActualName = "Generations";
comparator3.ResultParameter.ActualName = "Terminate";
comparator3.RightSideParameter.ActualName = MaximumGenerationsParameter.Name;
conditionalBranch4.Name = "Terminate?";
conditionalBranch4.ConditionParameter.ActualName = "Terminate";
comparator4.Name = "CurrentPopulationSize < MinimumPopulationSize";
comparator4.Comparison = new Comparison(ComparisonType.Less);
comparator4.LeftSideParameter.ActualName = "CurrentPopulationSize";
comparator4.RightSideParameter.ActualName = MinimumPopulationSizeParameter.Name;
comparator4.ResultParameter.ActualName = "Terminate";
conditionalBranch5.Name = "Terminate?";
conditionalBranch5.ConditionParameter.ActualName = "Terminate";
assigner3.Name = "Reset NumberOfCreatedOffspring";
assigner3.LeftSideParameter.ActualName = "NumberOfCreatedOffspring";
assigner3.RightSideParameter.Value = new IntValue(0);
assigner4.Name = "Reset NumberOfSuccessfulOffspring";
assigner4.LeftSideParameter.ActualName = "NumberOfSuccessfulOffspring";
assigner4.RightSideParameter.Value = new IntValue(0);
assigner5.Name = "Reset OffspringList";
assigner5.LeftSideParameter.ActualName = "OffspringList";
assigner5.RightSideParameter.Value = new ScopeList();
reevaluateElitesBranch.ConditionParameter.ActualName = "ReevaluateElites";
reevaluateElitesBranch.Name = "Reevaluate elites ?";
uniformSubScopesProcessor2.Parallel.Value = true;
evaluator2.Name = "Evaluator (placeholder)";
evaluator2.OperatorParameter.ActualName = EvaluatorParameter.Name;
subScopesCounter4.Name = "Increment EvaluatedSolutions";
subScopesCounter4.ValueParameter.ActualName = EvaluatedSolutionsParameter.Name;
#endregion
#region Create operator graph
OperatorGraph.InitialOperator = variableCreator;
variableCreator.Successor = assigner1;
assigner1.Successor = resultsCollector;
resultsCollector.Successor = analyzer1;
analyzer1.Successor = selector;
selector.Successor = subScopesProcessor1;
subScopesProcessor1.Operators.Add(new EmptyOperator());
subScopesProcessor1.Operators.Add(childrenCreator);
subScopesProcessor1.Successor = calculator1;
childrenCreator.Successor = uniformSubScopesProcessor;
uniformSubScopesProcessor.Operator = crossover;
uniformSubScopesProcessor.Successor = intCounter1;
crossover.Successor = stochasticBranch;
stochasticBranch.FirstBranch = mutator;
stochasticBranch.SecondBranch = null;
mutator.Successor = null;
stochasticBranch.Successor = evaluator;
evaluator.Successor = weightedParentsQualityComparator;
weightedParentsQualityComparator.Successor = subScopesRemover;
intCounter1.Successor = intCounter2;
intCounter2.Successor = conditionalSelector;
conditionalSelector.Successor = rightReducer1;
rightReducer1.Successor = duplicateSelector;
duplicateSelector.Successor = leftReducer1;
leftReducer1.Successor = progressiveOffspringSelector;
progressiveOffspringSelector.Successor = subScopesCounter2;
calculator1.Successor = conditionalBranch1;
conditionalBranch1.FalseBranch = comparator1;
conditionalBranch1.TrueBranch = subScopesProcessor2;
comparator1.Successor = conditionalBranch2;
conditionalBranch2.FalseBranch = leftReducer2;
conditionalBranch2.TrueBranch = subScopesProcessor2;
leftReducer2.Successor = selector;
subScopesProcessor2.Operators.Add(bestSelector);
subScopesProcessor2.Operators.Add(scopeCleaner);
subScopesProcessor2.Successor = mergingReducer;
bestSelector.Successor = rightReducer2;
rightReducer2.Successor = reevaluateElitesBranch;
reevaluateElitesBranch.TrueBranch = uniformSubScopesProcessor2;
uniformSubScopesProcessor2.Operator = evaluator2;
uniformSubScopesProcessor2.Successor = subScopesCounter4;
evaluator2.Successor = null;
subScopesCounter4.Successor = null;
reevaluateElitesBranch.FalseBranch = null;
reevaluateElitesBranch.Successor = null;
scopeCleaner.Successor = scopeRestorer;
mergingReducer.Successor = intCounter3;
intCounter3.Successor = subScopesCounter3;
subScopesCounter3.Successor = calculator2;
calculator2.Successor = comparator2;
comparator2.Successor = conditionalBranch3;
conditionalBranch3.FalseBranch = analyzer2;
conditionalBranch3.TrueBranch = null;
analyzer2.Successor = comparator3;
comparator3.Successor = conditionalBranch4;
conditionalBranch4.FalseBranch = comparator4;
conditionalBranch4.TrueBranch = null;
conditionalBranch4.Successor = null;
comparator4.Successor = conditionalBranch5;
conditionalBranch5.FalseBranch = assigner3;
conditionalBranch5.TrueBranch = null;
conditionalBranch5.Successor = null;
assigner3.Successor = assigner4;
assigner4.Successor = assigner5;
assigner5.Successor = selector;
#endregion
}
private Assigner(Assigner original, Cloner cloner)
: base(original, cloner)
{
}
public SASEGASAMainLoop()
: base() {
#region Create parameters
Parameters.Add(new ValueLookupParameter<IRandom>("Random", "A pseudo random number generator."));
Parameters.Add(new ValueLookupParameter<BoolValue>("Maximization", "True if the problem is a maximization problem, otherwise false."));
Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("Quality", "The value which represents the quality of a solution."));
Parameters.Add(new ValueLookupParameter<DoubleValue>("BestKnownQuality", "The best known quality value found so far."));
Parameters.Add(new ValueLookupParameter<IntValue>("NumberOfVillages", "The initial number of villages."));
Parameters.Add(new ValueLookupParameter<IntValue>("MigrationInterval", "The fixed period after which migration occurs."));
Parameters.Add(new ValueLookupParameter<IOperator>("Selector", "The operator used to select solutions for reproduction."));
Parameters.Add(new ValueLookupParameter<IOperator>("Crossover", "The operator used to cross solutions."));
Parameters.Add(new ValueLookupParameter<PercentValue>("MutationProbability", "The probability that the mutation operator is applied on a solution."));
Parameters.Add(new ValueLookupParameter<IOperator>("Mutator", "The operator used to mutate solutions."));
Parameters.Add(new ValueLookupParameter<IOperator>("Evaluator", "The operator used to evaluate solutions. This operator is executed in parallel, if an engine is used which supports parallelization."));
Parameters.Add(new ValueLookupParameter<IntValue>("Elites", "The numer of elite solutions which are kept in each generation."));
Parameters.Add(new ValueLookupParameter<BoolValue>("ReevaluateElites", "Flag to determine if elite individuals should be reevaluated (i.e., if stochastic fitness functions are used.)"));
Parameters.Add(new ValueLookupParameter<ResultCollection>("Results", "The results collection to store the results."));
Parameters.Add(new ValueLookupParameter<IOperator>("Analyzer", "The operator used to the analyze the villages."));
Parameters.Add(new ValueLookupParameter<IOperator>("VillageAnalyzer", "The operator used to analyze each village."));
Parameters.Add(new ValueLookupParameter<DoubleValue>("SuccessRatio", "The ratio of successful to total children that should be achieved."));
Parameters.Add(new LookupParameter<DoubleValue>("ComparisonFactor", "The comparison factor is used to determine whether the offspring should be compared to the better parent, the worse parent or a quality value linearly interpolated between them. It is in the range [0;1]."));
Parameters.Add(new ValueLookupParameter<DoubleValue>("ComparisonFactorStart", "The lower bound of the comparison factor (start)."));
Parameters.Add(new ValueLookupParameter<IOperator>("ComparisonFactorModifier", "The operator used to modify the comparison factor."));
Parameters.Add(new ValueLookupParameter<DoubleValue>("MaximumSelectionPressure", "The maximum selection pressure that terminates the algorithm."));
Parameters.Add(new ValueLookupParameter<DoubleValue>("FinalMaximumSelectionPressure", "The maximum selection pressure used when there is only one village left."));
Parameters.Add(new ValueLookupParameter<IntValue>("MaximumGenerations", "The maximum genreation that terminates the algorithm."));
Parameters.Add(new ValueLookupParameter<BoolValue>("OffspringSelectionBeforeMutation", "True if the offspring selection step should be applied before mutation, false if it should be applied after mutation."));
Parameters.Add(new LookupParameter<IntValue>("EvaluatedSolutions", "The number of times solutions have been evaluated."));
Parameters.Add(new ValueLookupParameter<BoolValue>("FillPopulationWithParents", "True if the population should be filled with parent individual or false if worse children should be used when the maximum selection pressure is exceeded."));
#endregion
#region Create operators
VariableCreator variableCreator = new VariableCreator();
Assigner maxSelPressAssigner = new Assigner();
Assigner villageCountAssigner = new Assigner();
Assigner comparisonFactorInitializer = new Assigner();
UniformSubScopesProcessor uniformSubScopesProcessor0 = new UniformSubScopesProcessor();
VariableCreator villageVariableCreator = new VariableCreator();
Placeholder villageAnalyzer1 = new Placeholder();
ResultsCollector villageResultsCollector1 = new ResultsCollector();
Placeholder analyzer1 = new Placeholder();
ResultsCollector resultsCollector1 = new ResultsCollector();
UniformSubScopesProcessor uniformSubScopesProcessor1 = new UniformSubScopesProcessor();
ConditionalBranch villageTerminatedBySelectionPressure1 = new ConditionalBranch();
OffspringSelectionGeneticAlgorithmMainOperator mainOperator = new OffspringSelectionGeneticAlgorithmMainOperator();
Placeholder villageAnalyzer2 = new Placeholder();
ResultsCollector villageResultsCollector2 = new ResultsCollector();
Comparator villageSelectionPressureComparator = new Comparator();
ConditionalBranch villageTerminatedBySelectionPressure2 = new ConditionalBranch();
IntCounter terminatedVillagesCounter = new IntCounter();
IntCounter generationsCounter = new IntCounter();
IntCounter generationsSinceLastReunificationCounter = new IntCounter();
Comparator reunificationComparator1 = new Comparator();
ConditionalBranch reunificationConditionalBranch1 = new ConditionalBranch();
Comparator reunificationComparator2 = new Comparator();
ConditionalBranch reunificationConditionalBranch2 = new ConditionalBranch();
Comparator reunificationComparator3 = new Comparator();
ConditionalBranch reunificationConditionalBranch3 = new ConditionalBranch();
Assigner resetTerminatedVillagesAssigner = new Assigner();
Assigner resetGenerationsSinceLastReunificationAssigner = new Assigner();
SASEGASAReunificator reunificator = new SASEGASAReunificator();
IntCounter reunificationCounter = new IntCounter();
Placeholder comparisonFactorModifier = new Placeholder();
UniformSubScopesProcessor uniformSubScopesProcessor2 = new UniformSubScopesProcessor();
Assigner villageReviver = new Assigner();
Comparator villageCountComparator = new Comparator();
ConditionalBranch villageCountConditionalBranch = new ConditionalBranch();
Assigner finalMaxSelPressAssigner = new Assigner();
Comparator maximumGenerationsComparator = new Comparator();
Comparator maximumEvaluatedSolutionsComparator = new Comparator();
Placeholder analyzer2 = new Placeholder();
ConditionalBranch terminationCondition = new ConditionalBranch();
ConditionalBranch maximumGenerationsTerminationCondition = new ConditionalBranch();
ConditionalBranch maximumEvaluatedSolutionsTerminationCondition = new ConditionalBranch();
variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("Reunifications", new IntValue(0)));
variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("Generations", new IntValue(0))); // Class SASEGASA expects this to be called Generations
variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("GenerationsSinceLastReunification", new IntValue(0)));
variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("TerminatedVillages", new IntValue(0)));
villageCountAssigner.LeftSideParameter.ActualName = "VillageCount";
villageCountAssigner.RightSideParameter.ActualName = NumberOfVillagesParameter.Name;
maxSelPressAssigner.LeftSideParameter.ActualName = "CurrentMaximumSelectionPressure";
maxSelPressAssigner.RightSideParameter.ActualName = MaximumSelectionPressureParameter.Name;
comparisonFactorInitializer.LeftSideParameter.ActualName = ComparisonFactorParameter.Name;
comparisonFactorInitializer.RightSideParameter.ActualName = ComparisonFactorStartParameter.Name;
villageVariableCreator.CollectedValues.Add(new ValueParameter<ResultCollection>("Results", new ResultCollection()));
villageVariableCreator.CollectedValues.Add(new ValueParameter<BoolValue>("TerminateSelectionPressure", new BoolValue(false)));
villageVariableCreator.CollectedValues.Add(new ValueParameter<DoubleValue>("SelectionPressure", new DoubleValue(0)));
villageVariableCreator.CollectedValues.Add(new ValueParameter<DoubleValue>("CurrentSuccessRatio", new DoubleValue(0)));
villageAnalyzer1.Name = "Village Analyzer (placeholder)";
villageAnalyzer1.OperatorParameter.ActualName = VillageAnalyzerParameter.Name;
villageResultsCollector1.CollectedValues.Add(new LookupParameter<DoubleValue>("Current Success Ratio", "Indicates how many successful children were already found during a generation (relative to the population size).", "CurrentSuccessRatio"));
villageResultsCollector1.CollectedValues.Add(new LookupParameter<DoubleValue>("Current Selection Pressure", "Displays the rising selection pressure during a generation.", "SelectionPressure"));
villageResultsCollector1.ResultsParameter.ActualName = "Results";
analyzer1.Name = "Analyzer (placeholder)";
analyzer1.OperatorParameter.ActualName = AnalyzerParameter.Name;
resultsCollector1.CopyValue = new BoolValue(false);
resultsCollector1.CollectedValues.Add(new LookupParameter<IntValue>("Generations"));
resultsCollector1.CollectedValues.Add(new LookupParameter<DoubleValue>("ComparisonFactor", null, ComparisonFactorParameter.Name));
resultsCollector1.CollectedValues.Add(new LookupParameter<IntValue>("Terminated Villages", null, "TerminatedVillages"));
resultsCollector1.CollectedValues.Add(new LookupParameter<IntValue>("Total Active Villages", null, "VillageCount"));
resultsCollector1.CollectedValues.Add(new ScopeTreeLookupParameter<ResultCollection>("VillageResults", "Result set for each village", "Results"));
resultsCollector1.ResultsParameter.ActualName = ResultsParameter.Name;
villageTerminatedBySelectionPressure1.Name = "Village Terminated ?";
villageTerminatedBySelectionPressure1.ConditionParameter.ActualName = "TerminateSelectionPressure";
mainOperator.ComparisonFactorParameter.ActualName = ComparisonFactorParameter.Name;
mainOperator.CrossoverParameter.ActualName = CrossoverParameter.Name;
mainOperator.CurrentSuccessRatioParameter.ActualName = "CurrentSuccessRatio";
mainOperator.ElitesParameter.ActualName = ElitesParameter.Name;
mainOperator.ReevaluateElitesParameter.ActualName = ReevaluateElitesParameter.Name;
mainOperator.EvaluatedSolutionsParameter.ActualName = EvaluatedSolutionsParameter.Name;
mainOperator.EvaluatorParameter.ActualName = EvaluatorParameter.Name;
mainOperator.MaximizationParameter.ActualName = MaximizationParameter.Name;
mainOperator.MaximumSelectionPressureParameter.ActualName = "CurrentMaximumSelectionPressure";
mainOperator.MutationProbabilityParameter.ActualName = MutationProbabilityParameter.Name;
mainOperator.MutatorParameter.ActualName = MutatorParameter.Name;
mainOperator.OffspringSelectionBeforeMutationParameter.ActualName = OffspringSelectionBeforeMutationParameter.Name;
mainOperator.QualityParameter.ActualName = QualityParameter.Name;
mainOperator.RandomParameter.ActualName = RandomParameter.Name;
mainOperator.SelectionPressureParameter.ActualName = "SelectionPressure";
mainOperator.SelectorParameter.ActualName = SelectorParameter.Name;
mainOperator.SuccessRatioParameter.ActualName = SuccessRatioParameter.Name;
mainOperator.FillPopulationWithParentsParameter.ActualName = FillPopulationWithParentsParameter.Name;
villageAnalyzer2.Name = "Village Analyzer (placeholder)";
villageAnalyzer2.OperatorParameter.ActualName = VillageAnalyzerParameter.Name;
villageResultsCollector2.CollectedValues.Add(new LookupParameter<DoubleValue>("Current Success Ratio", "Indicates how many successful children were already found during a generation (relative to the population size).", "CurrentSuccessRatio"));
villageResultsCollector2.CollectedValues.Add(new LookupParameter<DoubleValue>("Current Selection Pressure", "Displays the rising selection pressure during a generation.", "SelectionPressure"));
villageResultsCollector2.ResultsParameter.ActualName = "Results";
villageSelectionPressureComparator.Name = "SelectionPressure >= CurrentMaximumSelectionPressure ?";
villageSelectionPressureComparator.LeftSideParameter.ActualName = "SelectionPressure";
villageSelectionPressureComparator.Comparison = new Comparison(ComparisonType.GreaterOrEqual);
villageSelectionPressureComparator.RightSideParameter.ActualName = "CurrentMaximumSelectionPressure";
villageSelectionPressureComparator.ResultParameter.ActualName = "TerminateSelectionPressure";
villageTerminatedBySelectionPressure2.Name = "Village Terminated ?";
villageTerminatedBySelectionPressure2.ConditionParameter.ActualName = "TerminateSelectionPressure";
terminatedVillagesCounter.Name = "TerminatedVillages + 1";
terminatedVillagesCounter.ValueParameter.ActualName = "TerminatedVillages";
terminatedVillagesCounter.Increment = new IntValue(1);
generationsCounter.Name = "Generations + 1";
generationsCounter.ValueParameter.ActualName = "Generations";
generationsCounter.Increment = new IntValue(1);
generationsSinceLastReunificationCounter.Name = "GenerationsSinceLastReunification + 1";
generationsSinceLastReunificationCounter.ValueParameter.ActualName = "GenerationsSinceLastReunification";
generationsSinceLastReunificationCounter.Increment = new IntValue(1);
reunificationComparator1.Name = "TerminatedVillages = VillageCount ?";
reunificationComparator1.LeftSideParameter.ActualName = "TerminatedVillages";
reunificationComparator1.Comparison = new Comparison(ComparisonType.Equal);
reunificationComparator1.RightSideParameter.ActualName = "VillageCount";
reunificationComparator1.ResultParameter.ActualName = "Reunificate";
reunificationConditionalBranch1.Name = "Reunificate ?";
reunificationConditionalBranch1.ConditionParameter.ActualName = "Reunificate";
reunificationComparator2.Name = "GenerationsSinceLastReunification = MigrationInterval ?";
reunificationComparator2.LeftSideParameter.ActualName = "GenerationsSinceLastReunification";
reunificationComparator2.Comparison = new Comparison(ComparisonType.Equal);
reunificationComparator2.RightSideParameter.ActualName = "MigrationInterval";
reunificationComparator2.ResultParameter.ActualName = "Reunificate";
reunificationConditionalBranch2.Name = "Reunificate ?";
reunificationConditionalBranch2.ConditionParameter.ActualName = "Reunificate";
// if there's just one village left and we're getting to this point SASEGASA terminates
reunificationComparator3.Name = "VillageCount <= 1 ?";
reunificationComparator3.LeftSideParameter.ActualName = "VillageCount";
reunificationComparator3.RightSideParameter.Value = new IntValue(1);
reunificationComparator3.Comparison.Value = ComparisonType.LessOrEqual;
reunificationComparator3.ResultParameter.ActualName = "TerminateSASEGASA";
reunificationConditionalBranch3.Name = "Skip reunification?";
reunificationConditionalBranch3.ConditionParameter.ActualName = "TerminateSASEGASA";
resetTerminatedVillagesAssigner.Name = "Reset TerminatedVillages";
resetTerminatedVillagesAssigner.LeftSideParameter.ActualName = "TerminatedVillages";
resetTerminatedVillagesAssigner.RightSideParameter.Value = new IntValue(0);
resetGenerationsSinceLastReunificationAssigner.Name = "Reset GenerationsSinceLastReunification";
resetGenerationsSinceLastReunificationAssigner.LeftSideParameter.ActualName = "GenerationsSinceLastReunification";
resetGenerationsSinceLastReunificationAssigner.RightSideParameter.Value = new IntValue(0);
reunificator.VillageCountParameter.ActualName = "VillageCount";
reunificationCounter.ValueParameter.ActualName = "Reunifications"; // this variable is referenced in SASEGASA, do not change!
reunificationCounter.IncrementParameter.Value = new IntValue(1);
comparisonFactorModifier.Name = "Update comparison factor (placeholder)";
comparisonFactorModifier.OperatorParameter.ActualName = ComparisonFactorModifierParameter.Name;
villageReviver.Name = "Village Reviver";
villageReviver.LeftSideParameter.ActualName = "TerminateSelectionPressure";
villageReviver.RightSideParameter.Value = new BoolValue(false);
villageCountComparator.Name = "VillageCount == 1 ?";
villageCountComparator.LeftSideParameter.ActualName = "VillageCount";
villageCountComparator.RightSideParameter.Value = new IntValue(1);
villageCountComparator.Comparison.Value = ComparisonType.Equal;
villageCountComparator.ResultParameter.ActualName = "ChangeMaxSelPress";
villageCountConditionalBranch.Name = "Change max selection pressure?";
villageCountConditionalBranch.ConditionParameter.ActualName = "ChangeMaxSelPress";
finalMaxSelPressAssigner.LeftSideParameter.ActualName = "CurrentMaximumSelectionPressure";
finalMaxSelPressAssigner.RightSideParameter.ActualName = FinalMaximumSelectionPressureParameter.Name;
// if Generations is reaching MaximumGenerations we're also terminating
maximumGenerationsComparator.LeftSideParameter.ActualName = "Generations";
maximumGenerationsComparator.RightSideParameter.ActualName = MaximumGenerationsParameter.Name;
maximumGenerationsComparator.Comparison = new Comparison(ComparisonType.GreaterOrEqual);
maximumGenerationsComparator.ResultParameter.ActualName = "TerminateMaximumGenerations";
maximumEvaluatedSolutionsComparator.Name = "EvaluatedSolutions >= MaximumEvaluatedSolutions";
maximumEvaluatedSolutionsComparator.Comparison = new Comparison(ComparisonType.GreaterOrEqual);
maximumEvaluatedSolutionsComparator.LeftSideParameter.ActualName = EvaluatedSolutionsParameter.Name;
maximumEvaluatedSolutionsComparator.ResultParameter.ActualName = "TerminateEvaluatedSolutions";
maximumEvaluatedSolutionsComparator.RightSideParameter.ActualName = "MaximumEvaluatedSolutions";
analyzer2.Name = "Analyzer (placeholder)";
analyzer2.OperatorParameter.ActualName = AnalyzerParameter.Name;
terminationCondition.ConditionParameter.ActualName = "TerminateSASEGASA";
maximumGenerationsTerminationCondition.ConditionParameter.ActualName = "TerminateMaximumGenerations";
maximumEvaluatedSolutionsTerminationCondition.ConditionParameter.ActualName = "TerminateEvaluatedSolutions";
#endregion
#region Create operator graph
OperatorGraph.InitialOperator = variableCreator;
variableCreator.Successor = maxSelPressAssigner;
maxSelPressAssigner.Successor = villageCountAssigner;
villageCountAssigner.Successor = comparisonFactorInitializer;
comparisonFactorInitializer.Successor = uniformSubScopesProcessor0;
uniformSubScopesProcessor0.Operator = villageVariableCreator;
uniformSubScopesProcessor0.Successor = analyzer1;
villageVariableCreator.Successor = villageAnalyzer1;
villageAnalyzer1.Successor = villageResultsCollector1;
analyzer1.Successor = resultsCollector1;
resultsCollector1.Successor = uniformSubScopesProcessor1;
uniformSubScopesProcessor1.Operator = villageTerminatedBySelectionPressure1;
uniformSubScopesProcessor1.Successor = generationsCounter;
villageTerminatedBySelectionPressure1.TrueBranch = null;
villageTerminatedBySelectionPressure1.FalseBranch = mainOperator;
villageTerminatedBySelectionPressure1.Successor = null;
mainOperator.Successor = villageAnalyzer2;
villageAnalyzer2.Successor = villageResultsCollector2;
villageResultsCollector2.Successor = villageSelectionPressureComparator;
villageSelectionPressureComparator.Successor = villageTerminatedBySelectionPressure2;
villageTerminatedBySelectionPressure2.TrueBranch = terminatedVillagesCounter;
villageTerminatedBySelectionPressure2.FalseBranch = null;
villageTerminatedBySelectionPressure2.Successor = null;
terminatedVillagesCounter.Successor = null;
generationsCounter.Successor = generationsSinceLastReunificationCounter;
generationsSinceLastReunificationCounter.Successor = reunificationComparator1;
reunificationComparator1.Successor = reunificationConditionalBranch1;
reunificationConditionalBranch1.TrueBranch = reunificationComparator3;
reunificationConditionalBranch1.FalseBranch = reunificationComparator2;
reunificationConditionalBranch1.Successor = maximumGenerationsComparator;
reunificationComparator2.Successor = reunificationConditionalBranch2;
reunificationConditionalBranch2.TrueBranch = reunificationComparator3;
reunificationConditionalBranch2.FalseBranch = null;
reunificationConditionalBranch2.Successor = null;
reunificationComparator3.Successor = reunificationConditionalBranch3;
reunificationConditionalBranch3.TrueBranch = null;
reunificationConditionalBranch3.FalseBranch = resetTerminatedVillagesAssigner;
reunificationConditionalBranch3.Successor = null;
resetTerminatedVillagesAssigner.Successor = resetGenerationsSinceLastReunificationAssigner;
resetGenerationsSinceLastReunificationAssigner.Successor = reunificator;
reunificator.Successor = reunificationCounter;
reunificationCounter.Successor = comparisonFactorModifier;
comparisonFactorModifier.Successor = uniformSubScopesProcessor2;
uniformSubScopesProcessor2.Operator = villageReviver;
uniformSubScopesProcessor2.Successor = villageCountComparator;
villageReviver.Successor = null;
villageCountComparator.Successor = villageCountConditionalBranch;
villageCountConditionalBranch.TrueBranch = finalMaxSelPressAssigner;
villageCountConditionalBranch.FalseBranch = null;
villageCountConditionalBranch.Successor = null;
finalMaxSelPressAssigner.Successor = null;
maximumGenerationsComparator.Successor = maximumEvaluatedSolutionsComparator;
maximumEvaluatedSolutionsComparator.Successor = analyzer2;
analyzer2.Successor = terminationCondition;
terminationCondition.TrueBranch = null;
terminationCondition.FalseBranch = maximumGenerationsTerminationCondition;
terminationCondition.Successor = null;
maximumGenerationsTerminationCondition.TrueBranch = null;
maximumGenerationsTerminationCondition.FalseBranch = maximumEvaluatedSolutionsTerminationCondition;
maximumGenerationsTerminationCondition.Successor = null;
maximumEvaluatedSolutionsTerminationCondition.TrueBranch = null;
maximumEvaluatedSolutionsTerminationCondition.FalseBranch = uniformSubScopesProcessor1;
maximumEvaluatedSolutionsTerminationCondition.Successor = null;
#endregion
}
public IslandOffspringSelectionGeneticAlgorithmMainLoop()
: base() {
#region Create parameters
Parameters.Add(new ValueLookupParameter<IRandom>("Random", "A pseudo random number generator."));
Parameters.Add(new ValueLookupParameter<BoolValue>("Maximization", "True if the problem is a maximization problem, otherwise false."));
Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("Quality", "The value which represents the quality of a solution."));
Parameters.Add(new ValueLookupParameter<DoubleValue>("BestKnownQuality", "The best known quality value found so far."));
Parameters.Add(new ValueLookupParameter<IntValue>("NumberOfIslands", "The number of islands."));
Parameters.Add(new ValueLookupParameter<IntValue>("MigrationInterval", "The number of generations that should pass between migration phases."));
Parameters.Add(new ValueLookupParameter<PercentValue>("MigrationRate", "The proportion of individuals that should migrate between the islands."));
Parameters.Add(new ValueLookupParameter<IOperator>("Migrator", "The migration strategy."));
Parameters.Add(new ValueLookupParameter<IOperator>("EmigrantsSelector", "Selects the individuals that will be migrated."));
Parameters.Add(new ValueLookupParameter<IOperator>("ImmigrationReplacer", "Replaces part of the original population with the immigrants."));
Parameters.Add(new ValueLookupParameter<IntValue>("PopulationSize", "The size of the population of solutions."));
Parameters.Add(new ValueLookupParameter<IntValue>("MaximumGenerations", "The maximum number of generations that should be processed."));
Parameters.Add(new ValueLookupParameter<IOperator>("Selector", "The operator used to select solutions for reproduction."));
Parameters.Add(new ValueLookupParameter<IOperator>("Crossover", "The operator used to cross solutions."));
Parameters.Add(new ValueLookupParameter<PercentValue>("MutationProbability", "The probability that the mutation operator is applied on a solution."));
Parameters.Add(new ValueLookupParameter<IOperator>("Mutator", "The operator used to mutate solutions."));
Parameters.Add(new ValueLookupParameter<IOperator>("Evaluator", "The operator used to evaluate solutions. This operator is executed in parallel, if an engine is used which supports parallelization."));
Parameters.Add(new ValueLookupParameter<IntValue>("Elites", "The numer of elite solutions which are kept in each generation."));
Parameters.Add(new ValueLookupParameter<BoolValue>("ReevaluateElites", "Flag to determine if elite individuals should be reevaluated (i.e., if stochastic fitness functions are used.)"));
Parameters.Add(new ValueLookupParameter<ResultCollection>("Results", "The results collection to store the results."));
Parameters.Add(new ValueLookupParameter<IOperator>("Visualizer", "The operator used to visualize solutions."));
Parameters.Add(new LookupParameter<IItem>("Visualization", "The item which represents the visualization of solutions."));
Parameters.Add(new ValueLookupParameter<DoubleValue>("SuccessRatio", "The ratio of successful to total children that should be achieved."));
Parameters.Add(new LookupParameter<DoubleValue>("ComparisonFactor", "The comparison factor is used to determine whether the offspring should be compared to the better parent, the worse parent or a quality value linearly interpolated between them. It is in the range [0;1]."));
Parameters.Add(new ValueLookupParameter<DoubleValue>("ComparisonFactorStart", "The initial value for the comparison factor."));
Parameters.Add(new ValueLookupParameter<IOperator>("ComparisonFactorModifier", "The operator used to modify the comparison factor."));
Parameters.Add(new ValueLookupParameter<DoubleValue>("MaximumSelectionPressure", "The maximum selection pressure that terminates the algorithm."));
Parameters.Add(new ValueLookupParameter<BoolValue>("OffspringSelectionBeforeMutation", "True if the offspring selection step should be applied before mutation, false if it should be applied after mutation."));
Parameters.Add(new ValueLookupParameter<IOperator>("Analyzer", "The operator used to the analyze the islands."));
Parameters.Add(new ValueLookupParameter<IOperator>("IslandAnalyzer", "The operator used to analyze each island."));
Parameters.Add(new LookupParameter<IntValue>("EvaluatedSolutions", "The number of times solutions have been evaluated."));
Parameters.Add(new ValueLookupParameter<BoolValue>("FillPopulationWithParents", "True if the population should be filled with parent individual or false if worse children should be used when the maximum selection pressure is exceeded."));
#endregion
#region Create operators
VariableCreator variableCreator = new VariableCreator();
UniformSubScopesProcessor uniformSubScopesProcessor0 = new UniformSubScopesProcessor();
VariableCreator islandVariableCreator = new VariableCreator();
Placeholder islandAnalyzer1 = new Placeholder();
ResultsCollector islandResultsCollector1 = new ResultsCollector();
Assigner comparisonFactorInitializer = new Assigner();
Placeholder analyzer1 = new Placeholder();
ResultsCollector resultsCollector1 = new ResultsCollector();
UniformSubScopesProcessor uniformSubScopesProcessor1 = new UniformSubScopesProcessor();
ConditionalBranch islandTerminatedBySelectionPressure1 = new ConditionalBranch();
OffspringSelectionGeneticAlgorithmMainOperator mainOperator = new OffspringSelectionGeneticAlgorithmMainOperator();
Placeholder islandAnalyzer2 = new Placeholder();
ResultsCollector islandResultsCollector2 = new ResultsCollector();
Comparator islandSelectionPressureComparator = new Comparator();
ConditionalBranch islandTerminatedBySelectionPressure2 = new ConditionalBranch();
IntCounter terminatedIslandsCounter = new IntCounter();
IntCounter generationsCounter = new IntCounter();
IntCounter generationsSinceLastMigrationCounter = new IntCounter();
Comparator migrationComparator = new Comparator();
ConditionalBranch migrationBranch = new ConditionalBranch();
Assigner resetTerminatedIslandsAssigner = new Assigner();
Assigner resetGenerationsSinceLastMigrationAssigner = new Assigner();
IntCounter migrationsCounter = new IntCounter();
UniformSubScopesProcessor uniformSubScopesProcessor2 = new UniformSubScopesProcessor();
Assigner reviveIslandAssigner = new Assigner();
Placeholder emigrantsSelector = new Placeholder();
Placeholder migrator = new Placeholder();
UniformSubScopesProcessor uniformSubScopesProcessor3 = new UniformSubScopesProcessor();
Placeholder immigrationReplacer = new Placeholder();
Comparator generationsComparator = new Comparator();
Comparator terminatedIslandsComparator = new Comparator();
Comparator maxEvaluatedSolutionsComparator = new Comparator();
Placeholder comparisonFactorModifier = new Placeholder();
Placeholder analyzer2 = new Placeholder();
ConditionalBranch generationsTerminationCondition = new ConditionalBranch();
ConditionalBranch terminatedIslandsCondition = new ConditionalBranch();
ConditionalBranch evaluatedSolutionsTerminationCondition = new ConditionalBranch();
variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("Migrations", new IntValue(0)));
variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("Generations", new IntValue(0))); // Class IslandOffspringSelectionGeneticAlgorithm expects this to be called Generations
variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("GenerationsSinceLastMigration", new IntValue(0)));
variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("TerminatedIslands", new IntValue(0)));
islandVariableCreator.CollectedValues.Add(new ValueParameter<ResultCollection>(ResultsParameter.Name, new ResultCollection()));
islandVariableCreator.CollectedValues.Add(new ValueParameter<BoolValue>("TerminateSelectionPressure", new BoolValue(false)));
islandVariableCreator.CollectedValues.Add(new ValueParameter<DoubleValue>("SelectionPressure", new DoubleValue(0)));
islandAnalyzer1.Name = "Island Analyzer (placeholder)";
islandAnalyzer1.OperatorParameter.ActualName = IslandAnalyzerParameter.Name;
islandResultsCollector1.CollectedValues.Add(new LookupParameter<DoubleValue>("Current Selection Pressure", "Displays the rising selection pressure during a generation.", "SelectionPressure"));
islandResultsCollector1.CollectedValues.Add(new LookupParameter<DoubleValue>("Current Success Ratio", "Indicates how many successful children were already found during a generation (relative to the population size).", "CurrentSuccessRatio"));
islandResultsCollector1.ResultsParameter.ActualName = ResultsParameter.Name;
comparisonFactorInitializer.Name = "Initialize Comparison Factor";
comparisonFactorInitializer.LeftSideParameter.ActualName = ComparisonFactorParameter.Name;
comparisonFactorInitializer.RightSideParameter.ActualName = ComparisonFactorStartParameter.Name;
analyzer1.Name = "Analyzer (placeholder)";
analyzer1.OperatorParameter.ActualName = AnalyzerParameter.Name;
resultsCollector1.CopyValue = new BoolValue(false);
resultsCollector1.CollectedValues.Add(new LookupParameter<IntValue>("Migrations"));
resultsCollector1.CollectedValues.Add(new LookupParameter<IntValue>("Generations"));
resultsCollector1.CollectedValues.Add(new LookupParameter<DoubleValue>("Current Comparison Factor", null, ComparisonFactorParameter.Name));
resultsCollector1.CollectedValues.Add(new ScopeTreeLookupParameter<ResultCollection>("IslandResults", "Result set for each island", ResultsParameter.Name));
resultsCollector1.ResultsParameter.ActualName = ResultsParameter.Name;
islandTerminatedBySelectionPressure1.Name = "Island Terminated ?";
islandTerminatedBySelectionPressure1.ConditionParameter.ActualName = "TerminateSelectionPressure";
mainOperator.ComparisonFactorParameter.ActualName = ComparisonFactorParameter.Name;
mainOperator.CrossoverParameter.ActualName = CrossoverParameter.Name;
mainOperator.CurrentSuccessRatioParameter.ActualName = "CurrentSuccessRatio";
mainOperator.ElitesParameter.ActualName = ElitesParameter.Name;
mainOperator.ReevaluateElitesParameter.ActualName = ReevaluateElitesParameter.Name;
mainOperator.EvaluatedSolutionsParameter.ActualName = EvaluatedSolutionsParameter.Name;
mainOperator.EvaluatorParameter.ActualName = EvaluatorParameter.Name;
mainOperator.MaximizationParameter.ActualName = MaximizationParameter.Name;
mainOperator.MaximumSelectionPressureParameter.ActualName = MaximumSelectionPressureParameter.Name;
mainOperator.MutationProbabilityParameter.ActualName = MutationProbabilityParameter.Name;
mainOperator.MutatorParameter.ActualName = MutatorParameter.Name;
mainOperator.OffspringSelectionBeforeMutationParameter.ActualName = OffspringSelectionBeforeMutationParameter.Name;
mainOperator.QualityParameter.ActualName = QualityParameter.Name;
mainOperator.RandomParameter.ActualName = RandomParameter.Name;
mainOperator.SelectionPressureParameter.ActualName = "SelectionPressure";
mainOperator.SelectorParameter.ActualName = SelectorParameter.Name;
mainOperator.SuccessRatioParameter.ActualName = SuccessRatioParameter.Name;
mainOperator.FillPopulationWithParentsParameter.ActualName = FillPopulationWithParentsParameter.Name;
islandAnalyzer2.Name = "Island Analyzer (placeholder)";
islandAnalyzer2.OperatorParameter.ActualName = IslandAnalyzerParameter.Name;
islandResultsCollector2.CollectedValues.Add(new LookupParameter<DoubleValue>("Current Selection Pressure", "Displays the rising selection pressure during a generation.", "SelectionPressure"));
islandResultsCollector2.CollectedValues.Add(new LookupParameter<DoubleValue>("Current Success Ratio", "Indicates how many successful children were already found during a generation (relative to the population size).", "CurrentSuccessRatio"));
islandResultsCollector2.ResultsParameter.ActualName = "Results";
islandSelectionPressureComparator.Name = "SelectionPressure >= MaximumSelectionPressure ?";
islandSelectionPressureComparator.LeftSideParameter.ActualName = "SelectionPressure";
islandSelectionPressureComparator.Comparison = new Comparison(ComparisonType.GreaterOrEqual);
islandSelectionPressureComparator.RightSideParameter.ActualName = MaximumSelectionPressureParameter.Name;
islandSelectionPressureComparator.ResultParameter.ActualName = "TerminateSelectionPressure";
islandTerminatedBySelectionPressure2.Name = "Island Terminated ?";
islandTerminatedBySelectionPressure2.ConditionParameter.ActualName = "TerminateSelectionPressure";
terminatedIslandsCounter.Name = "TerminatedIslands + 1";
terminatedIslandsCounter.ValueParameter.ActualName = "TerminatedIslands";
terminatedIslandsCounter.Increment = new IntValue(1);
generationsCounter.Name = "Generations + 1";
generationsCounter.ValueParameter.ActualName = "Generations";
generationsCounter.Increment = new IntValue(1);
generationsSinceLastMigrationCounter.Name = "GenerationsSinceLastMigration + 1";
generationsSinceLastMigrationCounter.ValueParameter.ActualName = "GenerationsSinceLastMigration";
generationsSinceLastMigrationCounter.Increment = new IntValue(1);
migrationComparator.Name = "GenerationsSinceLastMigration = MigrationInterval ?";
migrationComparator.LeftSideParameter.ActualName = "GenerationsSinceLastMigration";
migrationComparator.Comparison = new Comparison(ComparisonType.Equal);
migrationComparator.RightSideParameter.ActualName = MigrationIntervalParameter.Name;
migrationComparator.ResultParameter.ActualName = "Migrate";
migrationBranch.Name = "Migrate?";
migrationBranch.ConditionParameter.ActualName = "Migrate";
resetTerminatedIslandsAssigner.Name = "Reset TerminatedIslands";
resetTerminatedIslandsAssigner.LeftSideParameter.ActualName = "TerminatedIslands";
resetTerminatedIslandsAssigner.RightSideParameter.Value = new IntValue(0);
resetGenerationsSinceLastMigrationAssigner.Name = "Reset GenerationsSinceLastMigration";
resetGenerationsSinceLastMigrationAssigner.LeftSideParameter.ActualName = "GenerationsSinceLastMigration";
resetGenerationsSinceLastMigrationAssigner.RightSideParameter.Value = new IntValue(0);
migrationsCounter.Name = "Migrations + 1";
migrationsCounter.IncrementParameter.Value = new IntValue(1);
migrationsCounter.ValueParameter.ActualName = "Migrations";
reviveIslandAssigner.Name = "Revive Island";
reviveIslandAssigner.LeftSideParameter.ActualName = "TerminateSelectionPressure";
reviveIslandAssigner.RightSideParameter.Value = new BoolValue(false);
emigrantsSelector.Name = "Emigrants Selector (placeholder)";
emigrantsSelector.OperatorParameter.ActualName = EmigrantsSelectorParameter.Name;
migrator.Name = "Migrator (placeholder)";
migrator.OperatorParameter.ActualName = MigratorParameter.Name;
immigrationReplacer.Name = "Immigration Replacer (placeholder)";
immigrationReplacer.OperatorParameter.ActualName = ImmigrationReplacerParameter.Name;
generationsComparator.Name = "Generations >= MaximumGenerations ?";
generationsComparator.LeftSideParameter.ActualName = "Generations";
generationsComparator.Comparison = new Comparison(ComparisonType.GreaterOrEqual);
generationsComparator.RightSideParameter.ActualName = MaximumGenerationsParameter.Name;
generationsComparator.ResultParameter.ActualName = "TerminateGenerations";
terminatedIslandsComparator.Name = "All Islands terminated ?";
terminatedIslandsComparator.LeftSideParameter.ActualName = "TerminatedIslands";
terminatedIslandsComparator.Comparison = new Comparison(ComparisonType.GreaterOrEqual);
terminatedIslandsComparator.RightSideParameter.ActualName = NumberOfIslandsParameter.Name;
terminatedIslandsComparator.ResultParameter.ActualName = "TerminateTerminatedIslands";
maxEvaluatedSolutionsComparator.Name = "EvaluatedSolutions >= MaximumEvaluatedSolutions ?";
maxEvaluatedSolutionsComparator.Comparison = new Comparison(ComparisonType.GreaterOrEqual);
maxEvaluatedSolutionsComparator.LeftSideParameter.ActualName = EvaluatedSolutionsParameter.Name;
maxEvaluatedSolutionsComparator.ResultParameter.ActualName = "TerminateEvaluatedSolutions";
maxEvaluatedSolutionsComparator.RightSideParameter.ActualName = "MaximumEvaluatedSolutions";
comparisonFactorModifier.Name = "Update Comparison Factor (Placeholder)";
comparisonFactorModifier.OperatorParameter.ActualName = ComparisonFactorModifierParameter.Name;
analyzer2.Name = "Analyzer (placeholder)";
analyzer2.OperatorParameter.ActualName = AnalyzerParameter.Name;
generationsTerminationCondition.Name = "Terminate (MaxGenerations) ?";
generationsTerminationCondition.ConditionParameter.ActualName = "TerminateGenerations";
terminatedIslandsCondition.Name = "Terminate (TerminatedIslands) ?";
terminatedIslandsCondition.ConditionParameter.ActualName = "TerminateTerminatedIslands";
evaluatedSolutionsTerminationCondition.Name = "Terminate (EvaluatedSolutions) ?";
evaluatedSolutionsTerminationCondition.ConditionParameter.ActualName = "TerminateEvaluatedSolutions";
#endregion
#region Create operator graph
OperatorGraph.InitialOperator = variableCreator;
variableCreator.Successor = uniformSubScopesProcessor0;
uniformSubScopesProcessor0.Operator = islandVariableCreator;
uniformSubScopesProcessor0.Successor = comparisonFactorInitializer;
islandVariableCreator.Successor = islandAnalyzer1;
islandAnalyzer1.Successor = islandResultsCollector1;
islandResultsCollector1.Successor = null;
comparisonFactorInitializer.Successor = analyzer1;
analyzer1.Successor = resultsCollector1;
resultsCollector1.Successor = uniformSubScopesProcessor1;
uniformSubScopesProcessor1.Operator = islandTerminatedBySelectionPressure1;
uniformSubScopesProcessor1.Successor = generationsCounter;
islandTerminatedBySelectionPressure1.TrueBranch = null;
islandTerminatedBySelectionPressure1.FalseBranch = mainOperator;
islandTerminatedBySelectionPressure1.Successor = null;
mainOperator.Successor = islandAnalyzer2;
islandAnalyzer2.Successor = islandResultsCollector2;
islandResultsCollector2.Successor = islandSelectionPressureComparator;
islandSelectionPressureComparator.Successor = islandTerminatedBySelectionPressure2;
islandTerminatedBySelectionPressure2.TrueBranch = terminatedIslandsCounter;
islandTerminatedBySelectionPressure2.FalseBranch = null;
islandTerminatedBySelectionPressure2.Successor = null;
generationsCounter.Successor = generationsSinceLastMigrationCounter;
generationsSinceLastMigrationCounter.Successor = migrationComparator;
migrationComparator.Successor = migrationBranch;
migrationBranch.TrueBranch = resetTerminatedIslandsAssigner;
migrationBranch.FalseBranch = null;
migrationBranch.Successor = generationsComparator;
resetTerminatedIslandsAssigner.Successor = resetGenerationsSinceLastMigrationAssigner;
resetGenerationsSinceLastMigrationAssigner.Successor = migrationsCounter;
migrationsCounter.Successor = uniformSubScopesProcessor2;
uniformSubScopesProcessor2.Operator = reviveIslandAssigner;
uniformSubScopesProcessor2.Successor = migrator;
reviveIslandAssigner.Successor = emigrantsSelector;
emigrantsSelector.Successor = null;
migrator.Successor = uniformSubScopesProcessor3;
uniformSubScopesProcessor3.Operator = immigrationReplacer;
uniformSubScopesProcessor3.Successor = null;
immigrationReplacer.Successor = null;
generationsComparator.Successor = terminatedIslandsComparator;
terminatedIslandsComparator.Successor = maxEvaluatedSolutionsComparator;
maxEvaluatedSolutionsComparator.Successor = comparisonFactorModifier;
comparisonFactorModifier.Successor = analyzer2;
analyzer2.Successor = generationsTerminationCondition;
generationsTerminationCondition.TrueBranch = null;
generationsTerminationCondition.FalseBranch = terminatedIslandsCondition;
generationsTerminationCondition.Successor = null;
terminatedIslandsCondition.TrueBranch = null;
terminatedIslandsCondition.FalseBranch = evaluatedSolutionsTerminationCondition;
terminatedIslandsCondition.Successor = null;
evaluatedSolutionsTerminationCondition.TrueBranch = null;
evaluatedSolutionsTerminationCondition.FalseBranch = uniformSubScopesProcessor1;
evaluatedSolutionsTerminationCondition.Successor = null;
#endregion
}
public IslandGeneticAlgorithmMainLoop()
: base() {
#region Create parameters
Parameters.Add(new ValueLookupParameter<IRandom>("Random", "A pseudo random number generator."));
Parameters.Add(new ValueLookupParameter<BoolValue>("Maximization", "True if the problem is a maximization problem, otherwise false."));
Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("Quality", "The value which represents the quality of a solution."));
Parameters.Add(new ValueLookupParameter<DoubleValue>("BestKnownQuality", "The best known quality value found so far."));
Parameters.Add(new ValueLookupParameter<IntValue>("NumberOfIslands", "The number of islands."));
Parameters.Add(new ValueLookupParameter<IntValue>("MigrationInterval", "The number of generations that should pass between migration phases."));
Parameters.Add(new ValueLookupParameter<PercentValue>("MigrationRate", "The proportion of individuals that should migrate between the islands."));
Parameters.Add(new ValueLookupParameter<IOperator>("Migrator", "The migration strategy."));
Parameters.Add(new ValueLookupParameter<IOperator>("EmigrantsSelector", "Selects the individuals that will be migrated."));
Parameters.Add(new ValueLookupParameter<IOperator>("ImmigrationReplacer", "Replaces some of the original population with the immigrants."));
Parameters.Add(new ValueLookupParameter<IntValue>("PopulationSize", "The size of the population of solutions."));
Parameters.Add(new ValueLookupParameter<IntValue>("MaximumGenerations", "The maximum number of generations that the algorithm should process."));
Parameters.Add(new ValueLookupParameter<IOperator>("Selector", "The operator used to select solutions for reproduction."));
Parameters.Add(new ValueLookupParameter<IOperator>("Crossover", "The operator used to cross solutions."));
Parameters.Add(new ValueLookupParameter<PercentValue>("MutationProbability", "The probability that the mutation operator is applied on a solution."));
Parameters.Add(new ValueLookupParameter<IOperator>("Mutator", "The operator used to mutate solutions."));
Parameters.Add(new ValueLookupParameter<IOperator>("Evaluator", "The operator used to evaluate solutions."));
Parameters.Add(new ValueLookupParameter<IntValue>("Elites", "The numer of elite solutions which are kept in each generation."));
Parameters.Add(new ValueLookupParameter<BoolValue>("ReevaluateElites", "Flag to determine if elite individuals should be reevaluated (i.e., if stochastic fitness functions are used.)"));
Parameters.Add(new ValueLookupParameter<ResultCollection>("Results", "The results collection to store the results."));
Parameters.Add(new ValueLookupParameter<IOperator>("Analyzer", "The operator used to the analyze the islands."));
Parameters.Add(new ValueLookupParameter<IOperator>("IslandAnalyzer", "The operator used to analyze each island."));
Parameters.Add(new LookupParameter<IntValue>("EvaluatedSolutions", "The number of times a solution has been evaluated."));
Parameters.Add(new LookupParameter<IntValue>("IslandGenerations", "The number of generations calculated on one island."));
Parameters.Add(new LookupParameter<IntValue>("IslandEvaluatedSolutions", "The number of times a solution has been evaluated on one island."));
Parameters.Add(new ValueLookupParameter<BoolValue>("Migrate", "Migrate the island?"));
#endregion
#region Create operators
VariableCreator variableCreator = new VariableCreator();
UniformSubScopesProcessor uniformSubScopesProcessor0 = new UniformSubScopesProcessor();
VariableCreator islandVariableCreator = new VariableCreator();
Placeholder islandAnalyzer1 = new Placeholder();
LocalRandomCreator localRandomCreator = new LocalRandomCreator();
Placeholder analyzer1 = new Placeholder();
ResultsCollector resultsCollector1 = new ResultsCollector();
UniformSubScopesProcessor uniformSubScopesProcessor1 = new UniformSubScopesProcessor();
Assigner generationsAssigner = new Assigner();
Assigner evaluatedSolutionsAssigner = new Assigner();
Placeholder selector = new Placeholder();
SubScopesProcessor subScopesProcessor1 = new SubScopesProcessor();
ChildrenCreator childrenCreator = new ChildrenCreator();
UniformSubScopesProcessor uniformSubScopesProcessor2 = new UniformSubScopesProcessor();
Placeholder crossover = new Placeholder();
StochasticBranch stochasticBranch = new StochasticBranch();
Placeholder mutator = new Placeholder();
SubScopesRemover subScopesRemover = new SubScopesRemover();
UniformSubScopesProcessor uniformSubScopesProcessor3 = new UniformSubScopesProcessor();
Placeholder evaluator = new Placeholder();
SubScopesCounter subScopesCounter = new SubScopesCounter();
SubScopesProcessor subScopesProcessor2 = new SubScopesProcessor();
BestSelector bestSelector = new BestSelector();
RightReducer rightReducer = new RightReducer();
MergingReducer mergingReducer = new MergingReducer();
IntCounter islandGenerationsCounter = new IntCounter();
Comparator checkIslandGenerationsReachedMaximum = new Comparator();
ConditionalBranch checkContinueEvolution = new ConditionalBranch();
DataReducer generationsReducer = new DataReducer();
DataReducer evaluatedSolutionsReducer = new DataReducer();
Placeholder islandAnalyzer2 = new Placeholder();
UniformSubScopesProcessor uniformSubScopesProcessor5 = new UniformSubScopesProcessor();
Placeholder emigrantsSelector = new Placeholder();
IntCounter migrationsCounter = new IntCounter();
Placeholder migrator = new Placeholder();
UniformSubScopesProcessor uniformSubScopesProcessor6 = new UniformSubScopesProcessor();
Placeholder immigrationReplacer = new Placeholder();
Comparator generationsComparator = new Comparator();
Placeholder analyzer2 = new Placeholder();
ConditionalBranch generationsTerminationCondition = new ConditionalBranch();
ConditionalBranch reevaluateElitesBranch = new ConditionalBranch();
variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("Migrations", new IntValue(0)));
variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("GenerationsSinceLastMigration", new IntValue(0)));
variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("Generations", new IntValue(0))); // Class IslandGeneticAlgorithm expects this to be called Generations
islandVariableCreator.CollectedValues.Add(new ValueParameter<ResultCollection>("Results", new ResultCollection()));
islandVariableCreator.CollectedValues.Add(new ValueParameter<IntValue>("IslandGenerations", new IntValue(0)));
islandVariableCreator.CollectedValues.Add(new ValueParameter<IntValue>("IslandEvaluatedSolutions", new IntValue(0)));
islandAnalyzer1.Name = "Island Analyzer (placeholder)";
islandAnalyzer1.OperatorParameter.ActualName = IslandAnalyzerParameter.Name;
analyzer1.Name = "Analyzer (placeholder)";
analyzer1.OperatorParameter.ActualName = AnalyzerParameter.Name;
resultsCollector1.CollectedValues.Add(new LookupParameter<IntValue>("Migrations"));
resultsCollector1.CollectedValues.Add(new LookupParameter<IntValue>("Generations"));
resultsCollector1.CollectedValues.Add(new ScopeTreeLookupParameter<ResultCollection>("IslandResults", "Result set for each island", "Results"));
resultsCollector1.ResultsParameter.ActualName = ResultsParameter.Name;
uniformSubScopesProcessor1.Parallel.Value = true;
generationsAssigner.Name = "Initialize Island Generations";
generationsAssigner.LeftSideParameter.ActualName = IslandGenerations.Name;
generationsAssigner.RightSideParameter.Value = new IntValue(0);
evaluatedSolutionsAssigner.Name = "Initialize Island evaluated solutions";
evaluatedSolutionsAssigner.LeftSideParameter.ActualName = IslandEvaluatedSolutions.Name;
evaluatedSolutionsAssigner.RightSideParameter.Value = new IntValue(0);
selector.Name = "Selector (placeholder)";
selector.OperatorParameter.ActualName = SelectorParameter.Name;
childrenCreator.ParentsPerChild = new IntValue(2);
crossover.Name = "Crossover (placeholder)";
crossover.OperatorParameter.ActualName = CrossoverParameter.Name;
stochasticBranch.ProbabilityParameter.ActualName = MutationProbabilityParameter.Name;
//set it to the random number generator of the island
stochasticBranch.RandomParameter.ActualName = "LocalRandom";
mutator.Name = "Mutator (placeholder)";
mutator.OperatorParameter.ActualName = MutatorParameter.Name;
subScopesRemover.RemoveAllSubScopes = true;
evaluator.Name = "Evaluator (placeholder)";
evaluator.OperatorParameter.ActualName = EvaluatorParameter.Name;
subScopesCounter.Name = "Increment EvaluatedSolutions";
subScopesCounter.ValueParameter.ActualName = IslandEvaluatedSolutions.Name;
bestSelector.CopySelected = new BoolValue(false);
bestSelector.MaximizationParameter.ActualName = MaximizationParameter.Name;
bestSelector.NumberOfSelectedSubScopesParameter.ActualName = ElitesParameter.Name;
bestSelector.QualityParameter.ActualName = QualityParameter.Name;
islandGenerationsCounter.Name = "Increment island generatrions";
islandGenerationsCounter.ValueParameter.ActualName = IslandGenerations.Name;
islandGenerationsCounter.Increment = new IntValue(1);
checkIslandGenerationsReachedMaximum.LeftSideParameter.ActualName = IslandGenerations.Name;
checkIslandGenerationsReachedMaximum.RightSideParameter.ActualName = MigrationIntervalParameter.Name;
checkIslandGenerationsReachedMaximum.Comparison = new Comparison(ComparisonType.GreaterOrEqual);
checkIslandGenerationsReachedMaximum.ResultParameter.ActualName = Migrate.Name;
checkContinueEvolution.Name = "Migrate?";
checkContinueEvolution.ConditionParameter.ActualName = Migrate.Name;
checkContinueEvolution.FalseBranch = selector;
islandAnalyzer2.Name = "Island Analyzer (placeholder)";
islandAnalyzer2.OperatorParameter.ActualName = IslandAnalyzerParameter.Name;
generationsReducer.Name = "Increment Generations";
generationsReducer.ParameterToReduce.ActualName = islandGenerationsCounter.ValueParameter.ActualName;
generationsReducer.TargetParameter.ActualName = "Generations";
generationsReducer.ReductionOperation.Value = new ReductionOperation(ReductionOperations.Min);
generationsReducer.TargetOperation.Value = new ReductionOperation(ReductionOperations.Sum);
evaluatedSolutionsReducer.Name = "Increment Evaluated Solutions";
evaluatedSolutionsReducer.ParameterToReduce.ActualName = IslandEvaluatedSolutions.Name;
evaluatedSolutionsReducer.TargetParameter.ActualName = EvaluatedSolutionsParameter.Name;
evaluatedSolutionsReducer.ReductionOperation.Value = new ReductionOperation(ReductionOperations.Sum);
evaluatedSolutionsReducer.TargetOperation.Value = new ReductionOperation(ReductionOperations.Sum);
emigrantsSelector.Name = "Emigrants Selector (placeholder)";
emigrantsSelector.OperatorParameter.ActualName = EmigrantsSelectorParameter.Name;
migrationsCounter.Name = "Increment number of Migrations";
migrationsCounter.ValueParameter.ActualName = "Migrations";
migrationsCounter.Increment = new IntValue(1);
migrator.Name = "Migrator (placeholder)";
migrator.OperatorParameter.ActualName = MigratorParameter.Name;
immigrationReplacer.Name = "Immigration Replacer (placeholder)";
immigrationReplacer.OperatorParameter.ActualName = ImmigrationReplacerParameter.Name;
generationsComparator.Name = "Generations >= MaximumGenerations ?";
generationsComparator.Comparison = new Comparison(ComparisonType.GreaterOrEqual);
generationsComparator.LeftSideParameter.ActualName = "Generations";
generationsComparator.ResultParameter.ActualName = "TerminateGenerations";
generationsComparator.RightSideParameter.ActualName = MaximumGenerationsParameter.Name;
analyzer2.Name = "Analyzer (placeholder)";
analyzer2.OperatorParameter.ActualName = AnalyzerParameter.Name;
generationsTerminationCondition.Name = "Terminate?";
generationsTerminationCondition.ConditionParameter.ActualName = "TerminateGenerations";
reevaluateElitesBranch.ConditionParameter.ActualName = "ReevaluateElites";
reevaluateElitesBranch.Name = "Reevaluate elites ?";
#endregion
#region Create operator graph
OperatorGraph.InitialOperator = variableCreator;
variableCreator.Successor = uniformSubScopesProcessor0;
uniformSubScopesProcessor0.Operator = islandVariableCreator;
uniformSubScopesProcessor0.Successor = analyzer1;
islandVariableCreator.Successor = islandAnalyzer1;
// BackwardsCompatibility3.3
//the local randoms are created by the island GA itself and are only here to ensure same algorithm results
#region Backwards compatible code, remove local random creator with 3.4 and rewire the operator graph
islandAnalyzer1.Successor = localRandomCreator;
localRandomCreator.Successor = null;
#endregion
analyzer1.Successor = resultsCollector1;
resultsCollector1.Successor = uniformSubScopesProcessor1;
uniformSubScopesProcessor1.Operator = generationsAssigner;
uniformSubScopesProcessor1.Successor = generationsReducer;
generationsReducer.Successor = evaluatedSolutionsReducer;
evaluatedSolutionsReducer.Successor = migrationsCounter;
migrationsCounter.Successor = uniformSubScopesProcessor5;
generationsAssigner.Successor = evaluatedSolutionsAssigner;
evaluatedSolutionsAssigner.Successor = selector;
selector.Successor = subScopesProcessor1;
subScopesProcessor1.Operators.Add(new EmptyOperator());
subScopesProcessor1.Operators.Add(childrenCreator);
subScopesProcessor1.Successor = subScopesProcessor2;
childrenCreator.Successor = uniformSubScopesProcessor2;
uniformSubScopesProcessor2.Operator = crossover;
uniformSubScopesProcessor2.Successor = uniformSubScopesProcessor3;
crossover.Successor = stochasticBranch;
stochasticBranch.FirstBranch = mutator;
stochasticBranch.SecondBranch = null;
stochasticBranch.Successor = subScopesRemover;
mutator.Successor = null;
subScopesRemover.Successor = null;
uniformSubScopesProcessor3.Operator = evaluator;
uniformSubScopesProcessor3.Successor = subScopesCounter;
evaluator.Successor = null;
subScopesCounter.Successor = null;
subScopesProcessor2.Operators.Add(bestSelector);
subScopesProcessor2.Operators.Add(new EmptyOperator());
subScopesProcessor2.Successor = mergingReducer;
mergingReducer.Successor = islandAnalyzer2;
bestSelector.Successor = rightReducer;
rightReducer.Successor = reevaluateElitesBranch;
reevaluateElitesBranch.TrueBranch = uniformSubScopesProcessor3;
reevaluateElitesBranch.FalseBranch = null;
reevaluateElitesBranch.Successor = null;
islandAnalyzer2.Successor = islandGenerationsCounter;
islandGenerationsCounter.Successor = checkIslandGenerationsReachedMaximum;
checkIslandGenerationsReachedMaximum.Successor = checkContinueEvolution;
uniformSubScopesProcessor5.Operator = emigrantsSelector;
emigrantsSelector.Successor = null;
uniformSubScopesProcessor5.Successor = migrator;
migrator.Successor = uniformSubScopesProcessor6;
uniformSubScopesProcessor6.Operator = immigrationReplacer;
uniformSubScopesProcessor6.Successor = generationsComparator;
generationsComparator.Successor = analyzer2;
analyzer2.Successor = generationsTerminationCondition;
generationsTerminationCondition.TrueBranch = null;
generationsTerminationCondition.FalseBranch = uniformSubScopesProcessor1;
generationsTerminationCondition.Successor = null;
#endregion
}
private void Initialize() {
#region Create parameters
Parameters.Add(new ValueLookupParameter<IRandom>("Random", "A pseudo random number generator."));
Parameters.Add(new ValueLookupParameter<BoolValue>("Maximization", "True if the problem is a maximization problem, otherwise false."));
Parameters.Add(new LookupParameter<DoubleValue>("Quality", "The value which represents the quality of a solution."));
Parameters.Add(new ValueLookupParameter<DoubleValue>("BestKnownQuality", "The best known quality value found so far."));
Parameters.Add(new LookupParameter<DoubleValue>("MoveQuality", "The value which represents the quality of a move."));
Parameters.Add(new LookupParameter<DoubleValue>("Temperature", "The current temperature."));
Parameters.Add(new ValueLookupParameter<DoubleValue>("StartTemperature", "The initial temperature."));
Parameters.Add(new ValueLookupParameter<DoubleValue>("EndTemperature", "The end temperature."));
Parameters.Add(new ValueLookupParameter<IntValue>("InnerIterations", "The amount of inner iterations (number of moves before temperature is adjusted again)."));
Parameters.Add(new LookupParameter<IntValue>("Iterations", "The number of iterations."));
Parameters.Add(new ValueLookupParameter<IntValue>("MaximumIterations", "The maximum number of iterations which should be processed."));
Parameters.Add(new ValueLookupParameter<IOperator>("MoveGenerator", "The operator that generates the moves."));
Parameters.Add(new ValueLookupParameter<IOperator>("MoveEvaluator", "The operator that evaluates a move."));
Parameters.Add(new ValueLookupParameter<IOperator>("MoveMaker", "The operator that performs a move and updates the quality."));
Parameters.Add(new ValueLookupParameter<IOperator>("AnnealingOperator", "The operator that modifies the temperature."));
Parameters.Add(new ValueLookupParameter<IOperator>("Analyzer", "The operator used to analyze each generation."));
Parameters.Add(new ValueLookupParameter<VariableCollection>("Results", "The variable collection where results should be stored."));
Parameters.Add(new LookupParameter<IntValue>("EvaluatedMoves", "The number of evaluated moves."));
#endregion
#region Create operators
Assigner temperatureInitializer = new Assigner();
ResultsCollector resultsCollector1 = new ResultsCollector();
SubScopesProcessor subScopesProcessor0 = new SubScopesProcessor();
Placeholder analyzer1 = new Placeholder();
SubScopesProcessor sssp = new SubScopesProcessor();
ResultsCollector resultsCollector = new ResultsCollector();
Placeholder annealingOperator = new Placeholder();
UniformSubScopesProcessor mainProcessor = new UniformSubScopesProcessor();
Placeholder moveGenerator = new Placeholder();
UniformSubScopesProcessor moveEvaluationProcessor = new UniformSubScopesProcessor();
Placeholder moveEvaluator = new Placeholder();
SubScopesCounter subScopesCounter = new SubScopesCounter();
ProbabilisticQualityComparator qualityComparator = new ProbabilisticQualityComparator();
ConditionalBranch improvesQualityBranch = new ConditionalBranch();
Placeholder moveMaker = new Placeholder();
SubScopesRemover subScopesRemover = new SubScopesRemover();
IntCounter iterationsCounter = new IntCounter();
Comparator iterationsComparator = new Comparator();
SubScopesProcessor subScopesProcessor1 = new SubScopesProcessor();
Placeholder analyzer2 = new Placeholder();
ConditionalBranch iterationsTermination = new ConditionalBranch();
temperatureInitializer.LeftSideParameter.ActualName = TemperatureParameter.ActualName;
temperatureInitializer.RightSideParameter.ActualName = StartTemperatureParameter.Name;
resultsCollector1.CollectedValues.Add(new LookupParameter<IntValue>(IterationsParameter.Name));
resultsCollector1.ResultsParameter.ActualName = ResultsParameter.Name;
analyzer1.Name = "Analyzer (placeholder)";
analyzer1.OperatorParameter.ActualName = AnalyzerParameter.Name;
annealingOperator.Name = "Annealing operator (placeholder)";
annealingOperator.OperatorParameter.ActualName = AnnealingOperatorParameter.Name;
moveGenerator.Name = "Move generator (placeholder)";
moveGenerator.OperatorParameter.ActualName = MoveGeneratorParameter.Name;
moveEvaluator.Name = "Move evaluator (placeholder)";
moveEvaluator.OperatorParameter.ActualName = MoveEvaluatorParameter.Name;
subScopesCounter.Name = "Increment EvaluatedMoves";
subScopesCounter.ValueParameter.ActualName = EvaluatedMovesParameter.Name;
qualityComparator.LeftSideParameter.ActualName = MoveQualityParameter.Name;
qualityComparator.RightSideParameter.ActualName = QualityParameter.Name;
qualityComparator.ResultParameter.ActualName = "IsBetter";
qualityComparator.DampeningParameter.ActualName = "Temperature";
improvesQualityBranch.ConditionParameter.ActualName = "IsBetter";
moveMaker.Name = "Move maker (placeholder)";
moveMaker.OperatorParameter.ActualName = MoveMakerParameter.Name;
subScopesRemover.RemoveAllSubScopes = true;
iterationsCounter.Name = "Increment Iterations";
iterationsCounter.Increment = new IntValue(1);
iterationsCounter.ValueParameter.ActualName = IterationsParameter.Name;
iterationsComparator.Name = "Iterations >= MaximumIterations";
iterationsComparator.LeftSideParameter.ActualName = IterationsParameter.Name;
iterationsComparator.RightSideParameter.ActualName = MaximumIterationsParameter.Name;
iterationsComparator.ResultParameter.ActualName = "Terminate";
iterationsComparator.Comparison.Value = ComparisonType.GreaterOrEqual;
analyzer2.Name = "Analyzer (placeholder)";
analyzer2.OperatorParameter.ActualName = AnalyzerParameter.Name;
iterationsTermination.Name = "Iterations termination condition";
iterationsTermination.ConditionParameter.ActualName = "Terminate";
#endregion
#region Create operator graph
OperatorGraph.InitialOperator = temperatureInitializer;
temperatureInitializer.Successor = resultsCollector1;
resultsCollector1.Successor = subScopesProcessor0;
subScopesProcessor0.Operators.Add(analyzer1);
subScopesProcessor0.Successor = sssp;
analyzer1.Successor = null;
sssp.Operators.Add(resultsCollector);
sssp.Successor = annealingOperator;
resultsCollector.Successor = null;
annealingOperator.Successor = mainProcessor;
mainProcessor.Operator = moveGenerator;
mainProcessor.Successor = iterationsCounter;
moveGenerator.Successor = moveEvaluationProcessor;
moveEvaluationProcessor.Operator = moveEvaluator;
moveEvaluationProcessor.Successor = subScopesCounter;
moveEvaluator.Successor = qualityComparator;
qualityComparator.Successor = improvesQualityBranch;
improvesQualityBranch.TrueBranch = moveMaker;
improvesQualityBranch.FalseBranch = null;
improvesQualityBranch.Successor = null;
moveMaker.Successor = null;
subScopesCounter.Successor = subScopesRemover;
subScopesRemover.Successor = null;
iterationsCounter.Successor = iterationsComparator;
iterationsComparator.Successor = subScopesProcessor1;
subScopesProcessor1.Operators.Add(analyzer2);
subScopesProcessor1.Successor = iterationsTermination;
iterationsTermination.TrueBranch = null;
iterationsTermination.FalseBranch = annealingOperator;
#endregion
}
private Assigner(Assigner original, Cloner cloner)
: base(original, cloner) {
}
private void Initialize() {
#region Create parameters
Parameters.Add(new ValueLookupParameter<IRandom>("Random", "A pseudo random number generator."));
Parameters.Add(new ValueLookupParameter<BoolValue>("Maximization", "True if the problem is a maximization problem, otherwise false."));
Parameters.Add(new LookupParameter<DoubleValue>("Quality", "The value which represents the quality of a solution."));
Parameters.Add(new ValueLookupParameter<DoubleValue>("BestKnownQuality", "The best known quality value found so far."));
Parameters.Add(new LookupParameter<DoubleValue>("MoveQuality", "The value which represents the quality of a move."));
Parameters.Add(new LookupParameter<BoolValue>("MoveTabu", "The value that indicates if a move is tabu or not."));
Parameters.Add(new ValueLookupParameter<IntValue>("MaximumIterations", "The maximum number of generations which should be processed."));
Parameters.Add(new ValueLookupParameter<IntValue>("TabuTenure", "The length of the tabu list, and also means the number of iterations a move is kept tabu"));
Parameters.Add(new ValueLookupParameter<IOperator>("MoveGenerator", "The operator that generates the moves."));
Parameters.Add(new ValueLookupParameter<IOperator>("MoveMaker", "The operator that performs a move and updates the quality."));
Parameters.Add(new ValueLookupParameter<IOperator>("MoveEvaluator", "The operator that evaluates a move."));
Parameters.Add(new ValueLookupParameter<IOperator>("TabuChecker", "The operator that checks whether a move is tabu."));
Parameters.Add(new ValueLookupParameter<IOperator>("TabuMaker", "The operator that declares a move tabu."));
Parameters.Add(new ValueLookupParameter<IOperator>("Analyzer", "The operator used to analyze the solution and moves."));
Parameters.Add(new ValueLookupParameter<VariableCollection>("Results", "The variable collection where results should be stored."));
Parameters.Add(new LookupParameter<IntValue>("EvaluatedMoves", "The number of evaluated moves."));
#endregion
#region Create operators
VariableCreator variableCreator = new VariableCreator();
SubScopesProcessor subScopesProcessor0 = new SubScopesProcessor();
Assigner bestQualityInitializer = new Assigner();
Placeholder analyzer1 = new Placeholder();
ResultsCollector resultsCollector1 = new ResultsCollector();
SubScopesProcessor solutionProcessor = new SubScopesProcessor();
Placeholder moveGenerator = new Placeholder();
UniformSubScopesProcessor moveEvaluationProcessor = new UniformSubScopesProcessor();
Placeholder moveEvaluator = new Placeholder();
Placeholder tabuChecker = new Placeholder();
SubScopesCounter subScopesCounter = new SubScopesCounter();
SubScopesSorter moveQualitySorter = new SubScopesSorter();
TabuSelector tabuSelector = new TabuSelector();
ConditionalBranch emptyNeighborhoodBranch1 = new ConditionalBranch();
SubScopesProcessor moveMakingProcessor = new SubScopesProcessor();
UniformSubScopesProcessor selectedMoveMakingProcesor = new UniformSubScopesProcessor();
Placeholder tabuMaker = new Placeholder();
Placeholder moveMaker = new Placeholder();
MergingReducer mergingReducer = new MergingReducer();
Placeholder analyzer2 = new Placeholder();
SubScopesRemover subScopesRemover = new SubScopesRemover();
ConditionalBranch emptyNeighborhoodBranch2 = new ConditionalBranch();
BestQualityMemorizer bestQualityUpdater = new BestQualityMemorizer();
IntCounter iterationsCounter = new IntCounter();
Comparator iterationsComparator = new Comparator();
ConditionalBranch iterationsTermination = new ConditionalBranch();
variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("Iterations", new IntValue(0))); // Class TabuSearch expects this to be called Iterations
variableCreator.CollectedValues.Add(new ValueParameter<BoolValue>("EmptyNeighborhood", new BoolValue(false)));
variableCreator.CollectedValues.Add(new ValueParameter<ItemList<IItem>>("TabuList", new ItemList<IItem>()));
variableCreator.CollectedValues.Add(new ValueParameter<VariableCollection>("Memories", new VariableCollection()));
variableCreator.CollectedValues.Add(new ValueParameter<DoubleValue>("BestQuality", new DoubleValue(0)));
bestQualityInitializer.Name = "Initialize BestQuality";
bestQualityInitializer.LeftSideParameter.ActualName = "BestQuality";
bestQualityInitializer.RightSideParameter.ActualName = QualityParameter.Name;
analyzer1.Name = "Analyzer (placeholder)";
analyzer1.OperatorParameter.ActualName = AnalyzerParameter.Name;
resultsCollector1.CopyValue = new BoolValue(false);
resultsCollector1.CollectedValues.Add(new LookupParameter<IntValue>("Iterations"));
resultsCollector1.CollectedValues.Add(new LookupParameter<DoubleValue>("Best Quality", null, "BestQuality"));
resultsCollector1.ResultsParameter.ActualName = ResultsParameter.Name;
moveGenerator.Name = "MoveGenerator (placeholder)";
moveGenerator.OperatorParameter.ActualName = MoveGeneratorParameter.Name;
moveEvaluationProcessor.Parallel = new BoolValue(true);
moveEvaluator.Name = "MoveEvaluator (placeholder)";
moveEvaluator.OperatorParameter.ActualName = MoveEvaluatorParameter.Name;
tabuChecker.Name = "TabuChecker (placeholder)";
tabuChecker.OperatorParameter.ActualName = TabuCheckerParameter.Name;
subScopesCounter.Name = "Increment EvaluatedMoves";
subScopesCounter.ValueParameter.ActualName = EvaluatedMovesParameter.Name;
moveQualitySorter.DescendingParameter.ActualName = MaximizationParameter.Name;
moveQualitySorter.ValueParameter.ActualName = MoveQualityParameter.Name;
tabuSelector.AspirationParameter.Value = new BoolValue(true);
tabuSelector.BestQualityParameter.ActualName = "BestQuality";
tabuSelector.CopySelected = new BoolValue(false);
tabuSelector.EmptyNeighborhoodParameter.ActualName = "EmptyNeighborhood";
tabuSelector.MaximizationParameter.ActualName = MaximizationParameter.Name;
tabuSelector.MoveQualityParameter.ActualName = MoveQualityParameter.Name;
tabuSelector.MoveTabuParameter.ActualName = MoveTabuParameter.Name;
moveMakingProcessor.Name = "MoveMaking processor (UniformSubScopesProcessor)";
emptyNeighborhoodBranch1.Name = "Neighborhood empty?";
emptyNeighborhoodBranch1.ConditionParameter.ActualName = "EmptyNeighborhood";
tabuMaker.Name = "TabuMaker (placeholder)";
tabuMaker.OperatorParameter.ActualName = TabuMakerParameter.Name;
moveMaker.Name = "MoveMaker (placeholder)";
moveMaker.OperatorParameter.ActualName = MoveMakerParameter.Name;
analyzer2.Name = "Analyzer (placeholder)";
analyzer2.OperatorParameter.ActualName = AnalyzerParameter.Name;
subScopesRemover.RemoveAllSubScopes = true;
bestQualityUpdater.Name = "Update BestQuality";
bestQualityUpdater.MaximizationParameter.ActualName = MaximizationParameter.Name;
bestQualityUpdater.QualityParameter.ActualName = QualityParameter.Name;
bestQualityUpdater.BestQualityParameter.ActualName = "BestQuality";
iterationsCounter.Name = "Iterations Counter";
iterationsCounter.Increment = new IntValue(1);
iterationsCounter.ValueParameter.ActualName = "Iterations";
iterationsComparator.Name = "Iterations >= MaximumIterations";
iterationsComparator.Comparison = new Comparison(ComparisonType.GreaterOrEqual);
iterationsComparator.LeftSideParameter.ActualName = "Iterations";
iterationsComparator.RightSideParameter.ActualName = MaximumIterationsParameter.Name;
iterationsComparator.ResultParameter.ActualName = "Terminate";
emptyNeighborhoodBranch2.Name = "Neighborhood empty?";
emptyNeighborhoodBranch2.ConditionParameter.ActualName = "EmptyNeighborhood";
iterationsTermination.Name = "Iterations Termination Condition";
iterationsTermination.ConditionParameter.ActualName = "Terminate";
#endregion
#region Create operator graph
OperatorGraph.InitialOperator = variableCreator;
variableCreator.Successor = subScopesProcessor0;
subScopesProcessor0.Operators.Add(bestQualityInitializer);
subScopesProcessor0.Successor = resultsCollector1;
bestQualityInitializer.Successor = analyzer1;
analyzer1.Successor = null;
resultsCollector1.Successor = solutionProcessor;
solutionProcessor.Operators.Add(moveGenerator);
solutionProcessor.Successor = iterationsCounter;
moveGenerator.Successor = moveEvaluationProcessor;
moveEvaluationProcessor.Operator = moveEvaluator;
moveEvaluationProcessor.Successor = subScopesCounter;
moveEvaluator.Successor = tabuChecker;
tabuChecker.Successor = null;
subScopesCounter.Successor = moveQualitySorter;
moveQualitySorter.Successor = tabuSelector;
tabuSelector.Successor = emptyNeighborhoodBranch1;
emptyNeighborhoodBranch1.FalseBranch = moveMakingProcessor;
emptyNeighborhoodBranch1.TrueBranch = null;
emptyNeighborhoodBranch1.Successor = subScopesRemover;
moveMakingProcessor.Operators.Add(new EmptyOperator());
moveMakingProcessor.Operators.Add(selectedMoveMakingProcesor);
moveMakingProcessor.Successor = mergingReducer;
selectedMoveMakingProcesor.Operator = tabuMaker;
selectedMoveMakingProcesor.Successor = null;
tabuMaker.Successor = moveMaker;
moveMaker.Successor = null;
mergingReducer.Successor = analyzer2;
analyzer2.Successor = null;
subScopesRemover.Successor = null;
iterationsCounter.Successor = iterationsComparator;
iterationsComparator.Successor = emptyNeighborhoodBranch2;
emptyNeighborhoodBranch2.TrueBranch = null;
emptyNeighborhoodBranch2.FalseBranch = iterationsTermination;
emptyNeighborhoodBranch2.Successor = null;
iterationsTermination.TrueBranch = null;
iterationsTermination.FalseBranch = solutionProcessor;
#endregion
}
private void Initialize() {
#region Create parameters
Parameters.Add(new ValueLookupParameter<IRandom>("Random", "A pseudo random number generator."));
Parameters.Add(new ValueLookupParameter<BoolValue>("Maximization", "True if the problem is a maximization problem, otherwise false."));
Parameters.Add(new LookupParameter<DoubleValue>("Quality", "The value which represents the quality of a solution."));
Parameters.Add(new ValueLookupParameter<DoubleValue>("BestKnownQuality", "The best known quality value found so far."));
Parameters.Add(new ValueLookupParameter<IOperator>("Evaluator", "The operator used to evaluate solutions. This operator is executed in parallel, if an engine is used which supports parallelization."));
Parameters.Add(new LookupParameter<IntValue>("Iterations", "The iterations to count."));
Parameters.Add(new ValueLookupParameter<IntValue>("MaximumIterations", "The maximum number of generations which should be processed."));
Parameters.Add(new ValueLookupParameter<VariableCollection>("Results", "The variable collection where results should be stored."));
Parameters.Add(new ValueLookupParameter<IOperator>("Analyzer", "The operator used to analyze the solution."));
Parameters.Add(new LookupParameter<IntValue>("EvaluatedSolutions", "The number of evaluated solutions."));
Parameters.Add(new ValueLookupParameter<ILocalImprovementOperator>("LocalImprovement", "The local improvement operation."));
Parameters.Add(new ValueLookupParameter<IMultiNeighborhoodShakingOperator>("ShakingOperator", "The shaking operation."));
Parameters.Add(new LookupParameter<IntValue>("CurrentNeighborhoodIndex", "The index of the current shaking operation that should be applied."));
Parameters.Add(new LookupParameter<IntValue>("NeighborhoodCount", "The number of neighborhood operators used for shaking."));
#endregion
#region Create operators
VariableCreator variableCreator = new VariableCreator();
SubScopesProcessor subScopesProcessor0 = new SubScopesProcessor();
Assigner bestQualityInitializer = new Assigner();
Placeholder analyzer1 = new Placeholder();
ResultsCollector resultsCollector1 = new ResultsCollector();
CombinedOperator iteration = new CombinedOperator();
Assigner iterationInit = new Assigner();
SubScopesCloner createChild = new SubScopesCloner();
SubScopesProcessor childProcessor = new SubScopesProcessor();
Assigner qualityAssigner = new Assigner();
Placeholder shaking = new Placeholder();
Placeholder localImprovement = new Placeholder();
Placeholder evaluator = new Placeholder();
IntCounter evalCounter = new IntCounter();
QualityComparator qualityComparator = new QualityComparator();
ConditionalBranch improvesQualityBranch = new ConditionalBranch();
Assigner bestQualityUpdater = new Assigner();
BestSelector bestSelector = new BestSelector();
RightReducer rightReducer = new RightReducer();
IntCounter indexCounter = new IntCounter();
Assigner indexResetter = new Assigner();
Placeholder analyzer2 = new Placeholder();
Comparator indexComparator = new Comparator();
ConditionalBranch indexTermination = new ConditionalBranch();
IntCounter iterationsCounter = new IntCounter();
Comparator iterationsComparator = new Comparator();
ConditionalBranch iterationsTermination = new ConditionalBranch();
variableCreator.CollectedValues.Add(new ValueParameter<BoolValue>("IsBetter", new BoolValue(false)));
variableCreator.CollectedValues.Add(new ValueParameter<DoubleValue>("BestQuality", new DoubleValue(0)));
bestQualityInitializer.Name = "Initialize BestQuality";
bestQualityInitializer.LeftSideParameter.ActualName = "BestQuality";
bestQualityInitializer.RightSideParameter.ActualName = QualityParameter.Name;
analyzer1.Name = "Analyzer (placeholder)";
analyzer1.OperatorParameter.ActualName = AnalyzerParameter.Name;
resultsCollector1.CopyValue = new BoolValue(false);
resultsCollector1.CollectedValues.Add(new LookupParameter<DoubleValue>("Best Quality", null, "BestQuality"));
resultsCollector1.ResultsParameter.ActualName = ResultsParameter.Name;
iteration.Name = "MainLoop Body";
iterationInit.Name = "Init k = 0";
iterationInit.LeftSideParameter.ActualName = CurrentNeighborhoodIndexParameter.Name;
iterationInit.RightSideParameter.Value = new IntValue(0);
createChild.Name = "Clone solution";
qualityAssigner.Name = "Assign quality";
qualityAssigner.LeftSideParameter.ActualName = "OriginalQuality";
qualityAssigner.RightSideParameter.ActualName = QualityParameter.Name;
shaking.Name = "Shaking operator (placeholder)";
shaking.OperatorParameter.ActualName = ShakingOperatorParameter.Name;
localImprovement.Name = "Local improvement operator (placeholder)";
localImprovement.OperatorParameter.ActualName = LocalImprovementParameter.Name;
evaluator.Name = "Evaluation operator (placeholder)";
evaluator.OperatorParameter.ActualName = EvaluatorParameter.Name;
evalCounter.Name = "Count evaluations";
evalCounter.Increment.Value = 1;
evalCounter.ValueParameter.ActualName = EvaluatedSolutionsParameter.ActualName;
qualityComparator.LeftSideParameter.ActualName = QualityParameter.Name;
qualityComparator.RightSideParameter.ActualName = "OriginalQuality";
qualityComparator.ResultParameter.ActualName = "IsBetter";
improvesQualityBranch.ConditionParameter.ActualName = "IsBetter";
bestQualityUpdater.Name = "Update BestQuality";
bestQualityUpdater.LeftSideParameter.ActualName = "BestQuality";
bestQualityUpdater.RightSideParameter.ActualName = QualityParameter.Name;
bestSelector.CopySelected = new BoolValue(false);
bestSelector.MaximizationParameter.ActualName = MaximizationParameter.Name;
bestSelector.NumberOfSelectedSubScopesParameter.Value = new IntValue(1);
bestSelector.QualityParameter.ActualName = QualityParameter.Name;
indexCounter.Name = "Count neighborhood index";
indexCounter.Increment.Value = 1;
indexCounter.ValueParameter.ActualName = CurrentNeighborhoodIndexParameter.Name;
indexResetter.Name = "Reset neighborhood index";
indexResetter.LeftSideParameter.ActualName = CurrentNeighborhoodIndexParameter.Name;
indexResetter.RightSideParameter.Value = new IntValue(0);
analyzer2.Name = "Analyzer (placeholder)";
analyzer2.OperatorParameter.ActualName = AnalyzerParameter.Name;
iterationsCounter.Name = "Iterations Counter";
iterationsCounter.Increment = new IntValue(1);
iterationsCounter.ValueParameter.ActualName = IterationsParameter.Name;
iterationsComparator.Name = "Iterations >= MaximumIterations";
iterationsComparator.Comparison = new Comparison(ComparisonType.GreaterOrEqual);
iterationsComparator.LeftSideParameter.ActualName = IterationsParameter.Name;
iterationsComparator.RightSideParameter.ActualName = MaximumIterationsParameter.Name;
iterationsComparator.ResultParameter.ActualName = "Terminate";
iterationsTermination.Name = "Iterations Termination Condition";
iterationsTermination.ConditionParameter.ActualName = "Terminate";
indexComparator.Name = "k < k_max (index condition)";
indexComparator.LeftSideParameter.ActualName = CurrentNeighborhoodIndexParameter.Name;
indexComparator.RightSideParameter.ActualName = NeighborhoodCountParameter.Name;
indexComparator.Comparison = new Comparison(ComparisonType.Less);
indexComparator.ResultParameter.ActualName = "ContinueIteration";
indexTermination.Name = "Index Termination Condition";
indexTermination.ConditionParameter.ActualName = "ContinueIteration";
#endregion
#region Create operator graph
OperatorGraph.InitialOperator = variableCreator;
variableCreator.Successor = subScopesProcessor0;
subScopesProcessor0.Operators.Add(bestQualityInitializer);
subScopesProcessor0.Successor = analyzer1;
analyzer1.Successor = resultsCollector1;
/////////
resultsCollector1.Successor = iteration;
iteration.OperatorGraph.InitialOperator = iterationInit;
iteration.Successor = iterationsCounter;
iterationInit.Successor = createChild;
createChild.Successor = childProcessor;
childProcessor.Operators.Add(new EmptyOperator());
childProcessor.Operators.Add(qualityAssigner);
childProcessor.Successor = bestSelector;
/////////
qualityAssigner.Successor = shaking;
shaking.Successor = evaluator;
evaluator.Successor = evalCounter;
evalCounter.Successor = localImprovement;
localImprovement.Successor = qualityComparator;
qualityComparator.Successor = improvesQualityBranch;
improvesQualityBranch.TrueBranch = bestQualityUpdater;
improvesQualityBranch.FalseBranch = indexCounter;
bestQualityUpdater.Successor = indexResetter;
indexResetter.Successor = null;
indexCounter.Successor = null;
/////////
bestSelector.Successor = rightReducer;
rightReducer.Successor = analyzer2;
analyzer2.Successor = indexComparator;
indexComparator.Successor = indexTermination;
indexTermination.TrueBranch = createChild;
indexTermination.FalseBranch = null;
iterationsCounter.Successor = iterationsComparator;
iterationsComparator.Successor = iterationsTermination;
iterationsTermination.TrueBranch = null;
iterationsTermination.FalseBranch = iteration;
#endregion
}
private void Initialize() {
#region Create parameters
Parameters.Add(new ValueLookupParameter<IRandom>("Random", "A pseudo random number generator."));
Parameters.Add(new ValueLookupParameter<BoolValue>("Maximization", "True if the problem is a maximization problem, otherwise false."));
Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("Quality", "The value which represents the quality of a solution."));
Parameters.Add(new ValueLookupParameter<DoubleValue>("BestKnownQuality", "The best known quality value found so far."));
Parameters.Add(new ValueLookupParameter<IOperator>("Selector", "The operator used to select solutions for reproduction."));
Parameters.Add(new ValueLookupParameter<IOperator>("Crossover", "The operator used to cross solutions."));
Parameters.Add(new ValueLookupParameter<PercentValue>("MutationProbability", "The probability that the mutation operator is applied on a solution."));
Parameters.Add(new ValueLookupParameter<IOperator>("Mutator", "The operator used to mutate solutions."));
Parameters.Add(new ValueLookupParameter<IOperator>("Evaluator", "The operator used to evaluate solutions. This operator is executed in parallel, if an engine is used which supports parallelization."));
Parameters.Add(new ValueLookupParameter<IntValue>("Elites", "The numer of elite solutions which are kept in each generation."));
Parameters.Add(new ValueLookupParameter<BoolValue>("ReevaluateElites", "Flag to determine if elite individuals should be reevaluated (i.e., if stochastic fitness functions are used.)"));
Parameters.Add(new ValueLookupParameter<IntValue>("MaximumGenerations", "The maximum number of generations which should be processed."));
Parameters.Add(new ValueLookupParameter<VariableCollection>("Results", "The variable collection where results should be stored."));
Parameters.Add(new ValueLookupParameter<IOperator>("Analyzer", "The operator used to analyze each generation."));
Parameters.Add(new ValueLookupParameter<DoubleValue>("SuccessRatio", "The ratio of successful to total children that should be achieved."));
Parameters.Add(new LookupParameter<DoubleValue>("ComparisonFactor", "The comparison factor is used to determine whether the offspring should be compared to the better parent, the worse parent or a quality value linearly interpolated between them. It is in the range [0;1]."));
Parameters.Add(new ValueLookupParameter<DoubleValue>("ComparisonFactorStart", "The initial value for the comparison factor."));
Parameters.Add(new ValueLookupParameter<IOperator>("ComparisonFactorModifier", "The operator used to modify the comparison factor."));
Parameters.Add(new ValueLookupParameter<DoubleValue>("MaximumSelectionPressure", "The maximum selection pressure that terminates the algorithm."));
Parameters.Add(new ValueLookupParameter<BoolValue>("OffspringSelectionBeforeMutation", "True if the offspring selection step should be applied before mutation, false if it should be applied after mutation."));
Parameters.Add(new LookupParameter<IntValue>("EvaluatedSolutions", "The number of times solutions have been evaluated."));
Parameters.Add(new ValueLookupParameter<BoolValue>("FillPopulationWithParents", "True if the population should be filled with parent individual or false if worse children should be used when the maximum selection pressure is exceeded."));
#endregion
#region Create operators
VariableCreator variableCreator = new VariableCreator();
Assigner comparisonFactorInitializer = new Assigner();
Placeholder analyzer1 = new Placeholder();
ResultsCollector resultsCollector1 = new ResultsCollector();
OffspringSelectionGeneticAlgorithmMainOperator mainOperator = new OffspringSelectionGeneticAlgorithmMainOperator();
IntCounter generationsCounter = new IntCounter();
Comparator maxGenerationsComparator = new Comparator();
Comparator maxSelectionPressureComparator = new Comparator();
Comparator maxEvaluatedSolutionsComparator = new Comparator();
Placeholder comparisonFactorModifier = new Placeholder();
Placeholder analyzer2 = new Placeholder();
ConditionalBranch conditionalBranch1 = new ConditionalBranch();
ConditionalBranch conditionalBranch2 = new ConditionalBranch();
ConditionalBranch conditionalBranch3 = new ConditionalBranch();
variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("Generations", new IntValue(0))); // Class OffspringSelectionGeneticAlgorithm expects this to be called Generations
variableCreator.CollectedValues.Add(new ValueParameter<DoubleValue>("SelectionPressure", new DoubleValue(0)));
variableCreator.CollectedValues.Add(new ValueParameter<DoubleValue>("CurrentSuccessRatio", new DoubleValue(0)));
comparisonFactorInitializer.Name = "Initialize ComparisonFactor (placeholder)";
comparisonFactorInitializer.LeftSideParameter.ActualName = ComparisonFactorParameter.Name;
comparisonFactorInitializer.RightSideParameter.ActualName = ComparisonFactorStartParameter.Name;
analyzer1.Name = "Analyzer (placeholder)";
analyzer1.OperatorParameter.ActualName = AnalyzerParameter.Name;
resultsCollector1.CopyValue = new BoolValue(false);
resultsCollector1.CollectedValues.Add(new LookupParameter<IntValue>("Generations"));
resultsCollector1.CollectedValues.Add(new LookupParameter<DoubleValue>("Current Comparison Factor", null, ComparisonFactorParameter.Name));
resultsCollector1.CollectedValues.Add(new LookupParameter<DoubleValue>("Current Selection Pressure", "Displays the rising selection pressure during a generation.", "SelectionPressure"));
resultsCollector1.CollectedValues.Add(new LookupParameter<DoubleValue>("Current Success Ratio", "Indicates how many successful children were already found during a generation (relative to the population size).", "CurrentSuccessRatio"));
resultsCollector1.ResultsParameter.ActualName = ResultsParameter.Name;
mainOperator.ComparisonFactorParameter.ActualName = ComparisonFactorParameter.Name;
mainOperator.CrossoverParameter.ActualName = CrossoverParameter.Name;
mainOperator.CurrentSuccessRatioParameter.ActualName = "CurrentSuccessRatio";
mainOperator.ElitesParameter.ActualName = ElitesParameter.Name;
mainOperator.ReevaluateElitesParameter.ActualName = ReevaluateElitesParameter.Name;
mainOperator.EvaluatedSolutionsParameter.ActualName = EvaluatedSolutionsParameter.Name;
mainOperator.EvaluatorParameter.ActualName = EvaluatorParameter.Name;
mainOperator.MaximizationParameter.ActualName = MaximizationParameter.Name;
mainOperator.MaximumSelectionPressureParameter.ActualName = MaximumSelectionPressureParameter.Name;
mainOperator.MutationProbabilityParameter.ActualName = MutationProbabilityParameter.Name;
mainOperator.MutatorParameter.ActualName = MutatorParameter.Name;
mainOperator.OffspringSelectionBeforeMutationParameter.ActualName = OffspringSelectionBeforeMutationParameter.Name;
mainOperator.QualityParameter.ActualName = QualityParameter.Name;
mainOperator.RandomParameter.ActualName = RandomParameter.Name;
mainOperator.SelectionPressureParameter.ActualName = "SelectionPressure";
mainOperator.SelectorParameter.ActualName = SelectorParameter.Name;
mainOperator.SuccessRatioParameter.ActualName = SuccessRatioParameter.Name;
mainOperator.FillPopulationWithParentsParameter.ActualName = FillPopulationWithParentsParameter.Name;
generationsCounter.Increment = new IntValue(1);
generationsCounter.ValueParameter.ActualName = "Generations";
maxGenerationsComparator.Comparison = new Comparison(ComparisonType.GreaterOrEqual);
maxGenerationsComparator.LeftSideParameter.ActualName = "Generations";
maxGenerationsComparator.ResultParameter.ActualName = "TerminateMaximumGenerations";
maxGenerationsComparator.RightSideParameter.ActualName = MaximumGenerationsParameter.Name;
maxSelectionPressureComparator.Comparison = new Comparison(ComparisonType.GreaterOrEqual);
maxSelectionPressureComparator.LeftSideParameter.ActualName = "SelectionPressure";
maxSelectionPressureComparator.ResultParameter.ActualName = "TerminateSelectionPressure";
maxSelectionPressureComparator.RightSideParameter.ActualName = MaximumSelectionPressureParameter.Name;
maxEvaluatedSolutionsComparator.Comparison = new Comparison(ComparisonType.GreaterOrEqual);
maxEvaluatedSolutionsComparator.LeftSideParameter.ActualName = EvaluatedSolutionsParameter.Name;
maxEvaluatedSolutionsComparator.ResultParameter.ActualName = "TerminateEvaluatedSolutions";
maxEvaluatedSolutionsComparator.RightSideParameter.ActualName = "MaximumEvaluatedSolutions";
comparisonFactorModifier.Name = "Update ComparisonFactor (placeholder)";
comparisonFactorModifier.OperatorParameter.ActualName = ComparisonFactorModifierParameter.Name;
analyzer2.Name = "Analyzer (placeholder)";
analyzer2.OperatorParameter.ActualName = AnalyzerParameter.Name;
conditionalBranch1.Name = "MaximumSelectionPressure reached?";
conditionalBranch1.ConditionParameter.ActualName = "TerminateSelectionPressure";
conditionalBranch2.Name = "MaximumGenerations reached?";
conditionalBranch2.ConditionParameter.ActualName = "TerminateMaximumGenerations";
conditionalBranch3.Name = "MaximumEvaluatedSolutions reached?";
conditionalBranch3.ConditionParameter.ActualName = "TerminateEvaluatedSolutions";
#endregion
#region Create operator graph
OperatorGraph.InitialOperator = variableCreator;
variableCreator.Successor = comparisonFactorInitializer;
comparisonFactorInitializer.Successor = analyzer1;
analyzer1.Successor = resultsCollector1;
resultsCollector1.Successor = mainOperator;
mainOperator.Successor = generationsCounter;
generationsCounter.Successor = maxGenerationsComparator;
maxGenerationsComparator.Successor = maxSelectionPressureComparator;
maxSelectionPressureComparator.Successor = maxEvaluatedSolutionsComparator;
maxEvaluatedSolutionsComparator.Successor = comparisonFactorModifier;
comparisonFactorModifier.Successor = analyzer2;
analyzer2.Successor = conditionalBranch1;
conditionalBranch1.FalseBranch = conditionalBranch2;
conditionalBranch1.TrueBranch = null;
conditionalBranch1.Successor = null;
conditionalBranch2.FalseBranch = conditionalBranch3;
conditionalBranch2.TrueBranch = null;
conditionalBranch2.Successor = null;
conditionalBranch3.FalseBranch = mainOperator;
conditionalBranch3.TrueBranch = null;
conditionalBranch3.Successor = null;
#endregion
}
private void Initialize() {
#region Create parameters
Parameters.Add(new ValueLookupParameter<IMultiAnalyzer>("Analyzer", "The analyzer used to analyze each iteration."));
Parameters.Add(new ValueLookupParameter<DoubleValue>("BestKnownQuality", "The best known quality value found so far."));
Parameters.Add(new ValueLookupParameter<ICrossover>("Crossover", "The operator used to cross solutions."));
Parameters.Add(new ValueLookupParameter<IntValue>("EvaluatedSolutions", "The number of times solutions have been evaluated."));
Parameters.Add(new ValueLookupParameter<IEvaluator>("Evaluator", "The operator used to evaluate solutions. This operator is executed in parallel, if an engine is used which supports parallelization."));
Parameters.Add(new ValueLookupParameter<BoolValue>("ExecutePathRelinking", "True if path relinking should be executed instead of crossover, otherwise false."));
Parameters.Add(new ValueLookupParameter<IImprovementOperator>("Improver", "The operator used to improve solutions."));
Parameters.Add(new ValueLookupParameter<IntValue>("Iterations", "The number of iterations performed."));
Parameters.Add(new ValueLookupParameter<BoolValue>("Maximization", "True if the problem is a maximization problem, otherwise false."));
Parameters.Add(new ValueLookupParameter<IntValue>("MaximumIterations", "The maximum number of iterations which should be processed."));
Parameters.Add(new ValueLookupParameter<IntValue>("NumberOfHighQualitySolutions", "The number of high quality solutions in the reference set."));
Parameters.Add(new ValueLookupParameter<IPathRelinker>("PathRelinker", "The operator used to execute path relinking."));
Parameters.Add(new ValueLookupParameter<IntValue>("PopulationSize", "The size of the population of solutions."));
Parameters.Add(new ValueLookupParameter<IntValue>("ReferenceSetSize", "The size of the reference set."));
Parameters.Add(new ValueLookupParameter<DoubleValue>("Quality", "This parameter is used for name translation only."));
Parameters.Add(new ValueLookupParameter<IRandom>("Random", "A pseudo random number generator."));
Parameters.Add(new ValueLookupParameter<VariableCollection>("Results", "The variable collection where results should be stored."));
Parameters.Add(new ValueLookupParameter<ISolutionSimilarityCalculator>("SimilarityCalculator", "The operator used to calculate the similarity between two solutions."));
#endregion
#region Create operators
Placeholder analyzer = new Placeholder();
Assigner assigner1 = new Assigner();
Assigner assigner2 = new Assigner();
ChildrenCreator childrenCreator = new ChildrenCreator();
Placeholder crossover = new Placeholder();
Comparator iterationsChecker = new Comparator();
IntCounter iterationsCounter = new IntCounter();
MergingReducer mergingReducer = new MergingReducer();
ConditionalBranch executePathRelinkingBranch = new ConditionalBranch();
ConditionalBranch newSolutionsBranch = new ConditionalBranch();
OffspringProcessor offspringProcessor = new OffspringProcessor();
Placeholder pathRelinker = new Placeholder();
PopulationRebuildMethod populationRebuildMethod = new PopulationRebuildMethod();
ReferenceSetUpdateMethod referenceSetUpdateMethod = new ReferenceSetUpdateMethod();
ResultsCollector resultsCollector = new ResultsCollector();
RightSelector rightSelector = new RightSelector();
Placeholder solutionEvaluator1 = new Placeholder();
Placeholder solutionEvaluator2 = new Placeholder();
Placeholder solutionImprover1 = new Placeholder();
Placeholder solutionImprover2 = new Placeholder();
SolutionPoolUpdateMethod solutionPoolUpdateMethod = new SolutionPoolUpdateMethod();
SolutionsCreator solutionsCreator = new SolutionsCreator();
DataReducer dataReducer1 = new DataReducer();
DataReducer dataReducer2 = new DataReducer();
SubScopesProcessor subScopesProcessor1 = new SubScopesProcessor();
SubScopesProcessor subScopesProcessor2 = new SubScopesProcessor();
SubScopesProcessor subScopesProcessor3 = new SubScopesProcessor();
SubScopesProcessor subScopesProcessor4 = new SubScopesProcessor();
ConditionalBranch terminateBranch = new ConditionalBranch();
UniformSubScopesProcessor uniformSubScopesProcessor1 = new UniformSubScopesProcessor();
UniformSubScopesProcessor uniformSubScopesProcessor2 = new UniformSubScopesProcessor();
UniformSubScopesProcessor uniformSubScopesProcessor3 = new UniformSubScopesProcessor();
VariableCreator variableCreator = new VariableCreator();
#endregion
#region Create operator graph
OperatorGraph.InitialOperator = variableCreator;
variableCreator.CollectedValues.Add(new ValueParameter<IntValue>(IterationsParameter.Name, new IntValue(0)));
variableCreator.CollectedValues.Add(new ValueParameter<BoolValue>("NewSolutions", new BoolValue(false)));
variableCreator.Successor = resultsCollector;
resultsCollector.CopyValue = new BoolValue(false);
resultsCollector.CollectedValues.Add(new LookupParameter<IntValue>(IterationsParameter.Name));
resultsCollector.ResultsParameter.ActualName = ResultsParameter.Name;
resultsCollector.Successor = iterationsChecker;
iterationsChecker.Name = "IterationsChecker";
iterationsChecker.Comparison.Value = ComparisonType.GreaterOrEqual;
iterationsChecker.LeftSideParameter.ActualName = IterationsParameter.Name;
iterationsChecker.RightSideParameter.ActualName = MaximumIterationsParameter.Name;
iterationsChecker.ResultParameter.ActualName = "Terminate";
iterationsChecker.Successor = terminateBranch;
terminateBranch.Name = "TerminateChecker";
terminateBranch.ConditionParameter.ActualName = "Terminate";
terminateBranch.FalseBranch = referenceSetUpdateMethod;
referenceSetUpdateMethod.Successor = assigner1;
assigner1.Name = "NewSolutions = true";
assigner1.LeftSideParameter.ActualName = "NewSolutions";
assigner1.RightSideParameter.Value = new BoolValue(true);
assigner1.Successor = subScopesProcessor1;
subScopesProcessor1.DepthParameter.Value = new IntValue(1);
subScopesProcessor1.Operators.Add(new EmptyOperator());
subScopesProcessor1.Operators.Add(childrenCreator);
subScopesProcessor1.Successor = newSolutionsBranch;
childrenCreator.Name = "SubsetGenerator";
childrenCreator.ParentsPerChildParameter.Value = new IntValue(2);
childrenCreator.Successor = assigner2;
assigner2.Name = "NewSolutions = false";
assigner2.LeftSideParameter.ActualName = "NewSolutions";
assigner2.RightSideParameter.Value = new BoolValue(false);
assigner2.Successor = uniformSubScopesProcessor1;
uniformSubScopesProcessor1.DepthParameter.Value = new IntValue(1);
uniformSubScopesProcessor1.Operator = executePathRelinkingBranch;
uniformSubScopesProcessor1.Successor = solutionPoolUpdateMethod;
executePathRelinkingBranch.Name = "ExecutePathRelinkingChecker";
executePathRelinkingBranch.ConditionParameter.ActualName = ExecutePathRelinkingParameter.ActualName;
executePathRelinkingBranch.TrueBranch = pathRelinker;
executePathRelinkingBranch.FalseBranch = crossover;
pathRelinker.Name = "PathRelinker";
pathRelinker.OperatorParameter.ActualName = PathRelinkerParameter.Name;
pathRelinker.Successor = rightSelector;
crossover.Name = "Crossover";
crossover.OperatorParameter.ActualName = CrossoverParameter.Name;
crossover.Successor = offspringProcessor;
offspringProcessor.Successor = rightSelector;
rightSelector.NumberOfSelectedSubScopesParameter.Value = new IntValue(1);
rightSelector.CopySelected = new BoolValue(false);
rightSelector.Successor = subScopesProcessor2;
subScopesProcessor2.DepthParameter.Value = new IntValue(1);
subScopesProcessor2.Operators.Add(new EmptyOperator());
subScopesProcessor2.Operators.Add(uniformSubScopesProcessor2);
subScopesProcessor2.Successor = mergingReducer;
uniformSubScopesProcessor2.DepthParameter.Value = new IntValue(2);
uniformSubScopesProcessor2.Operator = solutionImprover1;
uniformSubScopesProcessor2.ParallelParameter.Value = new BoolValue(true);
uniformSubScopesProcessor2.Successor = subScopesProcessor4;
solutionImprover1.Name = "SolutionImprover";
solutionImprover1.OperatorParameter.ActualName = ImproverParameter.Name;
solutionImprover1.Successor = solutionEvaluator1;
solutionEvaluator1.Name = "SolutionEvaluator";
solutionEvaluator1.OperatorParameter.ActualName = EvaluatorParameter.Name;
subScopesProcessor4.Operators.Add(dataReducer1);
dataReducer1.Name = "Increment EvaluatedSolutions";
dataReducer1.ParameterToReduce.ActualName = "LocalEvaluatedSolutions";
dataReducer1.TargetParameter.ActualName = EvaluatedSolutionsParameter.Name;
dataReducer1.ReductionOperation.Value = new ReductionOperation(ReductionOperations.Sum);
dataReducer1.TargetOperation.Value = new ReductionOperation(ReductionOperations.Sum);
solutionPoolUpdateMethod.QualityParameter.ActualName = QualityParameter.ActualName;
solutionPoolUpdateMethod.Successor = analyzer;
analyzer.Name = "Analyzer";
analyzer.OperatorParameter.ActualName = AnalyzerParameter.Name;
newSolutionsBranch.Name = "NewSolutionsChecker";
newSolutionsBranch.ConditionParameter.ActualName = "NewSolutions";
newSolutionsBranch.TrueBranch = subScopesProcessor1;
newSolutionsBranch.FalseBranch = populationRebuildMethod;
populationRebuildMethod.QualityParameter.ActualName = QualityParameter.ActualName;
populationRebuildMethod.Successor = subScopesProcessor3;
subScopesProcessor3.DepthParameter.Value = new IntValue(1);
subScopesProcessor3.Operators.Add(solutionsCreator);
subScopesProcessor3.Operators.Add(new EmptyOperator());
subScopesProcessor3.Successor = iterationsCounter;
solutionsCreator.Name = "DiversificationGenerationMethod";
solutionsCreator.NumberOfSolutionsParameter.ActualName = PopulationSizeParameter.Name;
solutionsCreator.Successor = uniformSubScopesProcessor3;
uniformSubScopesProcessor3.DepthParameter.Value = new IntValue(1);
uniformSubScopesProcessor3.Operator = solutionImprover2;
uniformSubScopesProcessor3.ParallelParameter.Value = new BoolValue(true);
uniformSubScopesProcessor3.Successor = dataReducer2;
solutionImprover2.Name = "SolutionImprover";
solutionImprover2.OperatorParameter.ActualName = ImproverParameter.Name;
solutionImprover2.Successor = solutionEvaluator2;
solutionEvaluator2.Name = "SolutionEvaluator";
solutionEvaluator2.OperatorParameter.ActualName = EvaluatorParameter.Name;
dataReducer2.Name = "Increment EvaluatedSolutions";
dataReducer2.ParameterToReduce.ActualName = "LocalEvaluatedSolutions";
dataReducer2.TargetParameter.ActualName = EvaluatedSolutionsParameter.Name;
dataReducer2.ReductionOperation.Value = new ReductionOperation(ReductionOperations.Sum);
dataReducer2.TargetOperation.Value = new ReductionOperation(ReductionOperations.Sum);
iterationsCounter.Name = "IterationCounter";
iterationsCounter.IncrementParameter.Value = new IntValue(1);
iterationsCounter.ValueParameter.ActualName = IterationsParameter.Name;
iterationsCounter.Successor = resultsCollector;
#endregion
}