Changeset 1235

Timestamp:

03/02/09 09:38:53 (16 years ago)

Author:

gkronber

Message:

Worked on hard-coded OffspringSelectionGP. #224 (Simple frontend for GP for non-expert users (similar to HeurisicLab.SGA))

Location:

branches/CEDMA-Refactoring-Ticket419/HeuristicLab.GP.StructureIdentification

Files:

• OffspringSelectionGP.cs (modified) (9 diffs)
• StandardGP.cs (modified) (2 diffs)

branches/CEDMA-Refactoring-Ticket419/HeuristicLab.GP.StructureIdentification/OffspringSelectionGP.cs

@@ -37 +37 @@
 
 namespace HeuristicLab.GP.StructureIdentification {
-  public class OffspringSelectionGP : ItemBase, IEditable {
-    private IntData maxGenerations = new IntData();
-    public int MaxGenerations {
-      get { return maxGenerations.Data; }
-      set { maxGenerations.Data = value; }
-    }
-
-    private DoubleData mutationRate = new DoubleData();
-    public double MutationRate {
-      get { return mutationRate.Data; }
-      set { mutationRate.Data = value; }
-    }
-
-    private IntData parents = new IntData();
-    private IntData populationSize = new IntData();
-    public int PopulationSize {
-      get { return populationSize.Data; }
-      set {
-        populationSize.Data = value;
-      }
-    }
-
-    private BoolData setSeedRandomly = new BoolData();
-    public bool SetSeedRandomly {
-      get { return setSeedRandomly.Data; }
-      set { setSeedRandomly.Data = value; }
-    }
-
-    private IntData seed = new IntData();
-    public int Seed {
-      get { return seed.Data; }
-      set { seed.Data = value; }
-    }
-
-    public IOperator ProblemInjector {
-      get { return algorithm.SubOperators[0]; }
-      set {
-        value.Name = "ProblemInjector";
-        algorithm.RemoveSubOperator(0);
-        algorithm.AddSubOperator(value, 0);
-      }
-    }
-
-    private IntData elites = new IntData();
-    public int Elites {
-      get { return elites.Data; }
-      set { elites.Data = value; }
-    }
-
-    private IntData maxTreeSize = new IntData();
-    public int MaxTreeSize {
-      get { return maxTreeSize.Data; }
-      set { maxTreeSize.Data = value; }
-    }
-
-    private IntData maxTreeHeight = new IntData();
-    public int MaxTreeHeight {
-      get { return maxTreeHeight.Data; }
-      set { maxTreeHeight.Data = value; }
+  public class OffspringSelectionGP : StandardGP {
+
+    private IntData maxEvaluatedSolutions = new IntData();
+    public int MaxEvaluatedSolutions {
+      get { return maxEvaluatedSolutions.Data; }
+      set { maxEvaluatedSolutions.Data = value; }
     }
 
@@ -116 +63 @@
     }
 
-    private double punishmentFactor = 10.0;
-    private bool useEstimatedTargetValue = false;
-    private double fullTreeShakingFactor = 0.1;
-    private double onepointShakingFactor = 1.0;
-    private IOperator algorithm;
-
-    private SequentialEngine.SequentialEngine engine;
-    public IEngine Engine {
-      get { return engine; }
-    }
-
-    public OffspringSelectionGP() {
+    public OffspringSelectionGP() : base() {
       PopulationSize = 1000;
-      parents.Data = 20;
-      MaxGenerations = 100;
-      MutationRate = 0.15;
-      Elites = 1;
+      Parents = 20;
+      MaxEvaluatedSolutions = 1000000;
       SelectionPressureLimit = 300;
       ComparisonFactor = 1.0;
       SuccessRatioLimit = 1.0;
-      MaxTreeHeight = 10;
-      MaxTreeSize = 100;
-      engine = new SequentialEngine.SequentialEngine();
-      CombinedOperator algo = CreateAlgorithm();
-      engine.OperatorGraph.AddOperator(algo);
-      engine.OperatorGraph.InitialOperator = algo;
-    }
-
-    private CombinedOperator CreateAlgorithm() {
-      CombinedOperator algo = new CombinedOperator();
-      algo.Name = "OffspringSelectionGP";
-      SequentialProcessor seq = new SequentialProcessor();
-      EmptyOperator problemInjectorPlaceholder = new EmptyOperator();
-      RandomInjector randomInjector = new RandomInjector();
-      randomInjector.GetVariable("SetSeedRandomly").Value = setSeedRandomly;
-      randomInjector.GetVariable("Seed").Value = seed;
-      randomInjector.Name = "Random Injector";
-      VariableInjector globalInjector = CreateGlobalInjector();
-      CombinedOperator initialization = CreateInitialization();
-      initialization.Name = "Initialization";
-      FunctionLibraryInjector funLibInjector = new FunctionLibraryInjector();
-      CombinedOperator mainLoop = CreateMainLoop();
-      mainLoop.Name = "Main loop";
-
-      ProbabilisticTreeCreator treeCreator = new ProbabilisticTreeCreator();
-      treeCreator.Name = "Tree generator";
-      treeCreator.GetVariableInfo("OperatorLibrary").ActualName = "FunctionLibrary";
-      treeCreator.GetVariableInfo("MinTreeSize").Local = true;
-      treeCreator.AddVariable(new HeuristicLab.Core.Variable("MinTreeSize", new IntData(3)));
-      MeanSquaredErrorEvaluator evaluator = new MeanSquaredErrorEvaluator();
-      evaluator.GetVariableInfo("MSE").ActualName = "Quality";
-      evaluator.GetVariableInfo("SamplesStart").ActualName = "TrainingSamplesStart";
-      evaluator.GetVariableInfo("SamplesEnd").ActualName = "TrainingSamplesEnd";
-      evaluator.Name = "Evaluator";
-      StandardCrossOver crossover = new StandardCrossOver();
-      crossover.Name = "Crossover";
-      crossover.GetVariableInfo("OperatorLibrary").ActualName = "FunctionLibrary";
-      CombinedOperator manipulator = CreateManipulator();
-      manipulator.Name = "Manipulator";
-      CombinedOperator selector = CreateSelector();
-      selector.Name = "Selector";
-      LeftReducer cleanUp = new LeftReducer();
-
-      seq.AddSubOperator(problemInjectorPlaceholder);
-      seq.AddSubOperator(randomInjector);
-      seq.AddSubOperator(globalInjector);
-      seq.AddSubOperator(funLibInjector);
-      seq.AddSubOperator(initialization);
-      seq.AddSubOperator(mainLoop);
-      seq.AddSubOperator(cleanUp);
-
-      initialization.AddSubOperator(treeCreator);
-      initialization.AddSubOperator(evaluator);
-
-      mainLoop.AddSubOperator(selector);
-      mainLoop.AddSubOperator(crossover);
-      mainLoop.AddSubOperator(manipulator);
-      mainLoop.AddSubOperator(evaluator);
-      algo.OperatorGraph.AddOperator(seq);
-      algo.OperatorGraph.InitialOperator = seq;
-      this.algorithm = seq;
-      return algo;
-    }
-
-    private VariableInjector CreateGlobalInjector() {
-      VariableInjector injector = new VariableInjector();
-      injector.Name = "Global Injector";
+    }
+
+    internal override IOperator CreateGlobalInjector() {
+      VariableInjector injector = (VariableInjector)base.CreateGlobalInjector();
+      injector.RemoveVariable("TournamentSize");
+      injector.RemoveVariable("MaxGenerations");
+      injector.AddVariable(new HeuristicLab.Core.Variable("MaxEvaluatedSolutions", maxEvaluatedSolutions));
       injector.AddVariable(new HeuristicLab.Core.Variable("ComparisonFactor", comparisonFactor));
-      injector.AddVariable(new HeuristicLab.Core.Variable("Elites", elites));
-      injector.AddVariable(new HeuristicLab.Core.Variable("EvaluatedSolutions", new IntData(0)));
-      injector.AddVariable(new HeuristicLab.Core.Variable("Generations", new IntData(0)));
-      injector.AddVariable(new HeuristicLab.Core.Variable("Maximization", new BoolData(false)));
-      injector.AddVariable(new HeuristicLab.Core.Variable("MaxGenerations", maxGenerations));
-      injector.AddVariable(new HeuristicLab.Core.Variable("MaxTreeHeight", maxTreeHeight));
-      injector.AddVariable(new HeuristicLab.Core.Variable("MaxTreeSize", maxTreeSize));
-      injector.AddVariable(new HeuristicLab.Core.Variable("MutationRate", mutationRate));
-      injector.AddVariable(new HeuristicLab.Core.Variable("Parents", parents));
-      injector.AddVariable(new HeuristicLab.Core.Variable("PopulationSize", populationSize));
-      injector.AddVariable(new HeuristicLab.Core.Variable("PunishmentFactor", new DoubleData(punishmentFactor)));
       injector.AddVariable(new HeuristicLab.Core.Variable("SelectionPressureLimit", selectionPressureLimit));
       injector.AddVariable(new HeuristicLab.Core.Variable("SuccessRatioLimit", successRatioLimit));
-      injector.AddVariable(new HeuristicLab.Core.Variable("TotalEvaluatedNodes", new DoubleData(0)));
-      injector.AddVariable(new HeuristicLab.Core.Variable("UseEstimatedTargetValue", new BoolData(useEstimatedTargetValue)));
       return injector;
     }
 
-    private CombinedOperator CreateManipulator() {
-      CombinedOperator manipulator = new CombinedOperator();
-      StochasticMultiBranch multibranch = new StochasticMultiBranch();
-      FullTreeShaker fullTreeShaker = new FullTreeShaker();
-      fullTreeShaker.GetVariableInfo("OperatorLibrary").ActualName = "FunctionLibrary";
-      fullTreeShaker.GetVariableInfo("ShakingFactor").Local = true;
-      fullTreeShaker.AddVariable(new HeuristicLab.Core.Variable("ShakingFactor", new DoubleData(fullTreeShakingFactor)));
-
-      OnePointShaker onepointShaker = new OnePointShaker();
-      onepointShaker.GetVariableInfo("OperatorLibrary").ActualName = "FunctionLibrary";
-      onepointShaker.GetVariableInfo("ShakingFactor").Local = true;
-      onepointShaker.AddVariable(new HeuristicLab.Core.Variable("ShakingFactor", new DoubleData(onepointShakingFactor)));
-      ChangeNodeTypeManipulation changeNodeTypeManipulation = new ChangeNodeTypeManipulation();
-      changeNodeTypeManipulation.GetVariableInfo("OperatorLibrary").ActualName = "FunctionLibrary";
-      CutOutNodeManipulation cutOutNodeManipulation = new CutOutNodeManipulation();
-      cutOutNodeManipulation.GetVariableInfo("OperatorLibrary").ActualName = "FunctionLibrary";
-      DeleteSubTreeManipulation deleteSubTreeManipulation = new DeleteSubTreeManipulation();
-      deleteSubTreeManipulation.GetVariableInfo("OperatorLibrary").ActualName = "FunctionLibrary";
-      SubstituteSubTreeManipulation substituteSubTreeManipulation = new SubstituteSubTreeManipulation();
-      substituteSubTreeManipulation.GetVariableInfo("OperatorLibrary").ActualName = "FunctionLibrary";
-
-      IOperator[] manipulators = new IOperator[] {
-        onepointShaker, fullTreeShaker,
-        changeNodeTypeManipulation,
-        cutOutNodeManipulation,
-        deleteSubTreeManipulation,
-        substituteSubTreeManipulation};
-
-      DoubleArrayData probabilities = new DoubleArrayData(new double[manipulators.Length]);
-      for (int i = 0; i < manipulators.Length; i++) {
-        probabilities.Data[i] = 1.0;
-        multibranch.AddSubOperator(manipulators[i]);
-      }
-      multibranch.GetVariableInfo("Probabilities").Local = true;
-      multibranch.AddVariable(new HeuristicLab.Core.Variable("Probabilities", probabilities));
-
-      manipulator.OperatorGraph.AddOperator(multibranch);
-      manipulator.OperatorGraph.InitialOperator = multibranch;
-      return manipulator;
-    }
-
-    private CombinedOperator CreateInitialization() {
-      CombinedOperator init = new CombinedOperator();
-      SequentialProcessor seq = new SequentialProcessor();
-      SubScopesCreater subScopesCreater = new SubScopesCreater();
-      subScopesCreater.GetVariableInfo("SubScopes").ActualName = "PopulationSize";
-      UniformSequentialSubScopesProcessor subScopesProc = new UniformSequentialSubScopesProcessor();
-      SequentialProcessor individualSeq = new SequentialProcessor();
-      OperatorExtractor treeCreater = new OperatorExtractor();
-      treeCreater.Name = "Tree generator (extr.)";
-      treeCreater.GetVariableInfo("Operator").ActualName = "Tree generator";
-      OperatorExtractor evaluator = new OperatorExtractor();
-      evaluator.Name = "Evaluator (extr.)";
-      evaluator.GetVariableInfo("Operator").ActualName = "Evaluator";
-      MeanSquaredErrorEvaluator validationEvaluator = new MeanSquaredErrorEvaluator();
-      validationEvaluator.GetVariableInfo("MSE").ActualName = "ValidationQuality";
-      validationEvaluator.GetVariableInfo("SamplesStart").ActualName = "ValidationSamplesStart";
-      validationEvaluator.GetVariableInfo("SamplesEnd").ActualName = "ValidationSamplesEnd";
-      Counter evalCounter = new Counter();
-      evalCounter.GetVariableInfo("Value").ActualName = "EvaluatedSolutions";
-      Sorter sorter = new Sorter();
-      sorter.GetVariableInfo("Descending").ActualName = "Maximization";
-      sorter.GetVariableInfo("Value").ActualName = "Quality";
-      seq.AddSubOperator(subScopesCreater);
-      seq.AddSubOperator(subScopesProc);
-      seq.AddSubOperator(sorter);
-      subScopesProc.AddSubOperator(individualSeq);
-      individualSeq.AddSubOperator(treeCreater);
-      individualSeq.AddSubOperator(evaluator);
-      individualSeq.AddSubOperator(validationEvaluator);
-      individualSeq.AddSubOperator(evalCounter);
-
-      init.OperatorGraph.AddOperator(seq);
-      init.OperatorGraph.InitialOperator = seq;
-      return init;
-    }
-
-    private CombinedOperator CreateSelector() {
+    internal override IOperator CreateSelector() {
       CombinedOperator selector = new CombinedOperator();
+      selector.Name = "Selector";
       SequentialProcessor seq = new SequentialProcessor();
       seq.Name = "Selector";
@@ -328 +113 @@
     }
 
-    private CombinedOperator CreateMainLoop() {
+    internal override IOperator CreateMainLoop() {
       CombinedOperator main = new CombinedOperator();
       SequentialProcessor seq = new SequentialProcessor();
@@ -340 +125 @@
       selector.GetVariableInfo("Operator").ActualName = "Selector";
 
-      CombinedOperator childCreater = CreateChildCreater();
+      IOperator childCreater = CreateChildCreater();
       childCreater.Name = "Create children";
-      CombinedOperator replacement = CreateReplacement();
+      IOperator replacement = CreateReplacement();
       replacement.Name = "Replacement";
-      BestSolutionStorer solutionStorer = CreateBestSolutionStorer();
+      IOperator solutionStorer = CreateBestSolutionProcessor();
       BestAverageWorstQualityCalculator qualityCalculator = new BestAverageWorstQualityCalculator();
       BestAverageWorstQualityCalculator validationQualityCalculator = new BestAverageWorstQualityCalculator();
@@ -374 +159 @@
       selPresComparator.GetVariableInfo("Result").ActualName = "SelectionPressureCondition";
       LessThanComparator generationsComparator = new LessThanComparator();
-      generationsComparator.GetVariableInfo("LeftSide").ActualName = "Generations";
-      generationsComparator.GetVariableInfo("RightSide").ActualName = "MaxGenerations";
-      generationsComparator.GetVariableInfo("Result").ActualName = "GenerationsCondition";
+      generationsComparator.GetVariableInfo("LeftSide").ActualName = "EvaluatedSolutions";
+      generationsComparator.GetVariableInfo("RightSide").ActualName = "MaxEvaluatedSolutions";
+      generationsComparator.GetVariableInfo("Result").ActualName = "EvaluatedSolutionsCondition";
       ConditionalBranch selPresCondition = new ConditionalBranch();
       selPresCondition.GetVariableInfo("Condition").ActualName = "SelectionPressureCondition";
       ConditionalBranch generationsCondition = new ConditionalBranch();
-      generationsCondition.GetVariableInfo("Condition").ActualName = "GenerationsCondition";
+      generationsCondition.GetVariableInfo("Condition").ActualName = "EvaluatedSolutionsCondition";
 
       subScopesProc.AddSubOperator(emptyOp);
@@ -412 +197 @@
     }
 
-    private BestSolutionStorer CreateBestSolutionStorer() {
-      BestSolutionStorer solutionStorer = new BestSolutionStorer();
-      solutionStorer.GetVariableInfo("Quality").ActualName = "ValidationQuality";
-      solutionStorer.GetVariableInfo("BestSolution").ActualName = "BestValidationSolution";
-      SequentialProcessor bestSolutionProcessor = new SequentialProcessor();
-      MeanAbsolutePercentageErrorEvaluator trainingMapeEvaluator = new MeanAbsolutePercentageErrorEvaluator();
-      trainingMapeEvaluator.Name = "TrainingMapeEvaluator";
-      trainingMapeEvaluator.GetVariableInfo("MAPE").ActualName = "TrainingMAPE";
-      trainingMapeEvaluator.GetVariableInfo("SamplesStart").ActualName = "TrainingSamplesStart";
-      trainingMapeEvaluator.GetVariableInfo("SamplesEnd").ActualName = "TrainingSamplesEnd";
-      MeanAbsolutePercentageErrorEvaluator validationMapeEvaluator = new MeanAbsolutePercentageErrorEvaluator();
-      validationMapeEvaluator.Name = "ValidationMapeEvaluator";
-      validationMapeEvaluator.GetVariableInfo("MAPE").ActualName = "ValidationMAPE";
-      validationMapeEvaluator.GetVariableInfo("SamplesStart").ActualName = "ValidationSamplesStart";
-      validationMapeEvaluator.GetVariableInfo("SamplesEnd").ActualName = "ValidationSamplesEnd";
-      ProgrammableOperator progOperator = new ProgrammableOperator();
-      progOperator.RemoveVariableInfo("Result");
-      progOperator.AddVariableInfo(new HeuristicLab.Core.VariableInfo("EvaluatedSolutions", "", typeof(IntData), VariableKind.In));
-      progOperator.AddVariableInfo(new HeuristicLab.Core.VariableInfo("SelectionPressure", "", typeof(DoubleData), VariableKind.In));
-      progOperator.Code = @"
-int evalSolutions = EvaluatedSolutions.Data;
-double selectionPressure = SelectionPressure.Data;
-scope.AddVariable(new Variable(""EvaluatedSolutions"", new IntData(evalSolutions)));
-scope.AddVariable(new Variable(""SelectionPressure"", new DoubleData(selectionPressure)));
-";
-      solutionStorer.AddSubOperator(bestSolutionProcessor);
-      bestSolutionProcessor.AddSubOperator(trainingMapeEvaluator);
-      bestSolutionProcessor.AddSubOperator(validationMapeEvaluator);
-      bestSolutionProcessor.AddSubOperator(progOperator);
-      return solutionStorer;
-    }
-
-    private CombinedOperator CreateReplacement() {
-      CombinedOperator replacement = new CombinedOperator();
-      SequentialProcessor seq = new SequentialProcessor();
-      SequentialSubScopesProcessor seqScopeProc = new SequentialSubScopesProcessor();
-      SequentialProcessor selectedProc = new SequentialProcessor();
-      LeftSelector leftSelector = new LeftSelector();
-      leftSelector.GetVariableInfo("Selected").ActualName = "Elites";
-      RightReducer rightReducer = new RightReducer();
-
-      SequentialProcessor remainingProc = new SequentialProcessor();
-      RightSelector rightSelector = new RightSelector();
-      rightSelector.GetVariableInfo("Selected").ActualName = "Elites";
-      LeftReducer leftReducer = new LeftReducer();
-      MergingReducer mergingReducer = new MergingReducer();
-      Sorter sorter = new Sorter();
-      sorter.GetVariableInfo("Descending").ActualName = "Maximization";
-      sorter.GetVariableInfo("Value").ActualName = "Quality";
-
-      seq.AddSubOperator(seqScopeProc);
-      seqScopeProc.AddSubOperator(selectedProc);
-      selectedProc.AddSubOperator(leftSelector);
-      selectedProc.AddSubOperator(rightReducer);
-
-      seqScopeProc.AddSubOperator(remainingProc);
-      remainingProc.AddSubOperator(rightSelector);
-      remainingProc.AddSubOperator(leftReducer);
-      seq.AddSubOperator(mergingReducer);
-      seq.AddSubOperator(sorter);
-      replacement.OperatorGraph.AddOperator(seq);
-      replacement.OperatorGraph.InitialOperator = seq;
-      return replacement;
-    }
-
-    private CombinedOperator CreateChildCreater() {
-      CombinedOperator childCreater = new CombinedOperator();
-      SequentialProcessor seq = new SequentialProcessor();
-      OffspringAnalyzer analyzer = new OffspringAnalyzer();
-      analyzer.GetVariableInfo("ComparisonFactor").Local = false;
-      analyzer.RemoveVariable("ComparisonFactor");
-      SequentialProcessor selectedProc = new SequentialProcessor();
-      OperatorExtractor crossover = new OperatorExtractor();
-      crossover.Name = "Crossover (extr.)";
-      crossover.GetVariableInfo("Operator").ActualName = "Crossover";
-      UniformSequentialSubScopesProcessor individualProc = new UniformSequentialSubScopesProcessor();
-      SequentialProcessor individualSeqProc = new SequentialProcessor();
-      StochasticBranch cond = new StochasticBranch();
-      cond.GetVariableInfo("Probability").ActualName = "MutationRate";
-      OperatorExtractor manipulator = new OperatorExtractor();
-      manipulator.Name = "Manipulator (extr.)";
-      manipulator.GetVariableInfo("Operator").ActualName = "Manipulator";
-      OperatorExtractor evaluator = new OperatorExtractor();
-      evaluator.Name = "Evaluator (extr.)";
-      evaluator.GetVariableInfo("Operator").ActualName = "Evaluator";
-      MeanSquaredErrorEvaluator validationEvaluator = new MeanSquaredErrorEvaluator();
-      validationEvaluator.GetVariableInfo("MSE").ActualName = "ValidationQuality";
-      validationEvaluator.GetVariableInfo("SamplesStart").ActualName = "ValidationSamplesStart";
-      validationEvaluator.GetVariableInfo("SamplesEnd").ActualName = "ValidationSamplesEnd";
-      Counter evalCounter = new Counter();
-      evalCounter.GetVariableInfo("Value").ActualName = "EvaluatedSolutions";
-
-      Sorter sorter = new Sorter();
-      sorter.GetVariableInfo("Descending").ActualName = "Maximization";
-      sorter.GetVariableInfo("Value").ActualName = "Quality";
-      seq.AddSubOperator(analyzer);
-      analyzer.AddSubOperator(selectedProc);
-      selectedProc.AddSubOperator(crossover);
-      selectedProc.AddSubOperator(individualProc);
-      individualProc.AddSubOperator(individualSeqProc);
-      individualSeqProc.AddSubOperator(cond);
-      cond.AddSubOperator(manipulator);
-      individualSeqProc.AddSubOperator(evaluator);
-      individualSeqProc.AddSubOperator(validationEvaluator);
-      individualSeqProc.AddSubOperator(evalCounter);
-      seq.AddSubOperator(sorter);
-
-      childCreater.OperatorGraph.AddOperator(seq);
-      childCreater.OperatorGraph.InitialOperator = seq;
-      return childCreater;
-    }
-
-    public IEditor CreateEditor() {
+    public override IEditor CreateEditor() {
       return new OffspringSelectionGpEditor(this);
     }
@@ -533 +206 @@
 
     public override object Clone(IDictionary<Guid, object> clonedObjects) {
-      OffspringSelectionGP clone = new OffspringSelectionGP();
-      clonedObjects.Add(Guid, clone);
-      clone.engine = (SequentialEngine.SequentialEngine)Auxiliary.Clone(Engine, clonedObjects);
+      OffspringSelectionGP clone = (OffspringSelectionGP)base.Clone(clonedObjects);
+      clone.SelectionPressureLimit = SelectionPressureLimit;
+      clone.SuccessRatioLimit = SuccessRatioLimit;
+      clone.ComparisonFactor = ComparisonFactor;
       return clone;
     }
+
     #region SetReferences Method
     private void SetReferences() {
@@ -543 +218 @@
       CombinedOperator co1 = (CombinedOperator)Engine.OperatorGraph.InitialOperator;
       // SequentialProcessor in SGA
-      algorithm = (SequentialProcessor)co1.OperatorGraph.InitialOperator;
+      SequentialProcessor algorithm = (SequentialProcessor)co1.OperatorGraph.InitialOperator;
       // RandomInjector
       RandomInjector ri = (RandomInjector)algorithm.SubOperators[1];
-      setSeedRandomly = ri.GetVariable("SetSeedRandomly").GetValue<BoolData>();
-      seed = ri.GetVariable("Seed").GetValue<IntData>();
       // VariableInjector
       VariableInjector vi = (VariableInjector)algorithm.SubOperators[2];
-      populationSize = vi.GetVariable("PopulationSize").GetValue<IntData>();
-      parents = vi.GetVariable("Parents").GetValue<IntData>();
-      maxGenerations = vi.GetVariable("MaxGenerations").GetValue<IntData>();
-      mutationRate = vi.GetVariable("MutationRate").GetValue<DoubleData>();
-      elites = vi.GetVariable("Elites").GetValue<IntData>();
-      maxTreeSize = vi.GetVariable("MaxTreeSize").GetValue<IntData>();
-      maxTreeHeight = vi.GetVariable("MaxTreeHeight").GetValue<IntData>();
+      maxEvaluatedSolutions = vi.GetVariable("MaxEvaluatedSolutions").GetValue<IntData>();
+      selectionPressureLimit = vi.GetVariable("SelectionPressureLimit").GetValue<DoubleData>();
+      successRatioLimit = vi.GetVariable("SuccessRatioLimit").GetValue<DoubleData>();
+      comparisonFactor = vi.GetVariable("ComparisonFactor").GetValue<DoubleData>();
     }
     #endregion
@@ -563 +233 @@
     public override XmlNode GetXmlNode(string name, XmlDocument document, IDictionary<Guid, IStorable> persistedObjects) {
       XmlNode node = base.GetXmlNode(name, document, persistedObjects);
-      node.AppendChild(PersistenceManager.Persist("Engine", Engine, document, persistedObjects));
       return node;
     }
     public override void Populate(XmlNode node, IDictionary<Guid, IStorable> restoredObjects) {
       base.Populate(node, restoredObjects);
-      engine = (SequentialEngine.SequentialEngine)PersistenceManager.Restore(node.SelectSingleNode("Engine"), restoredObjects);
       SetReferences();
     }

branches/CEDMA-Refactoring-Ticket419/HeuristicLab.GP.StructureIdentification/StandardGP.cs

@@ -194 +194 @@
     }
 
-    public IEditor CreateEditor() {
+    public virtual IEditor CreateEditor() {
       return new StandardGpEditor(this);
     }
@@ -208 +208 @@
       return clone;
     }
+
     #region SetReferences Method
     private void SetReferences() {