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

using System.Collections.Generic;

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
    {
        #region Properties

        public double[] Values { get; }
        public int NumberOfDimensions => Values.Length;

        #endregion Properties

        #region Constructors

        public ReferencePoint(int numberOfDimensions)
        {
            Values = new double[numberOfDimensions];
        }

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

        #endregion Constructors

        // 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(int nDim, int nDiv)
        {
            List<ReferencePoint> referencePoints = new List<ReferencePoint>();
            ReferencePoint refPoint = new ReferencePoint(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);
                }
            }
        }
    }
}