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

Timestamp:

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

Author:

bwerth

Message:

#1087 regorganized testfunctions, added view for qualities

File:

• branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Comparators/Crowding.cs (modified) (2 diffs)

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);
     }