Changeset 12280 for stable/HeuristicLab.Optimization.Operators

Timestamp:

04/01/15 17:06:17 (10 years ago)

Author:

mkommend

Message:

#2332: Merged all changes from this ticket into stable.

Location:

stable

Files:

• . (modified) (1 prop)
• HeuristicLab.Optimization.Operators/3.3/NoSimilarityCalculator.cs (modified) (1 diff)
• HeuristicLab.Optimization.Operators/3.3/QualitySimilarityCalculator.cs (modified) (1 diff)
• HeuristicLab.Optimization.Operators/3.3/SingleObjectiveSolutionSimilarityCalculator.cs (modified) (1 diff)
• HeuristicLab.Optimization.Operators/3.3/SolutionSimilarityCalculator.cs (modified) (4 diffs)

stable/HeuristicLab.Optimization.Operators/3.3/NoSimilarityCalculator.cs

@@ -32 +32 @@
   [Item("NoSimilarityCalculator", "An item that performs similarity calculation between two solutions. The item always considers two solutions to be distinct.")]
   public sealed class NoSimilarityCalculator : SingleObjectiveSolutionSimilarityCalculator {
+    protected override bool IsCommutative { get { return true; } }
+
     private NoSimilarityCalculator(bool deserializing) : base(deserializing) { }
     private NoSimilarityCalculator(NoSimilarityCalculator original, Cloner cloner) : base(original, cloner) { }

stable/HeuristicLab.Optimization.Operators/3.3/QualitySimilarityCalculator.cs

@@ -34 +34 @@
   [Item("QualitySimilarityCalculator", "An item that performs similarity calculation between two solutions. The item only considers the qualities of the two solutions.")]
   public sealed class QualitySimilarityCalculator : SingleObjectiveSolutionSimilarityCalculator {
+    protected override bool IsCommutative { get { return true; } }
+
     private QualitySimilarityCalculator(bool deserializing) : base(deserializing) { }
     private QualitySimilarityCalculator(QualitySimilarityCalculator original, Cloner cloner) : base(original, cloner) { }

stable/HeuristicLab.Optimization.Operators/3.3/SingleObjectiveSolutionSimilarityCalculator.cs

@@ -31 +31 @@
   [Item("SimilarityCalculator", "A base class for items that perform similarity calculation between two solutions.")]
   [StorableClass]
+#pragma warning disable 0618
   public abstract class SingleObjectiveSolutionSimilarityCalculator : SolutionSimilarityCalculator, ISingleObjectiveSolutionSimilarityCalculator {
-    #region Properties
-    [Storable]
-    public string SolutionVariableName { get; set; }
-    [Storable]
-    public string QualityVariableName { get; set; }
-    #endregion
-
+#pragma warning restore 0618
     [StorableConstructor]
     protected SingleObjectiveSolutionSimilarityCalculator(bool deserializing) : base(deserializing) { }
     protected SingleObjectiveSolutionSimilarityCalculator(SingleObjectiveSolutionSimilarityCalculator original, Cloner cloner)
       : base(original, cloner) {
-      this.SolutionVariableName = original.SolutionVariableName;
-      this.QualityVariableName = original.QualityVariableName;
+
     }
     protected SingleObjectiveSolutionSimilarityCalculator() : base() { }

stable/HeuristicLab.Optimization.Operators/3.3/SolutionSimilarityCalculator.cs

@@ -24 +24 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
+using HeuristicLab.Data;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
@@ -33 +34 @@
   [StorableClass]
   public abstract class SolutionSimilarityCalculator : Item, ISolutionSimilarityCalculator {
+    protected abstract bool IsCommutative { get; }
+
+    #region Properties
+    [Storable]
+    public string SolutionVariableName { get; set; }
+    [Storable]
+    public string QualityVariableName { get; set; }
+    #endregion
+
     [StorableConstructor]
     protected SolutionSimilarityCalculator(bool deserializing) : base(deserializing) { }
-    protected SolutionSimilarityCalculator(SolutionSimilarityCalculator original, Cloner cloner) : base(original, cloner) { }
+
+    protected SolutionSimilarityCalculator(SolutionSimilarityCalculator original, Cloner cloner)
+      : base(original, cloner) {
+      this.SolutionVariableName = original.SolutionVariableName;
+      this.QualityVariableName = original.QualityVariableName;
+    }
     protected SolutionSimilarityCalculator() : base() { }
 
@@ -71 +86 @@
       for (int i = 0; i < individuals.Count; i++) similarityMatrix[i] = new double[individuals.Count];
 
-      for (int i = 0; i < individuals.Count; i++) {
-        for (int j = i; j < individuals.Count; j++) {
-          similarityMatrix[i][j] = similarityMatrix[j][i] = CalculateSolutionSimilarity(individuals[i], individuals[j]);
+      if (IsCommutative) {
+        for (int i = 0; i < individuals.Count; i++) {
+          for (int j = i; j < individuals.Count; j++) {
+            similarityMatrix[i][j] = similarityMatrix[j][i] = CalculateSolutionSimilarity(individuals[i], individuals[j]);
+          }
+        }
+      } else {
+        for (int i = 0; i < individuals.Count; i++) {
+          for (int j = i; j < individuals.Count; j++) {
+            similarityMatrix[i][j] = CalculateSolutionSimilarity(individuals[i], individuals[j]);
+            if (i == j) continue;
+            similarityMatrix[j][i] = CalculateSolutionSimilarity(individuals[j], individuals[i]);
+          }
         }
       }
@@ -81 +106 @@
 
     public abstract double CalculateSolutionSimilarity(IScope leftSolution, IScope rightSolution);
-    public abstract bool Equals(IScope x, IScope y);
-    public abstract int GetHashCode(IScope obj);
+
+    public virtual bool Equals(IScope x, IScope y) {
+      if (ReferenceEquals(x, y)) return true;
+      if (x == null || y == null) return false;
+
+      var q1 = x.Variables[QualityVariableName].Value;
+      var q2 = y.Variables[QualityVariableName].Value;
+
+      return CheckQualityEquality(q1, q2) && CalculateSolutionSimilarity(x, y).IsAlmost(1.0);
+    }
+
+    public virtual int GetHashCode(IScope scope) {
+      var quality = scope.Variables[QualityVariableName].Value;
+      var dv = quality as DoubleValue;
+      if (dv != null)
+        return dv.Value.GetHashCode();
+
+      var da = quality as DoubleArray;
+      if (da != null) {
+        int hash = 17;
+        unchecked {
+          for (int i = 0; i < da.Length; ++i) {
+            hash += hash * 23 + da[i].GetHashCode();
+          }
+          return hash;
+        }
+      }
+      return 0;
+    }
+
+    private static bool CheckQualityEquality(IItem q1, IItem q2) {
+      var d1 = q1 as DoubleValue;
+      var d2 = q2 as DoubleValue;
+
+      if (d1 != null && d2 != null)
+        return d1.Value.IsAlmost(d2.Value);
+
+      var da1 = q1 as DoubleArray;
+      var da2 = q2 as DoubleArray;
+
+      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.");
+    }
   }
 }