Changeset 13620 for branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Comparators

Timestamp:

02/15/16 17:19:34 (8 years ago)

Author:

bwerth

Message:

#1087 regorganized testfunctions, added view for qualities

Location:

branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Comparators

Files:

• Crowding.cs (modified) (2 diffs)
• GenerationalDistance.cs (modified) (2 diffs)
• HyperVolume.cs (modified) (4 diffs)
• HyperVolumeFast.cs (modified) (15 diffs)
• InvertedGenerationalDistance.cs (modified) (3 diffs)
• Spacing.cs (modified) (2 diffs)
• Utilities.cs (added)

branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Comparators/Crowding.cs

@@ -1 +1 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Data;
 using HeuristicLab.Encodings.RealVectorEncoding;
+using HeuristicLab.Problems.MultiObjectiveTestFunctions.Comparators;
 
 namespace HeuristicLab.Problems.MultiObjectiveTestFunctions {
 
   /// <summary>
-  /// Crowding distance d(x,A) is usually defined between a point x and a set of points  A
+  /// Crowding distance d(x,A) is usually defined between a point x and a set of points A
   /// d(x,A) is then a weighted sum over all dimensions where for each dimension the next larger and the next smaller Point to x are subtracted
   /// I extended the concept and defined the Crowding distance of a front A as the mean of the crowding distances of every point x in A 
-  /// C(A) = mean(x,A) where x in A
+  /// C(A) = mean(d(x,A)) where x in A  and d(x,A) is not infinite 
   /// </summary>
   public class Crowding : IMultiObjectiveDistance {
-    private double[][] bounds;
-    public Crowding(double[][] bounds) {
+    private double[,] bounds;
+
+    public Crowding(double[,] bounds) {
       this.bounds = bounds;
+
     }
 
-
-    public static double GetDistance(RealVector[] front, RealVector[] optimalFront, double[][] bounds) {
+    public static double GetDistance(IEnumerable<double[]> front, IEnumerable<double[]> optimalFront, double[,] bounds) {
       return new Crowding(bounds).Compare(front, optimalFront);
     }
 
-
-    public static double GetCrowding(RealVector[] front, double[][] bounds) {
+    public static double GetCrowding(IEnumerable<double[]> front, double[,] bounds) {
       return new Crowding(bounds).Get(front);
     }
 
-
-    public double Get(RealVector[] front) {
+    public double Get(IEnumerable<double[]> front) {
       double sum = 0;
-      foreach(RealVector point in front) {
-        sum += CalcCrowding(point, front);
+      int c = 0;
+      foreach (double[] point in front) {
+        double d = CalcCrowding(point, front);
+        if (!Double.IsInfinity(d)) {
+          sum += d;
+          c++;
+        }
       }
-      return sum / front.Length;
+      return c==0?Double.PositiveInfinity:sum / c;
     }
 
-    public double Compare(RealVector[] front, RealVector[] optimalFront) {
+    public double Compare(IEnumerable<double[]> front, IEnumerable<double[]> optimalFront) {
       return Get(optimalFront) - Get(front);
     }
 
-    private double CalcCrowding(RealVector point, RealVector[] list) {
+    private double CalcCrowding(double[] point, IEnumerable<double[]> list) {
       double sum = 0;
       for (int i = 0; i < point.Length; i++) {
@@ -48 +55 @@
     }
 
-    private double CalcCrowding(RealVector point, RealVector[] list, int dim) {
-      double fmax = bounds[dim % bounds.Length][1];
-      double fmin = bounds[dim % bounds.Length][0];
-
-      Array.Sort<RealVector>(list, new DimensionComparer(dim, false));
-      if (list[0][dim] == point[0] || list[list.Length - 1][dim] == point[0]) return Double.PositiveInfinity;
-      int pos = binarySearch(point[dim], list, dim);
-      return (list[pos + 1][dim] - list[pos - 1][dim] )/ (fmax - fmin);
-    }
-
-    private int binarySearch(double x, RealVector[] list, int dim) {
-      int low = 0;
-      int high = list.Length - 1;
-      while (high >= low) {
-        int middle = (low + high) / 2;
-        if (list[middle][dim] == x) return middle;
-        if (list[middle][dim] < x)  low = middle + 1;
-        if (list[middle][dim] > x)  high = middle - 1; 
-      }
-      return -1; //This should never happen
-    }
-
-    private class DimensionComparer : IComparer<RealVector> {
-      private int dim;
-      private int descending;
-
-      public DimensionComparer(int dimension, bool descending) {
-        this.dim = dimension;
-        this.descending = descending ? -1 : 1;
-      }
-
-      #region IComparer<DoubleArray> Members
-
-      public int Compare(RealVector x, RealVector y) {
-        if (x[dim] < y[dim]) return -descending;
-        else if (x[dim] > y[dim]) return descending;
-        else return 0;
-      }
-
-      #endregion
+    private double CalcCrowding(double[] point, IEnumerable<double[]> list, int dim) {
+      double fmax = bounds[dim % bounds.GetLength(0), 1];
+      double fmin = bounds[dim % bounds.GetLength(0), 0];
+      double[][] arr = list.ToArray();  //TODO Shady
+      Array.Sort<double[]>(arr, Utilities.getDimensionComparer(dim, false));
+      if (arr[0][dim] == point[0] || arr[arr.Length - 1][dim] == point[0]) return Double.PositiveInfinity;
+      int pos = Utilities.binarySearch(point[dim], arr, dim);
+      if (pos == 0 || pos == list.Count()-1) return Double.PositiveInfinity;
+      return (arr[pos + 1][dim] - arr[pos - 1][dim]) / (fmax - fmin);
     }
 

branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Comparators/GenerationalDistance.cs

@@ -1 +1 @@
 using System;
+using System.Collections.Generic;
 using HeuristicLab.Encodings.RealVectorEncoding;
+using HeuristicLab.Problems.MultiObjectiveTestFunctions.Comparators;
 
 namespace HeuristicLab.Problems.MultiObjectiveTestFunctions {
@@ -15 +17 @@
     }
 
-
-    public static double GetDistance(RealVector[] front, RealVector[] optimalFront, double p) {
+    public static double GetDistance(IEnumerable<double[]> front, IEnumerable<double[]> optimalFront, double p) {
      return new GenerationalDistance(p).Compare(front,optimalFront);
     }
 
-    public double Compare(RealVector[] front, RealVector[] optimalFront) {
-     //TODO build a kd-tree, sort the array, do someting intelligent here
-     double sum = 0;
-      if (front.Length == 0 || optimalFront.Length == 0) throw new Exception("Both Fronts need to contain at least one point");
-     foreach(RealVector r in front) {
-        sum += minDistance(r, optimalFront);
+    public double Compare(IEnumerable<double[]> front, IEnumerable<double[]> optimalFront) {
+      //TODO build a kd-tree, sort the array, do someting intelligent here
+      if (front == null || optimalFront == null) throw new ArgumentException("Fronts must not be null");
+      double sum = 0;
+      int c = 0;
+     foreach(double[] r in front) {
+        sum += Utilities.minDistance(r, optimalFront,true);
+        c++;
       }
-      return Math.Pow(sum, p) /front.Length;
+      if (c == 0) throw new ArgumentException("Fronts must not be empty");
+      return Math.Pow(sum, p) /c;
     }
 
-    private double minDistance(RealVector point, RealVector[] list) {
-      //TODO inefficient
-      double min = Double.MaxValue;
-      foreach (RealVector r in list) {
-        if (r == point) continue;
-        double d = 0;
-        for (int i = 0; i < r.Length; i++) {
-          d += (point[i] - r[i]) * (point[i] - r[i]);
-        }
-        min = Math.Min(d, min);
-      }
-      return Math.Sqrt(min);
-    }
+    
 
   }

branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Comparators/HyperVolume.cs

@@ -1 +1 @@
 using System;
 using System.Collections.Generic;
-using HeuristicLab.Encodings.RealVectorEncoding;
+using System.Linq;
+using HeuristicLab.Problems.MultiObjectiveTestFunctions.Comparators;
 
 namespace HeuristicLab.Problems.MultiObjectiveTestFunctions {
@@ -29 +30 @@
   public class Hypervolume : IMultiObjectiveDistance {
 
-    private RealVector reference;
+    private double[] reference;
     private bool[] maximization;
-    public Hypervolume(RealVector reference, bool[] maximization) {
+    public Hypervolume(double[] reference, bool[] maximization) {
       if (reference.Length != 2) throw new Exception("Only 2-dimensional cases are supported yet");
       this.reference = reference;
@@ -37 +38 @@
     }
 
-    public double Compare(RealVector[] front, RealVector[] optimalFront) {
+    public double Compare(IEnumerable<double[]> front, IEnumerable<double[]> optimalFront) {
       return GetHypervolume(optimalFront) - GetHypervolume(front);
 
     }
 
-    public double GetHypervolume(RealVector[] front) {
+    public double GetHypervolume(IEnumerable<double[]> front) {
+      if (front == null) throw new ArgumentException("Fronts must not be null");
       //TODO what to do if set contains dominated points
-      front = (RealVector[])front.Clone(); //TODO this seems shady
-      Array.Sort<RealVector>(front, new DimensionComparer(0, maximization[0]));
-      RealVector last = front[front.Length - 1];
+      double[][] set = front.ToArray();   //Still no Good
+      if (set.Length == 0) throw new ArgumentException("Fronts must not be empty");
+      Array.Sort<double[]>(set, Utilities.getDimensionComparer(0, maximization[0]));
+      double[] last = set[set.Length - 1];
       CheckConsistency(last, 0);
       CheckConsistency(last, 1);
       double sum = 0;
-      for (int i = 0; i < front.Length - 1; i++) {
-        CheckConsistency(front[i], 1);
-        sum += Math.Abs((front[i][0] - front[i + 1][0])) * Math.Abs((front[i][1] - reference[1]));
+      for (int i = 0; i < set.Length - 1; i++) {
+        CheckConsistency(set[i], 1);
+        sum += Math.Abs((set[i][0] - set[i + 1][0])) * Math.Abs((set[i][1] - reference[1]));
       }
 
@@ -59 +62 @@
     }
 
-    public static double GetHypervolume(RealVector[] front, RealVector reference, bool[] maximization){
+    public static double GetHypervolume(IEnumerable<double[]> front, double[] reference, bool[] maximization){
       Hypervolume comp = new Hypervolume(reference, maximization);
       return comp.GetHypervolume(front);
     }
 
-    public static double GetDistance(RealVector[] front, RealVector[] optimalFront, RealVector reference, bool[] maximization) {
+    public static double GetDistance(IEnumerable<double[]> front, IEnumerable<double[]> optimalFront, double[] reference, bool[] maximization) {
       return GetHypervolume(optimalFront, reference, maximization) - GetHypervolume(front, reference, maximization);
     }
 
-    private void CheckConsistency(RealVector point, int dim) {
-      if (!maximization[dim] && point[dim] > reference[dim]) throw new Exception("Reference Point must be dominated by all points of the front");
-      if (maximization[dim] && point[dim] < reference[dim]) throw new Exception("Reference Point must be dominated by all points of the front");
-      if (point.Length != 2) throw new Exception("Only 2-dimensional cases are supported yet");
+    private void CheckConsistency(double[] point, int dim) {
+      if (!maximization[dim] && point[dim] > reference[dim]) throw new ArgumentException("Reference Point must be dominated by all points of the front");
+      if (maximization[dim] && point[dim] < reference[dim]) throw new ArgumentException("Reference Point must be dominated by all points of the front");
+      if (point.Length != 2) throw new ArgumentException("Only 2-dimensional cases are supported yet");
     }
-
-    private class DimensionComparer : IComparer<RealVector> {
-      private int dim;
-      private int descending;
-
-      public DimensionComparer(int dimension, bool descending) {
-        this.dim = dimension;
-        this.descending = descending ? -1 : 1;
-      }
-
-      #region IComparer<DoubleArray> Members
-
-      public int Compare(RealVector x, RealVector y) {
-        if (x[dim] < y[dim]) return -descending;
-        else if (x[dim] > y[dim]) return descending;
-        else return 0;
-      }
-
-      #endregion
-    }
-
   }
 }

branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Comparators/HyperVolumeFast.cs

@@ -1 +1 @@
 using System;
 using System.Collections.Generic;
-using HeuristicLab.Encodings.RealVectorEncoding;
+using HeuristicLab.Common;
+using HeuristicLab.Problems.MultiObjectiveTestFunctions.Comparators;
 
 namespace HeuristicLab.Problems.MultiObjectiveTestFunctions {
@@ -29 +30 @@
   public class FastHypervolume {
 
-    private RealVector reference;
+    private double[] reference;
     private bool[] maximization;
-    public FastHypervolume(RealVector reference, bool[] maximization) {
-      if (reference.Length != 2) throw new Exception("Only 2-dimensional cases are supported yet");
+    public FastHypervolume(double[] reference, bool[] maximization) {
+      if (reference.Length != 2) throw new NotSupportedException("Only 2-dimensional cases are supported yet");
       this.reference = reference;
       this.maximization = maximization;
     }
 
-    public double Compare(RealVector[] front, RealVector[] optimalFront, double[][] bounds) {
+    public double Compare(IEnumerable<double[]> front, IEnumerable<double[]> optimalFront, double[,] bounds) {
       return GetHypervolume(optimalFront, bounds) - GetHypervolume(front, bounds);
 
@@ -49 +50 @@
     /// <param name="bounds">also called region</param>
     /// <returns></returns>
-    public double GetHypervolume(RealVector[] front, double[][] bounds) {
+    public double GetHypervolume(IEnumerable<double[]> front, double[,] bounds) {
       //TODO what to do if set contains dominated points
-      var list = new List<RealVector>();
+      if (front == null) throw new ArgumentException("Fronts must not be null");
+      var list = new List<double[]>();
       list.AddRange(front);
-      list.Sort(new DimensionComparer(reference.Length - 1, maximization[reference.Length - 1]));
+      list.Sort(Utilities.getDimensionComparer(reference.Length - 1, maximization[reference.Length - 1]));
       var results = new ExPrivates(this);
-      GetHV(DeepClone(bounds), list, 1, reference[reference.Length - 1], results);
+      GetHV(SpanRegion(), list, 0, reference[reference.Length - 1], results);
       return results.Volume;
 
     }
+
+    private double[][] SpanRegion(double[,] bounds, int length) {
+      if (bounds.GetLength(1) != 2) throw new ArgumentException();
+      double[][] copy = new double[length][];
+      for (int i = 0; i < copy.Length; i++) {
+        copy[i] = new double[2];
+        for (int j = 0; j < 2; j++) {
+          copy[i][j] = bounds[i%bounds.GetLength(0),j];
+        }
+      }
+      return copy;
+    }
+
+    private double[][] SpanRegion() {
+      double[][] copy = new double[reference.Length][];
+      for (int i = 0; i < copy.Length; i++) {
+        copy[i] = new double[2];
+        copy[i][0] = 0;
+        copy[i][1] = reference[i];
+      }
+      return copy;
+
+    }
+
 
     private double[][] DeepClone(double[][] array) {
@@ -64 +90 @@
       for (int i = 0; i < copy.Length; i++) {
         copy[i] = new double[array[i].Length];
-        for (int j = 0; i < array[i].Length; j++) {
+        for (int j = 0; j < array[i].Length; j++) {
           copy[i][j] = array[i][j];
         }
@@ -80 +106 @@
 
       public int D {
-        get { return D; }
+        get { return d; }
       }
       public ExPrivates(FastHypervolume hv) {
@@ -91 +117 @@
     }
 
-    private void GetHV(double[][] region, List<RealVector> points, int split, double cover, ExPrivates results) {
+    private void GetHV(double[][] region, List<double[]> points, int split, double cover, ExPrivates results) {
       double coverNew = cover;
-      int coverIndex = 1;
+      int coverIndex = 0;
       bool allPiles = true;
-      int bound = -1;
+      double bound = -1;
 
       /* is the region completely covered? */
@@ -101 +127 @@
         if (covers(points[coverIndex], region, results)) {
           coverNew = points[coverIndex][results.D];
-          results.Volume += getMeasure(region) * (cover - coverNew);
-        } else { }
-        coverIndex++;
-      }
-      if (coverIndex == 1) return;
-
-      for (int i = 1; i < coverIndex; i++) { if (checkPile(points[i], region) == -1) allPiles = false; }
+          results.Volume += GetMeasure(region,results) * (cover - coverNew);
+        } else coverIndex++;
+      }
+      if (coverIndex == 0) return;
+
+      for (int i = 0; i < coverIndex; i++) { if (checkPile(points[i], region, results) == -1) allPiles = false; }
 
       if (allPiles) {
         /* calculate volume by sweeping along dimension d */
         var trellis = new double[reference.Length];
-        int i = 1;
-        for (int j = 1; j < results.D; j++) trellis[j] = reference[j];
+        int i = 0;
+        for (int j = 0; j < results.D-1; j++) trellis[j] = reference[j];
 
         double next;//bernhard
         do {
-          double current = points[i][results.D];
+          double current = points[i][results.D-1];
           do {
-            int pile = getPile(points[i], region);
+            int pile = checkPile(points[i], region,results);
             if (points[i][pile] < trellis[pile]) trellis[pile] = points[i][pile];
             i++;
-            if (i < coverIndex - 1) next = points[i][results.D]; else next = coverNew;
+            if (i < coverIndex - 1) next = points[i][results.D-1]; else next = coverNew;
           } while (current == next);
-          results.Volume += measure(trellis, region) * (next - current);
+          results.Volume += measure(trellis, region, results) * (next - current);
         } while (next != coverNew);
 
@@ -131 +156 @@
         do {
           var intersect = new List<Double>(); var nonIntersect = new List<Double>();
-          for (int i = 1; i < coverIndex; i++) {
+          for (int i = 0; i < coverIndex; i++) {
             var intersection = intersects(points[i], region, split);
             if (intersection == 1) intersect.Add(points[i][split]);
             if (intersection == 0) nonIntersect.Add(points[i][split]);
           }
-          if (intersect.Count != 0) bound = median(intersect);
-          else if (nonIntersect.Count > Math.Sqrt(n)) bound = median(nonIntersect);
+          if (intersect.Count != 0) bound = intersect.Median();
+          else if (nonIntersect.Count > Math.Sqrt(points.Count)) bound = nonIntersect.Median();
           else split++;
         } while (bound == -1);
@@ -145 +170 @@
       var regionC = DeepClone(region);
       regionC[split][1] = bound;
-      var pointsC = new List<RealVector>();
-      for (int i = 1; i < coverIndex; i++) {
-        if (partCovers(points[i], regionC, results)) move(points[i], pointsC);
+      var pointsC = new List<double[]>();
+      for (int i = 0; i < coverIndex; i++) {
+        if (partCovers(points[i], regionC, results)) move(points,i, pointsC);
       }
       if (pointsC.Count != 0) GetHV(regionC, pointsC, split, coverNew, results);
@@ -153 +178 @@
       regionC = region;
       regionC[split][0] = bound;
-      pointsC = new List<RealVector>();
+      pointsC = new List<double[]>();
       for (int i = 1; i < coverIndex; i++) {
-        if (partCovers(points[i], regionC, results)) move(points[i], pointsC);
+        if (partCovers(points[i], regionC, results)) move(points,i, pointsC);
       }
       if (pointsC.Count != 0) GetHV(regionC, pointsC, split, coverNew, results);
@@ -161 +186 @@
     }
 
-    private int checkPile(RealVector point, double[][] region, ExPrivates results) {
+    private void reinsert(List<double[]> pointsC, List<double[]> points) {
+      points.AddRange(pointsC);
+      pointsC.Clear();
+    }
+
+    private double GetMeasure(double[][] region,ExPrivates result) {
+      double volume = 1.0;
+      // for ( std::size_t i = 0; i < regionLow.size(); i++ ) {
+      for (int i = 1; i < result.D; i++) {
+      volume *= (region[1][i] - region[0][i]);
+      }
+      return (volume);
+    }
+
+    private void move(List<double[]> points, int i, List<double[]> pointsC) {
+      double[] v = points[i];
+      points.Remove(v);
+      pointsC.Add(v);
+    }
+
+    private double measure(double[] trellis, double[][] region, ExPrivates results) {
+      double volume=0;
+      bool[] indicator = new bool[results.D];
+      for (int i = 0; i < results.D-1; i++) indicator[i] = true;
+      int numberSummands = integerValue(indicator);
+
+      for (int i = 0; i <= numberSummands; i++) {
+        indicator = binaryValue(i);
+        int oneCounter = 0;
+        double summand = 0;
+        for (int j = 1; j < results.D; j++) {
+          if (indicator[i] == true) {
+            summand += region[1][j] - trellis[j];
+            oneCounter++;
+          } else {
+            summand += region[1][j] - region[0][j];
+          }
+        }
+        if(oneCounter%2 == 0) {
+          volume -= summand;
+        } else {
+          volume += summand;
+        }
+      }
+      return volume;
+    }
+
+    private int integerValue(bool[] binary) {
+      int sum=0;
+      foreach (bool b in binary) {
+        sum = (sum << 1) + (b ? 1 : 0);
+      }
+      return sum;
+    }
+
+    private bool[] binaryValue(int integer) {
+      bool[] res = new bool[32];
+      int i = 0;
+      while (integer != 0) {
+        res[i++]= (integer & 1)==1;
+        integer >>= 1;
+      }
+      return res;
+
+    }
+
+    private int checkPile(double[] point, double[][] region, ExPrivates results) {
       int pile = -1;
-      for (int j = 1; j < results.D; j++) {
+      for (int j = 0; j < results.D-1; j++) {
         if (point[j] > region[j][0]) {
           if (pile != -1) return -1;
@@ -173 +264 @@
     }
 
-    private int intersects(RealVector point, double[][] region, int split) {
+    private int intersects(double[] point, double[][] region, int split) {
       if (region[split][0] >= point[split]) return -1;
       for (int j = 1; j < split; j++) {
@@ -182 +273 @@
     }
 
-    private bool covers(RealVector point, double[][] region, ExPrivates results) {
+    private bool covers(double[] point, double[][] region, ExPrivates results) {
       for (int j = 1; j < results.D; j++) {
         if (point[j] > region[j][0]) return false;
@@ -190 +281 @@
     }
 
-    private bool partCovers(RealVector point, double[][] region, ExPrivates results) {
+    private bool partCovers(double[] point, double[][] region, ExPrivates results) {
       for (int j = 1; j < results.D; j++) {
         if (point[j] >= region[j][1]) return false;
@@ -197 +288 @@
     }
 
-    public static double GetHypervolume(RealVector[] front, RealVector reference, bool[] maximization) {
-      Hypervolume comp = new Hypervolume(reference, maximization);
-      return comp.GetHypervolume(front);
-    }
-
-    public static double GetDistance(RealVector[] front, RealVector[] optimalFront, RealVector reference, bool[] maximization) {
-      return GetHypervolume(optimalFront, reference, maximization) - GetHypervolume(front, reference, maximization);
-    }
-
-    private void CheckConsistency(RealVector point, int dim) {
+    public static double GetHypervolume(IEnumerable<double[]> front, double[] reference, bool[] maximization, double[,] bounds) {
+      FastHypervolume comp = new FastHypervolume(reference, maximization);
+      return comp.GetHypervolume(front,bounds);
+    }
+
+    public static double GetDistance(IEnumerable<double[]> front, IEnumerable<double[]> optimalFront, double[] reference, bool[] maximization, double[,] bounds) {
+      return GetHypervolume(optimalFront, reference, maximization, bounds) - GetHypervolume(front, reference, maximization,bounds);
+    }
+
+    private void CheckConsistency(double[] point, int dim) {
       if (!maximization[dim] && point[dim] > reference[dim]) throw new Exception("Reference Point must be dominated by all points of the front");
       if (maximization[dim] && point[dim] < reference[dim]) throw new Exception("Reference Point must be dominated by all points of the front");
     }
 
-    private class DimensionComparer : IComparer<RealVector> {
-      private int dim;
-      private int descending;
-
-      public DimensionComparer(int dimension, bool descending) {
-        this.dim = dimension;
-        this.descending = descending ? -1 : 1;
-      }
-
-      #region IComparer<DoubleArray> Members
-
-      public int Compare(RealVector x, RealVector y) {
-        if (x[dim] < y[dim]) return -descending;
-        else if (x[dim] > y[dim]) return descending;
-        else return 0;
-      }
-
-      #endregion
-    }
+
+
+
+
+
+
+   
+
 
   }

branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Comparators/InvertedGenerationalDistance.cs

@@ -1 +1 @@
 using System;
+using System.Collections.Generic;
 using HeuristicLab.Encodings.RealVectorEncoding;
+using HeuristicLab.Problems.MultiObjectiveTestFunctions.Comparators;
 
 namespace HeuristicLab.Problems.MultiObjectiveTestFunctions {
@@ -11 +13 @@
 
     public InvertedGenerationalDistance(double p) {
+      if (p <= 0) throw new ArgumentOutOfRangeException("weighting factor p has to be greater than 0");
       this.p = 1 / p;
     }
-
-
 
     /// <summary>
@@ -23 +24 @@
     /// <param name="p"></param>
     /// <returns></returns>
-    public static double GetDistance(RealVector[] front, RealVector[] optimalFront, double p) {
+    public static double GetDistance(IEnumerable<double[]> front, IEnumerable<double[]> optimalFront, double p) {
       return new InvertedGenerationalDistance(p).Compare(front, optimalFront);
     }
 
-    public double Compare(RealVector[] front, RealVector[] optimalFront) {
-      //TODO build a kd-tree, sort the array, do someting intelligent here
-      double sum = 0;
-      if (front.Length == 0 || optimalFront.Length == 0) throw new Exception("Both Fronts need to contain at least one point");
-      foreach (RealVector r in optimalFront) {
-        sum += minDistance(r, front);
-      }
-      return Math.Pow(sum, p) / optimalFront.Length;
+    public double Compare(IEnumerable<double[]> front, IEnumerable<double[]> optimalFront) {
+      return new GenerationalDistance(p).Compare(optimalFront, front);
     }
-
-    private double minDistance(RealVector point, RealVector[] list) {
-      //TODO inefficient
-      double min = Double.MaxValue;
-      foreach (RealVector r in list) {
-        if (r == point) continue;
-        double d = 0;
-        for (int i = 0; i < r.Length; i++) {
-          d += (point[i] - r[i]) * (point[i] - r[i]);
-        }
-        min = Math.Min(d, min);
-      }
-      return Math.Sqrt(min);
-    }
-
   }
 }

branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Comparators/Spacing.cs

@@ -1 +1 @@
 using System;
+using System.Collections.Generic;
+using HeuristicLab.Common;
 using HeuristicLab.Encodings.RealVectorEncoding;
+using HeuristicLab.Problems.MultiObjectiveTestFunctions.Comparators;
 
 namespace HeuristicLab.Problems.MultiObjectiveTestFunctions {
@@ -15 +18 @@
 
 
-    public static double GetSpacing(RealVector[] front) {
+    public static double GetSpacing(IEnumerable<double[]> front) {
       return new Spacing().Get(front);
     }
-    public static double GetDistance(RealVector[] front, RealVector[] optimalFront) {
+    public static double GetDistance(IEnumerable<double[]> front, IEnumerable<double[]> optimalFront) {
       return new Spacing().Get(front);
     }
 
-    public double Compare(RealVector[] front, RealVector[] optimalFront) {
+    public double Compare(IEnumerable<double[]> front, IEnumerable<double[]> optimalFront) {
       return GetSpacing(front) - GetSpacing(optimalFront);
     }
 
-    public double Get(RealVector[] front) {
+    public double Get(IEnumerable<double[]> front) {
       //TODO build a kd-tree, sort the array, do someting intelligent here
-      double sum = 0;
-      if (front.Length == 0) throw new Exception("Front does not contain any points");
-      double[] d = new double[front.Length];
-      int i = 0;
-      foreach (RealVector r in front) {
-        d[i] = minDistance(r, front);
-        sum += d[i++];
+      if (front == null) throw new ArgumentException("Fronts must not be null");
+      List<double> d = new List<double>();
+      foreach (double[] r in front) {
+        double dist = Utilities.minDistance(r, front, false);
+        d.Add(dist>=0?dist:0);
+      }
+      int n = d.Count;
+      if (n == 0) throw new ArgumentException("Fronts must not be empty");
+      return Math.Sqrt(d.Variance()*(n-1)/n);
 
-      }
-      double mean = sum / front.Length;
-      sum = 0;
-      foreach (double e in d) {
-        sum += (e - mean) * (e - mean);
-      }
-      sum /= front.Length;
-      return Math.Sqrt(sum);
-
-    }
-
-    private double minDistance(RealVector point, RealVector[] list) {
-      //TODO inefficient
-      double min = Double.MaxValue;
-      foreach (RealVector r in list) {
-        if (r == point) continue;
-        double d = 0;
-        for (int i = 0; i < r.Length; i++) {
-          d += (point[i] - r[i]) * (point[i] - r[i]);
-        }
-        min = Math.Min(d, min);
-      }
-      return Math.Sqrt(min);
     }