source: branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Calculators/Utilities.cs @ 13672

#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;

namespace HeuristicLab.Problems.MultiObjectiveTestFunctions {
  internal class Utilities {

    /// <summary>
    /// 
    /// </summary>
    /// <param name="point"></param>
    /// <param name="list"></param>
    /// <param name="reflexive"></param>
    /// <returns>return -1 if list contains only rejected points</returns>
    internal static double minDistance(double[] point, IEnumerable<double[]> list, bool reflexive) {
      double min = double.MaxValue;
      bool empty = true;
      foreach (double[] r in list) {
        empty = false;
        if (!reflexive && ReferenceEquals(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);
      }
      if (empty) throw new ArgumentException("Fronts must not be empty");
      if (min == double.MaxValue) { return -1; }
      return Math.Sqrt(min);
    }

    internal static IComparer<double[]> getDimensionComparer(int dim, bool descending) {
      return new DimensionComparer(dim, descending);
    }


    internal class DimensionComparer : IComparer<double[]> {
      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(double[] x, double[] y) {
        if (x[dim] < y[dim]) return -descending;
        else if (x[dim] > y[dim]) return descending;
        else return 0;
      }

      #endregion
    }
  }





}