Changeset 3048 for trunk/sources/HeuristicLab.Operators

Timestamp:

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

Author:

swagner

Message:

Renamed classes of HeuristicLab.Data (#909)

Location:

trunk/sources/HeuristicLab.Operators/3.3

Files:

• Comparator.cs (modified) (3 diffs)
• ConditionalBranch.cs (modified) (2 diffs)
• DoubleCounter.cs (modified) (2 diffs)
• IntCounter.cs (modified) (2 diffs)
• StochasticBranch.cs (modified) (2 diffs)
• SubScopesCreator.cs (modified) (2 diffs)
• SubScopesRemover.cs (modified) (2 diffs)
• SubScopesSorter.cs (modified) (4 diffs)

trunk/sources/HeuristicLab.Operators/3.3/Comparator.cs

@@ -40 +40 @@
       get { return (ValueLookupParameter<IItem>)Parameters["RightSide"]; }
     }
-    private ValueParameter<ComparisonData> ComparisonParameter {
-      get { return (ValueParameter<ComparisonData>)Parameters["Comparison"]; }
+    private ValueParameter<Comparison> ComparisonParameter {
+      get { return (ValueParameter<Comparison>)Parameters["Comparison"]; }
     }
-    public LookupParameter<BoolData> ResultParameter {
-      get { return (LookupParameter<BoolData>)Parameters["Result"]; }
+    public LookupParameter<BoolValue> ResultParameter {
+      get { return (LookupParameter<BoolValue>)Parameters["Result"]; }
     }
-    public ComparisonData Comparison {
+    public Comparison Comparison {
       get { return ComparisonParameter.Value; }
       set { ComparisonParameter.Value = value; }
@@ -55 +55 @@
       Parameters.Add(new LookupParameter<IItem>("LeftSide", "The left side of the comparison."));
       Parameters.Add(new ValueLookupParameter<IItem>("RightSide", "The right side of the comparison."));
-      Parameters.Add(new ValueParameter<ComparisonData>("Comparison", "The type of comparison.", new ComparisonData(Data.Comparison.Equal)));
-      Parameters.Add(new LookupParameter<BoolData>("Result", "The result of the comparison."));
+      Parameters.Add(new ValueParameter<Comparison>("Comparison", "The type of comparison.", new Comparison(Data.ComparisonType.Equal)));
+      Parameters.Add(new LookupParameter<BoolValue>("Result", "The result of the comparison."));
     }
 
@@ -68 +68 @@
       bool b = false;
       switch (Comparison.Value) {
-        case HeuristicLab.Data.Comparison.Less:
+        case HeuristicLab.Data.ComparisonType.Less:
           b = i < 0; break;
-        case HeuristicLab.Data.Comparison.LessOrEqual:
+        case HeuristicLab.Data.ComparisonType.LessOrEqual:
           b = i <= 0; break;
-        case HeuristicLab.Data.Comparison.Equal:
+        case HeuristicLab.Data.ComparisonType.Equal:
           b = i == 0; break;
-        case HeuristicLab.Data.Comparison.GreaterOrEqual:
+        case HeuristicLab.Data.ComparisonType.GreaterOrEqual:
           b = i >= 0; break;
-        case HeuristicLab.Data.Comparison.Greater:
+        case HeuristicLab.Data.ComparisonType.Greater:
           b = i > 0; break;
-        case HeuristicLab.Data.Comparison.NotEqual:
+        case HeuristicLab.Data.ComparisonType.NotEqual:
           b = i != 0; break;
       }
-      ResultParameter.ActualValue = new BoolData(b);
+      ResultParameter.ActualValue = new BoolValue(b);
       return base.Apply();
     }

trunk/sources/HeuristicLab.Operators/3.3/ConditionalBranch.cs

@@ -33 +33 @@
   [StorableClass]
   public class ConditionalBranch : SingleSuccessorOperator {
-    public LookupParameter<BoolData> ConditionParameter {
-      get { return (LookupParameter<BoolData>)Parameters["Condition"]; }
+    public LookupParameter<BoolValue> ConditionParameter {
+      get { return (LookupParameter<BoolValue>)Parameters["Condition"]; }
     }
     protected OperatorParameter TrueBranchParameter {
@@ -53 +53 @@
     public ConditionalBranch()
       : base() {
-      Parameters.Add(new LookupParameter<BoolData>("Condition", "A boolean variable which defines which branch is executed."));
+      Parameters.Add(new LookupParameter<BoolValue>("Condition", "A boolean variable which defines which branch is executed."));
       Parameters.Add(new OperatorParameter("TrueBranch", "The operator which is executed if the condition is true."));
       Parameters.Add(new OperatorParameter("FalseBranch", "The operator which is executed if the condition is false."));

trunk/sources/HeuristicLab.Operators/3.3/DoubleCounter.cs

@@ -33 +33 @@
   [Creatable("Test")]
   public sealed class DoubleCounter : SingleSuccessorOperator {
-    public LookupParameter<DoubleData> ValueParameter {
-      get { return (LookupParameter<DoubleData>)Parameters["Value"]; }
+    public LookupParameter<DoubleValue> ValueParameter {
+      get { return (LookupParameter<DoubleValue>)Parameters["Value"]; }
     }
-    public ValueLookupParameter<DoubleData> IncrementParameter {
-      get { return (ValueLookupParameter<DoubleData>)Parameters["Increment"]; }
+    public ValueLookupParameter<DoubleValue> IncrementParameter {
+      get { return (ValueLookupParameter<DoubleValue>)Parameters["Increment"]; }
     }
-    public DoubleData Increment {
+    public DoubleValue Increment {
       get { return IncrementParameter.Value; }
       set { IncrementParameter.Value = value; }
@@ -46 +46 @@
     public DoubleCounter()
       : base() {
-      Parameters.Add(new LookupParameter<DoubleData>("Value", "The value which should be incremented."));
-      Parameters.Add(new ValueLookupParameter<DoubleData>("Increment", "The increment which is added to the value.", new DoubleData(1)));
+      Parameters.Add(new LookupParameter<DoubleValue>("Value", "The value which should be incremented."));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("Increment", "The increment which is added to the value.", new DoubleValue(1)));
     }
 
     public override IOperation Apply() {
-      if (ValueParameter.ActualValue == null) ValueParameter.ActualValue = new DoubleData();
+      if (ValueParameter.ActualValue == null) ValueParameter.ActualValue = new DoubleValue();
       ValueParameter.ActualValue.Value += IncrementParameter.ActualValue.Value;
       return base.Apply();

trunk/sources/HeuristicLab.Operators/3.3/IntCounter.cs

@@ -33 +33 @@
   [Creatable("Test")]
   public sealed class IntCounter : SingleSuccessorOperator {
-    public LookupParameter<IntData> ValueParameter {
-      get { return (LookupParameter<IntData>)Parameters["Value"]; }
+    public LookupParameter<IntValue> ValueParameter {
+      get { return (LookupParameter<IntValue>)Parameters["Value"]; }
     }
-    public ValueLookupParameter<IntData> IncrementParameter {
-      get { return (ValueLookupParameter<IntData>)Parameters["Increment"]; }
+    public ValueLookupParameter<IntValue> IncrementParameter {
+      get { return (ValueLookupParameter<IntValue>)Parameters["Increment"]; }
     }
-    public IntData Increment {
+    public IntValue Increment {
       get { return IncrementParameter.Value; }
       set { IncrementParameter.Value = value; }
@@ -46 +46 @@
     public IntCounter()
       : base() {
-      Parameters.Add(new LookupParameter<IntData>("Value", "The value which should be incremented."));
-      Parameters.Add(new ValueLookupParameter<IntData>("Increment", "The increment which is added to the value.", new IntData(1)));
+      Parameters.Add(new LookupParameter<IntValue>("Value", "The value which should be incremented."));
+      Parameters.Add(new ValueLookupParameter<IntValue>("Increment", "The increment which is added to the value.", new IntValue(1)));
     }
 
     public override IOperation Apply() {
-      if (ValueParameter.ActualValue == null) ValueParameter.ActualValue = new IntData();
+      if (ValueParameter.ActualValue == null) ValueParameter.ActualValue = new IntValue();
       ValueParameter.ActualValue.Value += IncrementParameter.ActualValue.Value;
       return base.Apply();

trunk/sources/HeuristicLab.Operators/3.3/StochasticBranch.cs

@@ -36 +36 @@
       get { return (LookupParameter<IRandom>)Parameters["Random"]; }
     }
-    public ValueLookupParameter<DoubleData> ProbabilityParameter {
-      get { return (ValueLookupParameter<DoubleData>)Parameters["Probability"]; }
+    public ValueLookupParameter<DoubleValue> ProbabilityParameter {
+      get { return (ValueLookupParameter<DoubleValue>)Parameters["Probability"]; }
     }
     protected OperatorParameter FirstBranchParameter {
@@ -57 +57 @@
       : base() {
       Parameters.Add(new LookupParameter<IRandom>("Random", "A pseudo random number generator."));
-      Parameters.Add(new ValueLookupParameter<DoubleData>("Probability", "The probability to execute the first branch."));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("Probability", "The probability to execute the first branch."));
       Parameters.Add(new OperatorParameter("FirstBranch", "The operator which is executed with the given probability."));
       Parameters.Add(new OperatorParameter("SecondBranch", "The operator which is executed if the first branch is not executed."));

trunk/sources/HeuristicLab.Operators/3.3/SubScopesCreator.cs

@@ -33 +33 @@
   [Creatable("Test")]
   public class SubScopesCreator : SingleSuccessorOperator {
-    public ValueLookupParameter<IntData> NumberOfSubScopesParameter {
-      get { return (ValueLookupParameter<IntData>)Parameters["NumberOfSubScopes"]; }
+    public ValueLookupParameter<IntValue> NumberOfSubScopesParameter {
+      get { return (ValueLookupParameter<IntValue>)Parameters["NumberOfSubScopes"]; }
     }
     protected ScopeParameter CurrentScopeParameter {
@@ -45 +45 @@
     public SubScopesCreator()
       : base() {
-      Parameters.Add(new ValueLookupParameter<IntData>("NumberOfSubScopes", "The number of new and empty sub-scopes which should be added to the current scope."));
+      Parameters.Add(new ValueLookupParameter<IntValue>("NumberOfSubScopes", "The number of new and empty sub-scopes which should be added to the current scope."));
       Parameters.Add(new ScopeParameter("CurrentScope", "The current scope to which the new and empty sub-scopes are added."));
     }

trunk/sources/HeuristicLab.Operators/3.3/SubScopesRemover.cs

@@ -33 +33 @@
   [Creatable("Test")]
   public sealed class SubScopesRemover : SingleSuccessorOperator {
-    private ValueParameter<BoolData> RemoveAllSubScopesParameter {
-      get { return (ValueParameter<BoolData>)Parameters["RemoveAllSubScopes"]; }
+    private ValueParameter<BoolValue> RemoveAllSubScopesParameter {
+      get { return (ValueParameter<BoolValue>)Parameters["RemoveAllSubScopes"]; }
     }
-    public ValueLookupParameter<IntData> SubScopeIndexParameter {
-      get { return (ValueLookupParameter<IntData>)Parameters["SubScopeIndex"]; }
+    public ValueLookupParameter<IntValue> SubScopeIndexParameter {
+      get { return (ValueLookupParameter<IntValue>)Parameters["SubScopeIndex"]; }
     }
     private ScopeParameter CurrentScopeParameter {
@@ -53 +53 @@
     public SubScopesRemover()
       : base() {
-      Parameters.Add(new ValueParameter<BoolData>("RemoveAllSubScopes", "True if all sub-scopes of the current scope should be removed, otherwise false.", new BoolData(true)));
-      Parameters.Add(new ValueLookupParameter<IntData>("SubScopeIndex", "The index of the sub-scope which should be removed. This parameter is ignored, if RemoveAllSubScopes is true."));
+      Parameters.Add(new ValueParameter<BoolValue>("RemoveAllSubScopes", "True if all sub-scopes of the current scope should be removed, otherwise false.", new BoolValue(true)));
+      Parameters.Add(new ValueLookupParameter<IntValue>("SubScopeIndex", "The index of the sub-scope which should be removed. This parameter is ignored, if RemoveAllSubScopes is true."));
       Parameters.Add(new ScopeParameter("CurrentScope", "The current scope from which one or all sub-scopes should be removed."));
     }

trunk/sources/HeuristicLab.Operators/3.3/SubScopesSorter.cs

@@ -36 +36 @@
     private string actualName;
 
-    public SubScopesLookupParameter<DoubleData> ValueParameter {
-      get { return (SubScopesLookupParameter<DoubleData>)Parameters["Value"]; }
+    public SubScopesLookupParameter<DoubleValue> ValueParameter {
+      get { return (SubScopesLookupParameter<DoubleValue>)Parameters["Value"]; }
     }
-    public ValueLookupParameter<BoolData> DescendingParameter {
-      get { return (ValueLookupParameter<BoolData>)Parameters["Descending"]; }
+    public ValueLookupParameter<BoolValue> DescendingParameter {
+      get { return (ValueLookupParameter<BoolValue>)Parameters["Descending"]; }
     }
     private ScopeParameter CurrentScopeParameter {
@@ -51 +51 @@
     public SubScopesSorter()
       : base() {
-      Parameters.Add(new SubScopesLookupParameter<DoubleData>("Value", "The values contained in each sub-scope acording which the sub-scopes of the current scope are sorted."));
-      Parameters.Add(new ValueLookupParameter<BoolData>("Descending", "True if the sub-scopes should be sorted in descending order, otherwise false."));
+      Parameters.Add(new SubScopesLookupParameter<DoubleValue>("Value", "The values contained in each sub-scope acording which the sub-scopes of the current scope are sorted."));
+      Parameters.Add(new ValueLookupParameter<BoolValue>("Descending", "True if the sub-scopes should be sorted in descending order, otherwise false."));
       Parameters.Add(new ScopeParameter("CurrentScope", "The current scope whose sub-scopes are sorted."));
     }
@@ -58 +58 @@
     public override IOperation Apply() {
       descending = DescendingParameter.ActualValue.Value;
-      actualName = LookupParameter<ItemArray<DoubleData>>.TranslateName(ValueParameter.Name, ExecutionContext);
+      actualName = LookupParameter<ItemArray<DoubleValue>>.TranslateName(ValueParameter.Name, ExecutionContext);
       CurrentScope.SubScopes.Sort(SortScopes);
       return base.Apply();
@@ -75 +75 @@
         return -1;
       else {
-        int result = ((DoubleData)var1.Value).CompareTo((DoubleData)var2.Value);
+        int result = ((DoubleValue)var1.Value).CompareTo((DoubleValue)var2.Value);
         if (descending) result = result * -1;
         return result;