source: branches/2825-NSGA3/HeuristicLab.Algorithms.NSGA3/3.3/ReferencePoint.cs @ 17657

using System;
using System.Collections.Generic;
using System.Linq;
using HeuristicLab.Core;

namespace HeuristicLab.Algorithms.NSGA3
{
    /*
     * The method for generating the reference points is based on the NSGA3 implementation in the jMetal framework (http://jmetal.sourceforge.net/).
     * That implementation in return is based on Tsung-Che Chiang's code
     * http://web.ntnu.edu.tw/~tcchiang/publications/nsga3cpp/nsga3cpp.htm
     */

    public class ReferencePoint
    {
        private readonly Dictionary<Solution, double> potentialAssociatedSolutions = new Dictionary<Solution, double>();

        #region Properties

        public IRandom random;
        public double[] Values { get; }
        public int NumberOfDimensions => Values.Length;
        public int NumberOfAssociatedSolutions { get; set; } = 0;

        #endregion Properties

        #region Constructors

        public ReferencePoint(IRandom random, int numberOfDimensions)
        {
            this.random = random;
            Values = new double[numberOfDimensions];
        }

        public ReferencePoint(ReferencePoint other)
        {
            random = other.random;
            Values = new double[other.NumberOfDimensions];
            for (int i = 0; i < other.NumberOfDimensions; i++)
                Values[i] = other.Values[i];
        }

        #endregion Constructors

        #region Static methods

        // todo: use this (for optimization)
        /// <summary>
        /// Returns the number of reference points that are generated by <see
        /// cref="GenerateReferencePoints(List{ReferencePoint}, int, int)" /> for the given number
        /// of dimensions and divisions.
        /// </summary>
        /// <param name="nDim">The number of dimensions</param>
        /// <param name="nDiv">The number of divisions</param>
        /// <returns></returns>
        internal static int GetNumberOfReferencePoints(int nDim, int nDiv)
        {
            return Utility.NCR(nDim + nDiv - 1, nDiv);
        }

        // maybe todo: move this to another class?
        /// <summary>
        /// Generate reference points that are evenly distributed over a hyperplane with dimensions
        /// <paramref name="nDim" /> - 1 with the sum of the values in all dimensions being equal to
        /// 1 for each reference point.
        /// </summary>
        /// <param name="nDim">The number of dimensions for the reference points</param>
        /// <param name="nDiv">The number of divisions to use to generate reference points</param>
        /// <returns>The generated reference points</returns>
        internal static List<ReferencePoint> GenerateReferencePoints(IRandom random, int nDim, int nDiv)
        {
            List<ReferencePoint> referencePoints = new List<ReferencePoint>();
            ReferencePoint refPoint = new ReferencePoint(random, nDim);
            GenerateRecursive(referencePoints, refPoint, nDim, nDiv, nDiv, 0);

            return referencePoints;
        }

        private static void GenerateRecursive(List<ReferencePoint> referencePoints, ReferencePoint refPoint, int numberOfObjectives, int left, int total, int element)
        {
            if (element == numberOfObjectives - 1)
            {
                refPoint.Values[element] = ((double)left) / total;
                var newRefPoint = new ReferencePoint(refPoint);
                referencePoints.Add(newRefPoint);
            }
            else
            {
                for (int i = 0; i <= left; i++)
                {
                    refPoint.Values[element] = (double)i / total;
                    GenerateRecursive(referencePoints, refPoint, numberOfObjectives, left - i, total, element + 1);
                }
            }
        }

        #endregion Static methods

        public void AddPotentialAssociatedSolution(Solution s, double distance)
        {
            if (potentialAssociatedSolutions.ContainsKey(s))
                throw new InvalidOperationException("Attempt to add potential solution to reference point failed: That solution was already added as a potential solution");

            potentialAssociatedSolutions.Add(s, distance);
        }

        public void RemovePotentialAssociatedSolution(Solution s)
        {
            potentialAssociatedSolutions.Remove(s);
        }

        public bool HasPotentialMember()
        {
            return potentialAssociatedSolutions.Any();
        }

        internal Solution FindClosestMember()
        {
            if (!potentialAssociatedSolutions.Any())
                throw new InvalidOperationException("No potential members exist");

            return Utility.ArgMin(pair => pair.Value, potentialAssociatedSolutions).Key;
        }

        internal Solution RandomMember()
        {
            if (!potentialAssociatedSolutions.Any())
                throw new InvalidOperationException("No potential members exist");

            return potentialAssociatedSolutions.Keys.ElementAt(random.Next(potentialAssociatedSolutions.Count));
        }
    }
}