Changeset 12247 for branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Optimization.Operators

Timestamp:

03/24/15 11:17:08 (10 years ago)

Author:

mkommend

Message:

#2276: Merged trunk changes into dataset refactoring branch.

Location:

branches/HeuristicLab.DatasetRefactor/sources

Files:

• . (modified) (1 prop)
• HeuristicLab.Optimization.Operators/3.3/ExpressionCalculator.cs (modified) (1 diff)
• HeuristicLab.Optimization.Operators/3.3/MultiObjective/FastNonDominatedSort.cs (modified) (9 diffs)
• HeuristicLab.Optimization.Operators/3.3/MultiObjective/RankAndCrowdingSorter.cs (modified) (5 diffs)
• HeuristicLab.Optimization.Operators/3.3/SolutionSimilarityCalculator.cs (modified) (3 diffs)

branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Optimization.Operators/3.3/ExpressionCalculator.cs

@@ -74 +74 @@
 variables (run parameters or results):
   unquoted or in double quotes if they contain special characters or whitespace
-mathematical functions:
+mathematical functions (resulting in double values):
   +, -, *, /, ^ (power), log
 predicates:
   ==, <, >, isnull, not
+conversions:
+  toint, todouble
+array indexing:
+  []
 stack manipulation:
   drop swap dup

branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Optimization.Operators/3.3/MultiObjective/FastNonDominatedSort.cs

@@ -22 +22 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
@@ -40 +41 @@
     private enum DominationResult { Dominates, IsDominated, IsNonDominated };
 
+    #region Parameter properties
     public IValueLookupParameter<BoolArray> MaximizationParameter {
       get { return (IValueLookupParameter<BoolArray>)Parameters["Maximization"]; }
     }
-
+    public IValueLookupParameter<BoolValue> DominateOnEqualQualitiesParameter {
+      get { return (ValueLookupParameter<BoolValue>)Parameters["DominateOnEqualQualities"]; }
+    }
     public IScopeTreeLookupParameter<DoubleArray> QualitiesParameter {
       get { return (IScopeTreeLookupParameter<DoubleArray>)Parameters["Qualities"]; }
     }
-
     public IScopeTreeLookupParameter<IntValue> RankParameter {
       get { return (IScopeTreeLookupParameter<IntValue>)Parameters["Rank"]; }
     }
+    #endregion
 
     [StorableConstructor]
@@ -57 +61 @@
     public FastNonDominatedSort() {
       Parameters.Add(new ValueLookupParameter<BoolArray>("Maximization", "Whether each objective is maximization or minimization."));
+      Parameters.Add(new ValueLookupParameter<BoolValue>("DominateOnEqualQualities", "Flag which determines wether solutions with equal quality values should be treated as dominated."));
       Parameters.Add(new ScopeTreeLookupParameter<DoubleArray>("Qualities", "The qualities of a solution.", 1));
       Parameters.Add(new ScopeTreeLookupParameter<IntValue>("Rank", "The rank of a solution.", 1));
@@ -62 +67 @@
 
     public override IOperation Apply() {
+      bool dominateOnEqualQualities = DominateOnEqualQualitiesParameter.ActualValue.Value;
       BoolArray maximization = MaximizationParameter.ActualValue;
       ItemArray<DoubleArray> qualities = QualitiesParameter.ActualValue;
@@ -79 +85 @@
           dominatedScopes[p] = new List<int>();
         for (int qI = pI + 1; qI < populationSize; qI++) {
-          DominationResult test = Dominates(qualities[pI], qualities[qI], maximization);
+          DominationResult test = Dominates(qualities[pI], qualities[qI], maximization, dominateOnEqualQualities);
           if (test == DominationResult.Dominates) {
             dominatedScopes[p].Add(qI);
@@ -134 +140 @@
     }
 
-    private DominationResult Dominates(DoubleArray left, DoubleArray right, BoolArray maximizations) {
+    private static DominationResult Dominates(DoubleArray left, DoubleArray right, BoolArray maximizations, bool dominateOnEqualQualities) {
+      if (dominateOnEqualQualities && left.SequenceEqual(right)) return DominationResult.Dominates;
+
       bool leftIsBetter = false, rightIsBetter = false;
       for (int i = 0; i < left.Length; i++) {
@@ -141 +149 @@
         if (leftIsBetter && rightIsBetter) break;
       }
+
       if (leftIsBetter && !rightIsBetter) return DominationResult.Dominates;
       if (!leftIsBetter && rightIsBetter) return DominationResult.IsDominated;
@@ -146 +155 @@
     }
 
-    private bool IsDominated(double left, double right, bool maximization) {
+    private static bool IsDominated(double left, double right, bool maximization) {
       return maximization && left < right
         || !maximization && left > right;
     }
 
-    private void AddToFront(IScope p, List<ScopeList> fronts, int i) {
+    private static void AddToFront(IScope p, List<ScopeList> fronts, int i) {
       if (i == fronts.Count) fronts.Add(new ScopeList());
       fronts[i].Add(p);
@@ -159 +168 @@
       return new FastNonDominatedSort(this, cloner);
     }
+
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      // BackwardsCompatibility3.3
+      #region Backwards compatible code, remove with 3.4
+      if (!Parameters.ContainsKey("DominateOnEqualQualities"))
+        Parameters.Add(new ValueLookupParameter<BoolValue>("DominateOnEqualQualities", "Flag which determines wether solutions with equal quality values should be treated as dominated."));
+      #endregion
+    }
   }
 }

branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Optimization.Operators/3.3/MultiObjective/RankAndCrowdingSorter.cs

@@ -30 +30 @@
 namespace HeuristicLab.Optimization.Operators {
   public class RankAndCrowdingSorter : AlgorithmOperator, IMultiObjectiveOperator {
+    #region Parameter properties
     public ValueLookupParameter<BoolArray> MaximizationParameter {
       get { return (ValueLookupParameter<BoolArray>)Parameters["Maximization"]; }
@@ -42 +43 @@
       get { return (ScopeTreeLookupParameter<DoubleValue>)Parameters["CrowdingDistance"]; }
     }
+    public IValueLookupParameter<BoolValue> DominateOnEqualQualitiesParameter {
+      get { return (ValueLookupParameter<BoolValue>)Parameters["DominateOnEqualQualities"]; }
+    }
+    #endregion
 
     [StorableConstructor]
@@ -49 +54 @@
       : base() {
       Parameters.Add(new ValueLookupParameter<BoolArray>("Maximization", "For each objective a value that is true if that objective should be maximized, or false if it should be minimized."));
+      Parameters.Add(new ValueLookupParameter<BoolValue>("DominateOnEqualQualities", "Flag which determines wether solutions with equal quality values should be treated as dominated."));
       Parameters.Add(new ScopeTreeLookupParameter<DoubleArray>("Qualities", "The vector of quality values."));
       Parameters.Add(new ScopeTreeLookupParameter<IntValue>("Rank", "The rank of a solution (to which front it belongs)."));
@@ -60 +66 @@
 
       fastNonDominatedSort.MaximizationParameter.ActualName = MaximizationParameter.Name;
+      fastNonDominatedSort.DominateOnEqualQualitiesParameter.ActualName = DominateOnEqualQualitiesParameter.Name;
       fastNonDominatedSort.QualitiesParameter.ActualName = QualitiesParameter.Name;
       fastNonDominatedSort.RankParameter.ActualName = RankParameter.Name;
@@ -81 +88 @@
       return new RankAndCrowdingSorter(this, cloner);
     }
+
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      // BackwardsCompatibility3.3
+      #region Backwards compatible code, remove with 3.4
+      if (!Parameters.ContainsKey("DominateOnEqualQualities"))
+        Parameters.Add(new ValueLookupParameter<BoolValue>("DominateOnEqualQualities", "Flag which determines wether solutions with equal quality values should be treated as dominated."));
+      #endregion
+    }
   }
 }

branches/HeuristicLab.DatasetRefactor/sources/HeuristicLab.Optimization.Operators/3.3/SolutionSimilarityCalculator.cs

@@ -111 +111 @@
       if (x == null || y == null) return false;
 
-      var q1 = x.Variables[QualityVariableName];
-      var q2 = x.Variables[QualityVariableName];
+      var q1 = x.Variables[QualityVariableName].Value;
+      var q2 = y.Variables[QualityVariableName].Value;
 
       return CheckQualityEquality(q1, q2) && CalculateSolutionSimilarity(x, y).IsAlmost(1.0);
@@ -133 +133 @@
         }
       }
-      return 0; // throw exception?
+      return 0;
     }
 
@@ -146 +146 @@
       var da2 = q2 as DoubleArray;
 
-      if (da1 != null && da2 != null)
-        return da1.SequenceEqual(da2);
+      if (da1 != null && da2 != null) {
+        if (da1.Length != da2.Length)
+          throw new ArgumentException("The quality arrays must have the same length.");
+
+        for (int i = 0; i < da1.Length; ++i) {
+          if (!da1[i].IsAlmost(da2[i]))
+            return false;
+        }
+
+        return true;
+      }
 
       throw new ArgumentException("Could not determine quality equality.");