Changeset 3048 for trunk/sources/HeuristicLab.Algorithms.SGA/3.3

Timestamp:

03/15/10 23:49:54 (15 years ago)

Author:

swagner

Message:

Renamed classes of HeuristicLab.Data (#909)

Location:

trunk/sources/HeuristicLab.Algorithms.SGA/3.3

Files:

• SGA.cs (modified) (6 diffs)
• SGAMainLoop.cs (modified) (9 diffs)

trunk/sources/HeuristicLab.Algorithms.SGA/3.3/SGA.cs

@@ -51 +51 @@
 
     #region Parameter Properties
-    private ValueParameter<IntData> SeedParameter {
-      get { return (ValueParameter<IntData>)Parameters["Seed"]; }
-    }
-    private ValueParameter<BoolData> SetSeedRandomlyParameter {
-      get { return (ValueParameter<BoolData>)Parameters["SetSeedRandomly"]; }
-    }
-    private ValueParameter<IntData> PopulationSizeParameter {
-      get { return (ValueParameter<IntData>)Parameters["PopulationSize"]; }
+    private ValueParameter<IntValue> SeedParameter {
+      get { return (ValueParameter<IntValue>)Parameters["Seed"]; }
+    }
+    private ValueParameter<BoolValue> SetSeedRandomlyParameter {
+      get { return (ValueParameter<BoolValue>)Parameters["SetSeedRandomly"]; }
+    }
+    private ValueParameter<IntValue> PopulationSizeParameter {
+      get { return (ValueParameter<IntValue>)Parameters["PopulationSize"]; }
     }
     private ConstrainedValueParameter<ISelector> SelectorParameter {
@@ -66 +66 @@
       get { return (ConstrainedValueParameter<ICrossover>)Parameters["Crossover"]; }
     }
-    private ValueParameter<DoubleData> MutationProbabilityParameter {
-      get { return (ValueParameter<DoubleData>)Parameters["MutationProbability"]; }
+    private ValueParameter<DoubleValue> MutationProbabilityParameter {
+      get { return (ValueParameter<DoubleValue>)Parameters["MutationProbability"]; }
     }
     private OptionalConstrainedValueParameter<IManipulator> MutatorParameter {
       get { return (OptionalConstrainedValueParameter<IManipulator>)Parameters["Mutator"]; }
     }
-    private ValueParameter<IntData> ElitesParameter {
-      get { return (ValueParameter<IntData>)Parameters["Elites"]; }
-    }
-    private ValueParameter<IntData> MaximumGenerationsParameter {
-      get { return (ValueParameter<IntData>)Parameters["MaximumGenerations"]; }
+    private ValueParameter<IntValue> ElitesParameter {
+      get { return (ValueParameter<IntValue>)Parameters["Elites"]; }
+    }
+    private ValueParameter<IntValue> MaximumGenerationsParameter {
+      get { return (ValueParameter<IntValue>)Parameters["MaximumGenerations"]; }
     }
     #endregion
 
     #region Properties
-    public IntData Seed {
+    public IntValue Seed {
       get { return SeedParameter.Value; }
       set { SeedParameter.Value = value; }
     }
-    public BoolData SetSeedRandomly {
+    public BoolValue SetSeedRandomly {
       get { return SetSeedRandomlyParameter.Value; }
       set { SetSeedRandomlyParameter.Value = value; }
     }
-    public IntData PopulationSize {
+    public IntValue PopulationSize {
       get { return PopulationSizeParameter.Value; }
       set { PopulationSizeParameter.Value = value; }
@@ -101 +101 @@
       set { CrossoverParameter.Value = value; }
     }
-    public DoubleData MutationProbability {
+    public DoubleValue MutationProbability {
       get { return MutationProbabilityParameter.Value; }
       set { MutationProbabilityParameter.Value = value; }
@@ -109 +109 @@
       set { MutatorParameter.Value = value; }
     }
-    public IntData Elites {
+    public IntValue Elites {
       get { return ElitesParameter.Value; }
       set { ElitesParameter.Value = value; }
     }
-    public IntData MaximumGenerations {
+    public IntValue MaximumGenerations {
       get { return MaximumGenerationsParameter.Value; }
       set { MaximumGenerationsParameter.Value = value; }
@@ -134 +134 @@
     public SGA()
       : base() {
-      Parameters.Add(new ValueParameter<IntData>("Seed", "The random seed used to initialize the new pseudo random number generator.", new IntData(0)));
-      Parameters.Add(new ValueParameter<BoolData>("SetSeedRandomly", "True if the random seed should be set to a random value, otherwise false.", new BoolData(true)));
-      Parameters.Add(new ValueParameter<IntData>("PopulationSize", "The size of the population of solutions.", new IntData(100)));
+      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>("PopulationSize", "The size of the population of solutions.", 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 ValueParameter<DoubleData>("MutationProbability", "The probability that the mutation operator is applied on a solution.", new DoubleData(0.05)));
+      Parameters.Add(new ValueParameter<DoubleValue>("MutationProbability", "The probability that the mutation operator is applied on a solution.", new DoubleValue(0.05)));
       Parameters.Add(new OptionalConstrainedValueParameter<IManipulator>("Mutator", "The operator used to mutate solutions."));
-      Parameters.Add(new ValueParameter<IntData>("Elites", "The numer of elite solutions which are kept in each generation.", new IntData(1)));
-      Parameters.Add(new ValueParameter<IntData>("MaximumGenerations", "The maximum number of generations which should be processed.", new IntData(1000)));
+      Parameters.Add(new ValueParameter<IntValue>("Elites", "The numer of elite solutions which are kept in each generation.", new IntValue(1)));
+      Parameters.Add(new ValueParameter<IntValue>("MaximumGenerations", "The maximum number of generations which should be processed.", new IntValue(1000)));
 
       RandomCreator randomCreator = new RandomCreator();
@@ -266 +266 @@
     private void ParameterizeSelectors() {
       foreach (ISelector selector in Selectors) {
-        selector.CopySelected = new BoolData(true);
-        selector.NumberOfSelectedSubScopesParameter.Value = new IntData(2 * (PopulationSizeParameter.Value.Value - ElitesParameter.Value.Value));
+        selector.CopySelected = new BoolValue(true);
+        selector.NumberOfSelectedSubScopesParameter.Value = new IntValue(2 * (PopulationSizeParameter.Value.Value - ElitesParameter.Value.Value));
         ParameterizeStochasticOperator(selector);
       }

trunk/sources/HeuristicLab.Algorithms.SGA/3.3/SGAMainLoop.cs

@@ -41 +41 @@
       get { return (ValueLookupParameter<IRandom>)Parameters["Random"]; }
     }
-    public ValueLookupParameter<BoolData> MaximizationParameter {
-      get { return (ValueLookupParameter<BoolData>)Parameters["Maximization"]; }
-    }
-    public SubScopesLookupParameter<DoubleData> QualityParameter {
-      get { return (SubScopesLookupParameter<DoubleData>)Parameters["Quality"]; }
+    public ValueLookupParameter<BoolValue> MaximizationParameter {
+      get { return (ValueLookupParameter<BoolValue>)Parameters["Maximization"]; }
+    }
+    public SubScopesLookupParameter<DoubleValue> QualityParameter {
+      get { return (SubScopesLookupParameter<DoubleValue>)Parameters["Quality"]; }
     }
     public ValueLookupParameter<IOperator> SelectorParameter {
@@ -53 +53 @@
       get { return (ValueLookupParameter<IOperator>)Parameters["Crossover"]; }
     }
-    public ValueLookupParameter<DoubleData> MutationProbabilityParameter {
-      get { return (ValueLookupParameter<DoubleData>)Parameters["MutationProbability"]; }
+    public ValueLookupParameter<DoubleValue> MutationProbabilityParameter {
+      get { return (ValueLookupParameter<DoubleValue>)Parameters["MutationProbability"]; }
     }
     public ValueLookupParameter<IOperator> MutatorParameter {
@@ -62 +62 @@
       get { return (ValueLookupParameter<IOperator>)Parameters["Evaluator"]; }
     }
-    public ValueLookupParameter<IntData> ElitesParameter {
-      get { return (ValueLookupParameter<IntData>)Parameters["Elites"]; }
-    }
-    public ValueLookupParameter<IntData> MaximumGenerationsParameter {
-      get { return (ValueLookupParameter<IntData>)Parameters["MaximumGenerations"]; }
+    public ValueLookupParameter<IntValue> ElitesParameter {
+      get { return (ValueLookupParameter<IntValue>)Parameters["Elites"]; }
+    }
+    public ValueLookupParameter<IntValue> MaximumGenerationsParameter {
+      get { return (ValueLookupParameter<IntValue>)Parameters["MaximumGenerations"]; }
     }
     public ValueLookupParameter<VariableCollection> ResultsParameter {
@@ -84 +84 @@
       #region Create parameters
       Parameters.Add(new ValueLookupParameter<IRandom>("Random", "A pseudo random number generator."));
-      Parameters.Add(new ValueLookupParameter<BoolData>("Maximization", "True if the problem is a maximization problem, otherwise false."));
-      Parameters.Add(new SubScopesLookupParameter<DoubleData>("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 SubScopesLookupParameter<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<DoubleData>("MutationProbability", "The probability that the mutation operator is applied on a solution."));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("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<IntData>("Elites", "The numer of elite solutions which are kept in each generation."));
-      Parameters.Add(new ValueLookupParameter<IntData>("MaximumGenerations", "The maximum number of generations which should be processed."));
+      Parameters.Add(new ValueLookupParameter<IntValue>("Elites", "The numer of elite solutions which are kept in each generation."));
+      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 ScopeParameter("CurrentScope", "The current scope which represents a population of solutions on which the SGA should be applied."));
@@ -123 +123 @@
       OperatorGraph.InitialOperator = variableCreator;
 
-      variableCreator.CollectedValues.Add(new ValueParameter<IntData>("Generations", new IntData(0)));
-      variableCreator.CollectedValues.Add(new ValueParameter<DoubleData>("Best Quality", new DoubleData(0)));
-      variableCreator.CollectedValues.Add(new ValueParameter<DoubleData>("Average Quality", new DoubleData(0)));
-      variableCreator.CollectedValues.Add(new ValueParameter<DoubleData>("Worst Quality", new DoubleData(0)));
+      variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("Generations", new IntValue(0)));
+      variableCreator.CollectedValues.Add(new ValueParameter<DoubleValue>("Best Quality", new DoubleValue(0)));
+      variableCreator.CollectedValues.Add(new ValueParameter<DoubleValue>("Average Quality", new DoubleValue(0)));
+      variableCreator.CollectedValues.Add(new ValueParameter<DoubleValue>("Worst Quality", new DoubleValue(0)));
       variableCreator.CollectedValues.Add(new ValueParameter<DataTable>("Qualities", new DataTable("Qualities")));
       variableCreator.Successor = resultsCollector;
 
-      resultsCollector.CollectedValues.Add(new LookupParameter<IntData>("Generations"));
-      resultsCollector.CollectedValues.Add(new LookupParameter<DoubleData>("Best Quality"));
-      resultsCollector.CollectedValues.Add(new LookupParameter<DoubleData>("Average Quality"));
-      resultsCollector.CollectedValues.Add(new LookupParameter<DoubleData>("Worst Quality"));
+      resultsCollector.CollectedValues.Add(new LookupParameter<IntValue>("Generations"));
+      resultsCollector.CollectedValues.Add(new LookupParameter<DoubleValue>("Best Quality"));
+      resultsCollector.CollectedValues.Add(new LookupParameter<DoubleValue>("Average Quality"));
+      resultsCollector.CollectedValues.Add(new LookupParameter<DoubleValue>("Worst Quality"));
       resultsCollector.CollectedValues.Add(new LookupParameter<DataTable>("Qualities"));
       resultsCollector.ResultsParameter.ActualName = "Results";
@@ -150 +150 @@
       sequentialSubScopesProcessor1.Successor = sequentialSubScopesProcessor2;
 
-      childrenCreator.ParentsPerChild = new IntData(2);
+      childrenCreator.ParentsPerChild = new IntValue(2);
       childrenCreator.Successor = uniformSequentialSubScopesProcessor;
 
@@ -185 +185 @@
       sequentialSubScopesProcessor2.Successor = mergingReducer;
 
-      leftSelector.CopySelected = new BoolData(false);
+      leftSelector.CopySelected = new BoolValue(false);
       leftSelector.NumberOfSelectedSubScopesParameter.ActualName = "Elites";
       leftSelector.Successor = rightReducer;
@@ -193 +193 @@
       mergingReducer.Successor = intCounter;
 
-      intCounter.Increment = new IntData(1);
+      intCounter.Increment = new IntValue(1);
       intCounter.ValueParameter.ActualName = "Generations";
       intCounter.Successor = comparator;
 
-      comparator.Comparison = new ComparisonData(Comparison.GreaterOrEqual);
+      comparator.Comparison = new Comparison(ComparisonType.GreaterOrEqual);
       comparator.LeftSideParameter.ActualName = "Generations";
       comparator.ResultParameter.ActualName = "Terminate";
@@ -210 +210 @@
       bestAverageWorstQualityCalculator.Successor = dataTableValuesCollector;
 
-      dataTableValuesCollector.CollectedValues.Add(new LookupParameter<DoubleData>("Best Quality"));
-      dataTableValuesCollector.CollectedValues.Add(new LookupParameter<DoubleData>("Average Quality"));
-      dataTableValuesCollector.CollectedValues.Add(new LookupParameter<DoubleData>("Worst Quality"));
+      dataTableValuesCollector.CollectedValues.Add(new LookupParameter<DoubleValue>("Best Quality"));
+      dataTableValuesCollector.CollectedValues.Add(new LookupParameter<DoubleValue>("Average Quality"));
+      dataTableValuesCollector.CollectedValues.Add(new LookupParameter<DoubleValue>("Worst Quality"));
       dataTableValuesCollector.DataTableParameter.ActualName = "Qualities";
       dataTableValuesCollector.Successor = conditionalBranch;