Changeset 1262

Timestamp:

03/05/09 18:32:59 (15 years ago)

Author:

gkronber

Message:

Fixed a few issues in persistence of hard-coded GP algorithms. #224 (Simple frontend for GP for non-expert users (similar to HeurisicLab.SGA))

Location:

branches/CEDMA-Refactoring-Ticket419

Files:

• HeuristicLab.GP.StructureIdentification.TimeSeries/OffspringSelectionGP.cs (modified) (3 diffs)
• HeuristicLab.GP.StructureIdentification.TimeSeries/OffspringSelectionGpEditor.cs (modified) (1 diff)
• HeuristicLab.GP.StructureIdentification.TimeSeries/StandardGP.cs (modified) (3 diffs)
• HeuristicLab.GP.StructureIdentification/AlgorithmBase.cs (modified) (7 diffs)
• HeuristicLab.GP.StructureIdentification/OffSpringSelectionGpEditor.Designer.cs (modified) (9 diffs)
• HeuristicLab.GP.StructureIdentification/OffSpringSelectionGpEditor.cs (modified) (2 diffs)
• HeuristicLab.GP.StructureIdentification/OffspringSelectionGP.cs (modified) (4 diffs)
• HeuristicLab.GP.StructureIdentification/StandardGP.cs (modified) (5 diffs)
• HeuristicLab.GP.StructureIdentification/StandardGpEditor.Designer.cs (modified) (1 diff)
• HeuristicLab.GP.StructureIdentification/StandardGpEditor.cs (modified) (1 diff)

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

@@ -34 +34 @@
 namespace HeuristicLab.GP.StructureIdentification.TimeSeries {
   public class OffspringSelectionGP : HeuristicLab.GP.StructureIdentification.OffspringSelectionGP {
-    private BoolData autoregressive = new BoolData();
-    public bool Autoregressive {
-      get { return autoregressive.Data; }
-      set { autoregressive.Data = value; }
+    public virtual bool Autoregressive {
+      get { return GetVariableInjector().GetVariable("Autoregressive").GetValue<BoolData>().Data; }
+      set { GetVariableInjector().GetVariable("Autoregressive").GetValue<BoolData>().Data = value; }
     }
-    
+
     protected override IOperator CreateFunctionLibraryInjector() {
       return new FunctionLibraryInjector();
@@ -50 +49 @@
     protected override IOperator CreateGlobalInjector() {
       VariableInjector injector = (VariableInjector)base.CreateGlobalInjector();
-      injector.AddVariable(new HeuristicLab.Core.Variable("Autoregressive", autoregressive));
+      injector.AddVariable(new HeuristicLab.Core.Variable("Autoregressive", new BoolData()));
       return injector;
     }
@@ -67 +66 @@
       return new OffspringSelectionGpEditor(this);
     }
+
+    public override object Clone(IDictionary<Guid, object> clonedObjects) {
+      OffspringSelectionGP clone = (OffspringSelectionGP)base.Clone(clonedObjects);
+      clone.Autoregressive = Autoregressive;
+      return clone;
+    }
   }
 }

branches/CEDMA-Refactoring-Ticket419/HeuristicLab.GP.StructureIdentification.TimeSeries/OffspringSelectionGpEditor.cs

@@ -19 +19 @@
 
     protected override void SetDataBinding() {
-      base.SetDataBinding();
+      base.SetDataBinding();      
       autoregressionCheckbox.DataBindings.Add("Checked", OffspringSelectionGP, "Autoregressive");
     }

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

@@ -34 +34 @@
 namespace HeuristicLab.GP.StructureIdentification.TimeSeries {
   public class StandardGP : HeuristicLab.GP.StructureIdentification.StandardGP {
-    private BoolData autoregressive = new BoolData();
     public bool Autoregressive {
-      get { return autoregressive.Data; }
-      set { autoregressive.Data = value; }
+      get { return GetVariableInjector().GetVariable("Autoregressive").GetValue<BoolData>().Data; }
+      set { GetVariableInjector().GetVariable("Autoregressive").GetValue<BoolData>().Data = value; }
     }
 
@@ -50 +49 @@
     protected override IOperator CreateGlobalInjector() {
       VariableInjector injector = (VariableInjector)base.CreateGlobalInjector();
-      injector.AddVariable(new HeuristicLab.Core.Variable("Autoregressive", autoregressive));
+      injector.AddVariable(new HeuristicLab.Core.Variable("Autoregressive", new BoolData()));
       return injector;
     }
@@ -138 +137 @@
       }
     }
+    public override object Clone(IDictionary<Guid, object> clonedObjects) {
+      OffspringSelectionGP clone = (OffspringSelectionGP)base.Clone(clonedObjects);
+      clone.Autoregressive = Autoregressive;
+      return clone;
+    }
   }
 }

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

@@ -37 +37 @@
 namespace HeuristicLab.GP.StructureIdentification {
   public abstract class AlgorithmBase : ItemBase {
-    private DoubleData mutationRate = new DoubleData();
     public virtual double MutationRate {
-      get { return mutationRate.Data; }
-      set { mutationRate.Data = value; }
-    }
-    private IntData populationSize = new IntData();
+      get { return GetVariableInjector().GetVariable("MutationRate").GetValue<DoubleData>().Data; }
+      set { GetVariableInjector().GetVariable("MutationRate").GetValue<DoubleData>().Data = value; }
+    }
     public virtual int PopulationSize {
-      get { return populationSize.Data; }
-      set {
-        populationSize.Data = value;
-      }
-    }
-
-    private BoolData setSeedRandomly = new BoolData();
+      get { return GetVariableInjector().GetVariable("PopulationSize").GetValue<IntData>().Data; }
+      set { GetVariableInjector().GetVariable("PopulationSize").GetValue<IntData>().Data = value; }
+    }
+
     public virtual bool SetSeedRandomly {
-      get { return setSeedRandomly.Data; }
-      set { setSeedRandomly.Data = value; }
-    }
-
-    private IntData seed = new IntData();
+      get { return GetRandomInjector().GetVariable("SetSeedRandomly").GetValue<BoolData>().Data; }
+      set { GetRandomInjector().GetVariable("SetSeedRandomly").GetValue<BoolData>().Data = value; }
+    }
+
     public virtual int Seed {
-      get { return seed.Data; }
-      set { seed.Data = value; }
+      get { return GetRandomInjector().GetVariable("Seed").GetValue<IntData>().Data; }
+      set { GetRandomInjector().GetVariable("Seed").GetValue<IntData>().Data = value; }
     }
 
@@ -71 +65 @@
     }
 
-    private IntData elites = new IntData();
     public virtual int Elites {
-      get { return elites.Data; }
-      set { elites.Data = value; }
-    }
-
-    private int maxTreeSize = 50;
+      get { return GetVariableInjector().GetVariable("Elites").GetValue<IntData>().Data; }
+      set { GetVariableInjector().GetVariable("Elites").GetValue<IntData>().Data = value; }
+    }
+
     public virtual int MaxTreeSize {
-      get { return maxTreeSize; }
-      set { maxTreeSize = value; }
-    }
-
-    private int maxTreeHeight = 8;
+      get { return GetVariableInjector().GetVariable("MaxTreeSize").GetValue<IntData>().Data; }
+      set { GetVariableInjector().GetVariable("MaxTreeSize").GetValue<IntData>().Data = value; }
+    }
+
     public virtual int MaxTreeHeight {
-      get { return maxTreeHeight; }
-      set { maxTreeHeight = value; }
-    }
-
-    private IntData parents = new IntData();
+      get { return GetVariableInjector().GetVariable("MaxTreeHeight").GetValue<IntData>().Data; }
+      set { GetVariableInjector().GetVariable("MaxTreeHeight").GetValue<IntData>().Data = value; }
+    }
+
     public virtual int Parents {
-      get { return parents.Data; }
-      protected set { parents.Data = value; }
-    }
-
-    private double punishmentFactor = 10.0;
-    private bool useEstimatedTargetValue = false;
+      get { return GetVariableInjector().GetVariable("Parents").GetValue<IntData>().Data; }
+      set { GetVariableInjector().GetVariable("Parents").GetValue<IntData>().Data = value; }
+    }
+
+    public virtual double PunishmentFactor {
+      get { return GetVariableInjector().GetVariable("PunishmentFactor").GetValue<DoubleData>().Data; }
+      set { GetVariableInjector().GetVariable("PunishmentFactor").GetValue<DoubleData>().Data = value; }
+    }
+
+    public virtual bool UseEstimatedTargetValue {
+      get { return GetVariableInjector().GetVariable("UseEstimatedTargetValue").GetValue<BoolData>().Data; }
+      set { GetVariableInjector().GetVariable("UseEstimatedTargetValue").GetValue<BoolData>().Data = value; }
+    }
+
     private IOperator algorithm;
 
@@ -119 +117 @@
 
       RandomInjector randomInjector = new RandomInjector();
-      randomInjector.GetVariable("SetSeedRandomly").Value = setSeedRandomly;
-      randomInjector.GetVariable("Seed").Value = seed;
       randomInjector.Name = "Random Injector";
 
       IOperator globalInjector = CreateGlobalInjector();
       IOperator initialization = CreateInitialization();
-      IOperator funLibInjector = CreateFunctionLibraryInjector(); 
+      IOperator funLibInjector = CreateFunctionLibraryInjector();
       IOperator mainLoop = CreateMainLoop();
       mainLoop.Name = "Main loop";
 
       IOperator treeCreator = CreateTreeCreator();
-      
+
       MeanSquaredErrorEvaluator evaluator = new MeanSquaredErrorEvaluator();
       evaluator.GetVariableInfo("MSE").ActualName = "Quality";
@@ -136 +132 @@
       evaluator.GetVariableInfo("SamplesEnd").ActualName = "TrainingSamplesEnd";
       evaluator.Name = "Evaluator";
-      
+
       IOperator crossover = CreateCrossover();
       IOperator manipulator = CreateManipulator();
@@ -180 +176 @@
       injector.Name = "Global Injector";
       injector.AddVariable(new HeuristicLab.Core.Variable("Generations", new IntData(0)));
-      injector.AddVariable(new HeuristicLab.Core.Variable("MutationRate", mutationRate));
-      injector.AddVariable(new HeuristicLab.Core.Variable("PopulationSize", populationSize));
-      injector.AddVariable(new HeuristicLab.Core.Variable("Elites", elites));
+      injector.AddVariable(new HeuristicLab.Core.Variable("MutationRate", new DoubleData()));
+      injector.AddVariable(new HeuristicLab.Core.Variable("PopulationSize", new IntData()));
+      injector.AddVariable(new HeuristicLab.Core.Variable("Elites", new IntData()));
       injector.AddVariable(new HeuristicLab.Core.Variable("Maximization", new BoolData(false)));
-      injector.AddVariable(new HeuristicLab.Core.Variable("MaxTreeHeight", new IntData(maxTreeHeight)));
-      injector.AddVariable(new HeuristicLab.Core.Variable("MaxTreeSize", new IntData(maxTreeSize)));
+      injector.AddVariable(new HeuristicLab.Core.Variable("MaxTreeHeight", new IntData()));
+      injector.AddVariable(new HeuristicLab.Core.Variable("MaxTreeSize", new IntData()));
       injector.AddVariable(new HeuristicLab.Core.Variable("EvaluatedSolutions", new IntData(0)));
       injector.AddVariable(new HeuristicLab.Core.Variable("TotalEvaluatedNodes", new DoubleData(0)));
-      injector.AddVariable(new HeuristicLab.Core.Variable("Parents", parents));
-      injector.AddVariable(new HeuristicLab.Core.Variable("PunishmentFactor", new DoubleData(punishmentFactor)));
-      injector.AddVariable(new HeuristicLab.Core.Variable("UseEstimatedTargetValue", new BoolData(useEstimatedTargetValue)));
+      injector.AddVariable(new HeuristicLab.Core.Variable("Parents", new IntData()));
+      injector.AddVariable(new HeuristicLab.Core.Variable("PunishmentFactor", new DoubleData()));
+      injector.AddVariable(new HeuristicLab.Core.Variable("UseEstimatedTargetValue", new BoolData()));
       return injector;
     }
@@ -392 +388 @@
     }
 
-    #region SetReferences Method
-    private void SetReferences() {
-      // SGA
+    protected VariableInjector GetVariableInjector() {
       CombinedOperator co1 = (CombinedOperator)Engine.OperatorGraph.InitialOperator;
-      // SequentialProcessor in SGA
+      // SequentialProcessor in GP
       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>();
-      mutationRate = vi.GetVariable("MutationRate").GetValue<DoubleData>();
-      elites = vi.GetVariable("Elites").GetValue<IntData>();
-      parents = vi.GetVariable("Parents").GetValue<IntData>();
-    }
-    #endregion
+      return (VariableInjector)algorithm.SubOperators[2];
+    }
+
+    protected RandomInjector GetRandomInjector() {
+      CombinedOperator co1 = (CombinedOperator)Engine.OperatorGraph.InitialOperator;
+      // SequentialProcessor in GP
+      algorithm = (SequentialProcessor)co1.OperatorGraph.InitialOperator;
+      return (RandomInjector)algorithm.SubOperators[1];
+    }
 
     #region Persistence Methods
@@ -420 +411 @@
       base.Populate(node, restoredObjects);
       engine = (SequentialEngine.SequentialEngine)PersistenceManager.Restore(node.SelectSingleNode("Engine"), restoredObjects);
-      SetReferences();
     }
     #endregion

branches/CEDMA-Refactoring-Ticket419/HeuristicLab.GP.StructureIdentification/OffSpringSelectionGpEditor.Designer.cs

@@ -49 +49 @@
       this.tabControl = new System.Windows.Forms.TabControl();
       this.parametersTabPage = new System.Windows.Forms.TabPage();
+      this.selectionPressureTextBox = new System.Windows.Forms.TextBox();
+      this.selectionPressureLabel = new System.Windows.Forms.Label();
       this.viewProblemInitializationButton = new System.Windows.Forms.Button();
       this.setProblemInitializationButton = new System.Windows.Forms.Button();
@@ -58 +60 @@
       this.mutationRateTextBox = new System.Windows.Forms.TextBox();
       this.mutationRateLabel = new System.Windows.Forms.Label();
-      this.maximumGenerationsTextBox = new System.Windows.Forms.TextBox();
-      this.maximumGenerationsLabel = new System.Windows.Forms.Label();
+      this.maximumEvaluatedSolutionsTextBox = new System.Windows.Forms.TextBox();
+      this.maxEvaluatedSolutionsLabel = new System.Windows.Forms.Label();
       this.randomSeedTextBox = new System.Windows.Forms.TextBox();
       this.populationSizeTextBox = new System.Windows.Forms.TextBox();
@@ -70 +72 @@
       this.resetButton = new System.Windows.Forms.Button();
       this.cloneEngineButton = new System.Windows.Forms.Button();
-      this.selectionPressureTextBox = new System.Windows.Forms.TextBox();
-      this.selectionPressureLabel = new System.Windows.Forms.Label();
       this.tabControl.SuspendLayout();
       this.parametersTabPage.SuspendLayout();
@@ -114 +114 @@
       this.parametersTabPage.Controls.Add(this.mutationRateTextBox);
       this.parametersTabPage.Controls.Add(this.mutationRateLabel);
-      this.parametersTabPage.Controls.Add(this.maximumGenerationsTextBox);
-      this.parametersTabPage.Controls.Add(this.maximumGenerationsLabel);
+      this.parametersTabPage.Controls.Add(this.maximumEvaluatedSolutionsTextBox);
+      this.parametersTabPage.Controls.Add(this.maxEvaluatedSolutionsLabel);
       this.parametersTabPage.Controls.Add(this.randomSeedTextBox);
       this.parametersTabPage.Controls.Add(this.populationSizeTextBox);
@@ -129 +129 @@
       this.parametersTabPage.UseVisualStyleBackColor = true;
       // 
+      // selectionPressureTextBox
+      // 
+      this.selectionPressureTextBox.Anchor = System.Windows.Forms.AnchorStyles.None;
+      this.selectionPressureTextBox.Location = new System.Drawing.Point(218, 130);
+      this.selectionPressureTextBox.Name = "selectionPressureTextBox";
+      this.selectionPressureTextBox.Size = new System.Drawing.Size(186, 20);
+      this.selectionPressureTextBox.TabIndex = 17;
+      // 
+      // selectionPressureLabel
+      // 
+      this.selectionPressureLabel.Anchor = System.Windows.Forms.AnchorStyles.None;
+      this.selectionPressureLabel.AutoSize = true;
+      this.selectionPressureLabel.Location = new System.Drawing.Point(65, 133);
+      this.selectionPressureLabel.Name = "selectionPressureLabel";
+      this.selectionPressureLabel.Size = new System.Drawing.Size(145, 13);
+      this.selectionPressureLabel.TabIndex = 16;
+      this.selectionPressureLabel.Text = "Maximum &Selection Pressure:";
+      // 
       // viewProblemInitializationButton
       // 
@@ -169 +187 @@
       this.setRandomSeedRandomlyCheckBox.TabIndex = 1;
       this.setRandomSeedRandomlyCheckBox.UseVisualStyleBackColor = true;
+      this.setRandomSeedRandomlyCheckBox.CheckedChanged += new System.EventHandler(this.setRandomSeedRandomlyCheckBox_CheckedChanged);
       // 
       // elitesTextBox
@@ -216 +235 @@
       this.mutationRateLabel.Text = "&Mutation Rate:";
       // 
-      // maximumGenerationsTextBox
-      // 
-      this.maximumGenerationsTextBox.Anchor = System.Windows.Forms.AnchorStyles.None;
-      this.maximumGenerationsTextBox.Location = new System.Drawing.Point(218, 104);
-      this.maximumGenerationsTextBox.Name = "maximumGenerationsTextBox";
-      this.maximumGenerationsTextBox.Size = new System.Drawing.Size(186, 20);
-      this.maximumGenerationsTextBox.TabIndex = 7;
-      // 
-      // maximumGenerationsLabel
-      // 
-      this.maximumGenerationsLabel.Anchor = System.Windows.Forms.AnchorStyles.None;
-      this.maximumGenerationsLabel.AutoSize = true;
-      this.maximumGenerationsLabel.Location = new System.Drawing.Point(65, 107);
-      this.maximumGenerationsLabel.Name = "maximumGenerationsLabel";
-      this.maximumGenerationsLabel.Size = new System.Drawing.Size(114, 13);
-      this.maximumGenerationsLabel.TabIndex = 6;
-      this.maximumGenerationsLabel.Text = "Maximum &Generations:";
+      // maximumEvaluatedSolutionsTextBox
+      // 
+      this.maximumEvaluatedSolutionsTextBox.Anchor = System.Windows.Forms.AnchorStyles.None;
+      this.maximumEvaluatedSolutionsTextBox.Location = new System.Drawing.Point(218, 104);
+      this.maximumEvaluatedSolutionsTextBox.Name = "maximumEvaluatedSolutionsTextBox";
+      this.maximumEvaluatedSolutionsTextBox.Size = new System.Drawing.Size(186, 20);
+      this.maximumEvaluatedSolutionsTextBox.TabIndex = 7;
+      // 
+      // maxEvaluatedSolutionsLabel
+      // 
+      this.maxEvaluatedSolutionsLabel.Anchor = System.Windows.Forms.AnchorStyles.None;
+      this.maxEvaluatedSolutionsLabel.AutoSize = true;
+      this.maxEvaluatedSolutionsLabel.Location = new System.Drawing.Point(65, 107);
+      this.maxEvaluatedSolutionsLabel.Name = "maxEvaluatedSolutionsLabel";
+      this.maxEvaluatedSolutionsLabel.Size = new System.Drawing.Size(130, 13);
+      this.maxEvaluatedSolutionsLabel.TabIndex = 6;
+      this.maxEvaluatedSolutionsLabel.Text = "Max. E&valuated Solutions:";
       // 
       // randomSeedTextBox
@@ -334 +353 @@
       this.cloneEngineButton.UseVisualStyleBackColor = true;
       this.cloneEngineButton.Click += new System.EventHandler(this.cloneEngineButton_Click);
-      // 
-      // selectionPressureTextBox
-      // 
-      this.selectionPressureTextBox.Anchor = System.Windows.Forms.AnchorStyles.None;
-      this.selectionPressureTextBox.Location = new System.Drawing.Point(218, 130);
-      this.selectionPressureTextBox.Name = "selectionPressureTextBox";
-      this.selectionPressureTextBox.Size = new System.Drawing.Size(186, 20);
-      this.selectionPressureTextBox.TabIndex = 17;
-      // 
-      // selectionPressureLabel
-      // 
-      this.selectionPressureLabel.Anchor = System.Windows.Forms.AnchorStyles.None;
-      this.selectionPressureLabel.AutoSize = true;
-      this.selectionPressureLabel.Location = new System.Drawing.Point(65, 133);
-      this.selectionPressureLabel.Name = "selectionPressureLabel";
-      this.selectionPressureLabel.Size = new System.Drawing.Size(145, 13);
-      this.selectionPressureLabel.TabIndex = 16;
-      this.selectionPressureLabel.Text = "Maximum &Selection Pressure:";
       // 
       // OffspringSelectionGpEditor
@@ -384 +385 @@
     private System.Windows.Forms.Label populationSizeLabel;
     private System.Windows.Forms.TabPage scopesTabPage;
-    private System.Windows.Forms.TextBox maximumGenerationsTextBox;
-    private System.Windows.Forms.Label maximumGenerationsLabel;
+    private System.Windows.Forms.TextBox maximumEvaluatedSolutionsTextBox;
+    private System.Windows.Forms.Label maxEvaluatedSolutionsLabel;
     private System.Windows.Forms.TextBox elitesTextBox;
     private System.Windows.Forms.Label elitesLabel;

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

@@ -76 +76 @@
       randomSeedTextBox.DataBindings.Add("Text", OffspringSelectionGP, "Seed");
       populationSizeTextBox.DataBindings.Add("Text", OffspringSelectionGP, "PopulationSize");
-      maximumGenerationsTextBox.DataBindings.Add("Text", OffspringSelectionGP, "MaxGenerations");
+      maximumEvaluatedSolutionsTextBox.DataBindings.Add("Text", OffspringSelectionGP, "MaxEvaluatedSolutions");
       selectionPressureTextBox.DataBindings.Add("Text", OffspringSelectionGP, "SelectionPressureLimit");
       mutationRateTextBox.DataBindings.Add("Text", OffspringSelectionGP, "MutationRate");
@@ -134 +134 @@
     }
     #endregion
+
+    private void setRandomSeedRandomlyCheckBox_CheckedChanged(object sender, EventArgs e) {
+      randomSeedTextBox.Enabled = !setRandomSeedRandomlyCheckBox.Checked;
+      randomSeedLabel.Enabled = !setRandomSeedRandomlyCheckBox.Checked;
+    }
   }
 }

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

@@ -39 +39 @@
   public class OffspringSelectionGP : StandardGP {
 
-    private IntData maxEvaluatedSolutions = new IntData();
-    public int MaxEvaluatedSolutions {
-      get { return maxEvaluatedSolutions.Data; }
-      set { maxEvaluatedSolutions.Data = value; }
-    }
-
-    private DoubleData selectionPressureLimit = new DoubleData();
-    public double SelectionPressureLimit {
-      get { return selectionPressureLimit.Data; }
-      set { selectionPressureLimit.Data = value; }
-    }
-
-    private DoubleData comparisonFactor = new DoubleData();
-    public double ComparisonFactor {
-      get { return comparisonFactor.Data; }
-      set { comparisonFactor.Data = value; }
-    }
-
-    private DoubleData successRatioLimit = new DoubleData();
-    public double SuccessRatioLimit {
-      get { return successRatioLimit.Data; }
-      set { successRatioLimit.Data = value; }
-    }
-
-    public OffspringSelectionGP() : base() {
+    public virtual int MaxEvaluatedSolutions {
+      get { return GetVariableInjector().GetVariable("MaxEvaluatedSolutions").GetValue<IntData>().Data; }
+      set { GetVariableInjector().GetVariable("MaxEvaluatedSolutions").GetValue<IntData>().Data = value; }
+    }
+
+    public virtual double SelectionPressureLimit {
+      get { return GetVariableInjector().GetVariable("SelectionPressureLimit").GetValue<DoubleData>().Data; }
+      set { GetVariableInjector().GetVariable("SelectionPressureLimit").GetValue<DoubleData>().Data = value; }
+    }
+
+    public virtual double ComparisonFactor {
+      get { return GetVariableInjector().GetVariable("ComparisonFactor").GetValue<DoubleData>().Data; }
+      set { GetVariableInjector().GetVariable("ComparisonFactor").GetValue<DoubleData>().Data = value; }
+    }
+
+    public virtual double SuccessRatioLimit {
+      get { return GetVariableInjector().GetVariable("SuccessRatioLimit").GetValue<DoubleData>().Data; }
+      set { GetVariableInjector().GetVariable("SuccessRatioLimit").GetValue<DoubleData>().Data = value; }
+    }
+
+    public override int MaxGenerations {
+      get { throw new NotSupportedException(); }
+      set { /* ignore */ }
+    }
+
+    public override int TournamentSize {
+      get { throw new NotSupportedException(); }
+      set { /* ignore */ }
+    }
+
+    public OffspringSelectionGP()
+      : base() {
       PopulationSize = 1000;
       Parents = 20;
@@ -76 +83 @@
       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("SelectionPressureLimit", selectionPressureLimit));
-      injector.AddVariable(new HeuristicLab.Core.Variable("SuccessRatioLimit", successRatioLimit));
+      injector.AddVariable(new HeuristicLab.Core.Variable("MaxEvaluatedSolutions", new IntData()));
+      injector.AddVariable(new HeuristicLab.Core.Variable("ComparisonFactor", new DoubleData()));
+      injector.AddVariable(new HeuristicLab.Core.Variable("SelectionPressureLimit", new DoubleData()));
+      injector.AddVariable(new HeuristicLab.Core.Variable("SuccessRatioLimit", new DoubleData()));
       return injector;
     }
@@ -199 +206 @@
       selPresComparator.GetVariableInfo("RightSide").ActualName = "SelectionPressureLimit";
       selPresComparator.GetVariableInfo("Result").ActualName = "SelectionPressureCondition";
-      
+
       ConditionalBranch generationsCond = new ConditionalBranch();
       generationsCond.GetVariableInfo("Condition").ActualName = "EvaluatedSolutionsCondition";
@@ -261 +268 @@
       return clone;
     }
-
-    #region SetReferences Method
-    private void SetReferences() {
-      // SGA
-      CombinedOperator co1 = (CombinedOperator)Engine.OperatorGraph.InitialOperator;
-      // SequentialProcessor in SGA
-      SequentialProcessor algorithm = (SequentialProcessor)co1.OperatorGraph.InitialOperator;
-      // RandomInjector
-      RandomInjector ri = (RandomInjector)algorithm.SubOperators[1];
-      // VariableInjector
-      VariableInjector vi = (VariableInjector)algorithm.SubOperators[2];
-      selectionPressureLimit = vi.GetVariable("SelectionPressureLimit").GetValue<DoubleData>();
-      successRatioLimit = vi.GetVariable("SuccessRatioLimit").GetValue<DoubleData>();
-      comparisonFactor = vi.GetVariable("ComparisonFactor").GetValue<DoubleData>();
-    }
-    #endregion
-
-    #region Persistence Methods
-    public override XmlNode GetXmlNode(string name, XmlDocument document, IDictionary<Guid, IStorable> persistedObjects) {
-      XmlNode node = base.GetXmlNode(name, document, persistedObjects);
-      return node;
-    }
-    public override void Populate(XmlNode node, IDictionary<Guid, IStorable> restoredObjects) {
-      base.Populate(node, restoredObjects);
-      SetReferences();
-    }
-    #endregion
   }
 }

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

@@ -38 +38 @@
   public class StandardGP : AlgorithmBase, IEditable {
 
-    private IntData maxGenerations = new IntData();
-    public int MaxGenerations {
-      get { return maxGenerations.Data; }
-      set { maxGenerations.Data = value; }
-    }
-
-    private IntData tournamentSize = new IntData();
-    public int TournamentSize {
-      get { return tournamentSize.Data; }
-      set { tournamentSize.Data = value; }
-    }
-
-    private DoubleData fullTreeShakingFactor = new DoubleData();
+    public virtual int MaxGenerations {
+      get { return GetVariableInjector().GetVariable("MaxGenerations").GetValue<IntData>().Data; }
+      set { GetVariableInjector().GetVariable("MaxGenerations").GetValue<IntData>().Data = value; }
+    }
+
+    public virtual int TournamentSize {
+      get { return GetVariableInjector().GetVariable("TournamentSize").GetValue<IntData>().Data; }
+      set { GetVariableInjector().GetVariable("TournamentSize").GetValue<IntData>().Data = value; }
+    }
+
     public double FullTreeShakingFactor {
-      get { return fullTreeShakingFactor.Data; }
-      set { fullTreeShakingFactor.Data = value; }
-    }
-
-    private DoubleData onepointShakingFactor = new DoubleData();
+      get { return GetVariableInjector().GetVariable("FullTreeShakingFactor").GetValue<DoubleData>().Data; }
+      set { GetVariableInjector().GetVariable("FullTreeShakingFactor").GetValue<DoubleData>().Data = value; }
+    }
+
     public double OnePointShakingFactor {
-      get { return onepointShakingFactor.Data; }
-      set { onepointShakingFactor.Data = value; }
+      get { return GetVariableInjector().GetVariable("OnePointShakingFactor").GetValue<DoubleData>().Data; }
+      set { GetVariableInjector().GetVariable("OnePointShakingFactor").GetValue<DoubleData>().Data = value; }
     }
 
@@ -83 +79 @@
       FullTreeShakingFactor = 0.1;
       OnePointShakingFactor = 1.0;
-      Engine = new SequentialEngine.SequentialEngine();
-      IOperator algo = CreateAlgorithm();
-      Engine.OperatorGraph.AddOperator(algo);
-      Engine.OperatorGraph.InitialOperator = algo;
+      PunishmentFactor = 10.0;
+      UseEstimatedTargetValue = false;
+      SetSeedRandomly = true;
     }
 
@@ -105 +100 @@
     protected internal override IOperator CreateGlobalInjector() {
       VariableInjector globalInjector = (VariableInjector)base.CreateGlobalInjector();
-      globalInjector.AddVariable(new HeuristicLab.Core.Variable("TournamentSize", tournamentSize));
-      globalInjector.AddVariable(new HeuristicLab.Core.Variable("MaxGenerations", maxGenerations));
+      globalInjector.AddVariable(new HeuristicLab.Core.Variable("TournamentSize", new IntData()));
+      globalInjector.AddVariable(new HeuristicLab.Core.Variable("MaxGenerations", new IntData()));
+      globalInjector.AddVariable(new HeuristicLab.Core.Variable("FullTreeShakingFactor", new DoubleData()));
+      globalInjector.AddVariable(new HeuristicLab.Core.Variable("OnePointShakingFactor", new DoubleData()));
       return globalInjector;
     }
@@ -136 +133 @@
       FullTreeShaker fullTreeShaker = new FullTreeShaker();
       fullTreeShaker.GetVariableInfo("OperatorLibrary").ActualName = "FunctionLibrary";
-      fullTreeShaker.GetVariableInfo("ShakingFactor").Local = true;
-      fullTreeShaker.AddVariable(new HeuristicLab.Core.Variable("ShakingFactor", fullTreeShakingFactor));
+      fullTreeShaker.GetVariableInfo("ShakingFactor").ActualName = "FullTreeShakingFactor";
 
       OnePointShaker onepointShaker = new OnePointShaker();
       onepointShaker.GetVariableInfo("OperatorLibrary").ActualName = "FunctionLibrary";
-      onepointShaker.GetVariableInfo("ShakingFactor").Local = true;
-      onepointShaker.AddVariable(new HeuristicLab.Core.Variable("ShakingFactor", onepointShakingFactor));
+      onepointShaker.GetVariableInfo("ShakingFactor").ActualName = "OnePointShakingFactor";
       ChangeNodeTypeManipulation changeNodeTypeManipulation = new ChangeNodeTypeManipulation();
       changeNodeTypeManipulation.GetVariableInfo("OperatorLibrary").ActualName = "FunctionLibrary";
@@ -248 +243 @@
       return new StandardGpEditor(this);
     }
-
-    public override object Clone(IDictionary<Guid, object> clonedObjects) {
-      StandardGP clone = new StandardGP();
-      clonedObjects.Add(Guid, clone);
-      clone.Engine = (SequentialEngine.SequentialEngine)Auxiliary.Clone(Engine, clonedObjects);
-      return clone;
-    }
-
-    #region SetReferences Method
-    private void SetReferences() {
-      // SGA
-      CombinedOperator co1 = (CombinedOperator)Engine.OperatorGraph.InitialOperator;
-      // SequentialProcessor in SGA
-      SequentialProcessor algorithm = (SequentialProcessor)co1.OperatorGraph.InitialOperator;
-      // RandomInjector
-      RandomInjector ri = (RandomInjector)algorithm.SubOperators[1];
-      // VariableInjector
-      VariableInjector vi = (VariableInjector)algorithm.SubOperators[2];
-      maxGenerations = vi.GetVariable("MaxGenerations").GetValue<IntData>();
-      tournamentSize = vi.GetVariable("TournamentSize").GetValue<IntData>();
-    }
-    #endregion
-
-    #region Persistence Methods
-    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();
-    }
-    #endregion
   }
 }

branches/CEDMA-Refactoring-Ticket419/HeuristicLab.GP.StructureIdentification/StandardGpEditor.Designer.cs

@@ -165 +165 @@
       this.setRandomSeedRandomlyCheckBox.TabIndex = 1;
       this.setRandomSeedRandomlyCheckBox.UseVisualStyleBackColor = true;
+      this.setRandomSeedRandomlyCheckBox.CheckedChanged += new System.EventHandler(this.setRandomSeedRandomlyCheckBox_CheckedChanged);
       // 
       // elitesTextBox

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

@@ -133 +133 @@
     #endregion
 
-
+    private void setRandomSeedRandomlyCheckBox_CheckedChanged(object sender, EventArgs e) {
+      randomSeedTextBox.Enabled = !setRandomSeedRandomlyCheckBox.Checked;
+      randomSeedLabel.Enabled = !setRandomSeedRandomlyCheckBox.Checked;
+    }
   }
 }