source: branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Calculators/HyperVolume.cs @ 13894

#region License Information
/* HeuristicLab
 * Copyright (C) 2002-2016 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
 *
 * This file is part of HeuristicLab.
 *
 * HeuristicLab is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * HeuristicLab is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
 */
#endregion
using System;
using System.Collections.Generic;
using System.Linq;

namespace HeuristicLab.Problems.MultiObjectiveTestFunctions {

  public class Hypervolume {

    /// <summary>
    /// The Hyprevolume-metric is defined as the Hypervolume enclosed between a given reference point,
    /// that is fixed for every evaluation function and the evaluated front.
    /// 
    /// Example:
    /// r is the reference Point at (1|1)  and every Point p is part of the evaluated front
    /// The filled Area labled HV is the 2 diensional Hypervolume enclosed by this front. 
    /// 
    /// (0|1)                (1|1)
    ///   +      +-------------r
    ///   |      |###### HV ###|
    ///   |      p------+######|
    ///   |             p+#####|
    ///   |              |#####|
    ///   |              p-+###|
    ///   |                p---+
    ///   |                 
    ///   +--------------------1
    /// (0|0)                (1|0)
    /// 
    ///  Please note that in this example both dimensions are minimized. The reference Point need to be dominated by EVERY point in the evaluated front 
    /// 
    /// </summary>
    public static double Calculate(IEnumerable<double[]> front, IEnumerable<double> reference, bool[] maximization) {
      List<double> list = new List<double>();
      foreach (double d in reference) list.Add(d);
      double[] refp = list.ToArray<double>();
      if (front == null) throw new ArgumentException("Fronts must not be null");
      double[][] set = front.ToArray();   //Still no Good
      if (set.Length == 0) throw new ArgumentException("Fronts must not be empty");
      if (refp.Length != set[0].Length) throw new ArgumentException("Front and referencepoint need to be of the same dimensionality");
      Array.Sort<double[]>(set, Utilities.getDimensionComparer(0, maximization[0]));
      double[] last = set[set.Length - 1];
      CheckConsistency(last, 0, refp, maximization);
      CheckConsistency(last, 1, refp, maximization);

      double sum = 0;
      for (int i = 0; i < set.Length - 1; i++) {
        CheckConsistency(set[i], 1, refp, maximization);
        sum += Math.Abs((set[i][0] - set[i + 1][0])) * Math.Abs((set[i][1] - refp[1]));
      }

      sum += Math.Abs(refp[0] - last[0]) * Math.Abs(refp[1] - last[1]);
      return sum;
    }

    private static void CheckConsistency(double[] point, int dim, double[] reference, bool[] maximization) {
      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");
    }
  }
}