Index: /branches/2825-NSGA3/HeuristicLab.Algorithms.NSGA3/3.3/HeuristicLab.Algorithms.NSGA3-3.3.csproj
===================================================================
--- /branches/2825-NSGA3/HeuristicLab.Algorithms.NSGA3/3.3/HeuristicLab.Algorithms.NSGA3-3.3.csproj	(revision 17557)
+++ /branches/2825-NSGA3/HeuristicLab.Algorithms.NSGA3/3.3/HeuristicLab.Algorithms.NSGA3-3.3.csproj	(revision 17558)
@@ -111,5 +111,7 @@
     <Compile Include="Plugin.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="ReferencePoint.cs" />
     <Compile Include="Solution.cs" />
+    <Compile Include="Utility.cs" />
   </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
Index: /branches/2825-NSGA3/HeuristicLab.Algorithms.NSGA3/3.3/NSGA3.cs
===================================================================
--- /branches/2825-NSGA3/HeuristicLab.Algorithms.NSGA3/3.3/NSGA3.cs	(revision 17557)
+++ /branches/2825-NSGA3/HeuristicLab.Algorithms.NSGA3/3.3/NSGA3.cs	(revision 17558)
@@ -1,3 +1,4 @@
 ﻿using System;
+using System.Collections.Generic;
 using System.Linq;
 using System.Threading;
@@ -62,4 +63,8 @@
         private const string DominateOnEqualQualitiesName = "DominateOnEqualQualities";
 
+        // Results Names
+
+        private const string GeneratedReferencePointsResultName = "Generated Reference Points";
+
         #endregion ParameterAndResultsNames
 
@@ -120,4 +125,14 @@
 
         #endregion Properties
+
+        #region ResultsProperties
+
+        public DoubleMatrix ResultsGeneratedReferencePoints
+        {
+            get { return (DoubleMatrix)Results[GeneratedReferencePointsResultName].Value; }
+            set { Results[GeneratedReferencePointsResultName].Value = value; }
+        }
+
+        #endregion ResultsProperties
 
         public NSGA3() : base()
@@ -147,4 +162,6 @@
         }
 
+        #region Overriden Methods
+
         public override IDeepCloneable Clone(Cloner cloner)
         {
@@ -152,8 +169,36 @@
         }
 
+        protected override void Initialize(CancellationToken cancellationToken)
+        {
+            base.Initialize(cancellationToken);
+
+            InitResults();
+            InitReferencePoints();
+        }
+
         protected override void Run(CancellationToken cancellationToken)
         {
             throw new NotImplementedException();
         }
+
+        #endregion Overriden Methods
+
+        #region Private Methods
+
+        private void InitResults()
+        {
+            Results.Add(new Result(GeneratedReferencePointsResultName, "The initially generated reference points", new DoubleMatrix()));
+        }
+
+        // Generates the structured reference points
+        private void InitReferencePoints()
+        {
+            // Generate reference points and add them to results
+            int nDiv = 5; // todo: figure out the correct number of divisions
+            List<ReferencePoint> referencePoints = ReferencePoint.GenerateReferencePoints(Problem.Encoding.Length, nDiv);
+            ResultsGeneratedReferencePoints = Utility.ConvertToDoubleMatrix(referencePoints);
+        }
+
+        #endregion Private Methods
     }
 }
Index: /branches/2825-NSGA3/HeuristicLab.Algorithms.NSGA3/3.3/ReferencePoint.cs
===================================================================
--- /branches/2825-NSGA3/HeuristicLab.Algorithms.NSGA3/3.3/ReferencePoint.cs	(revision 17558)
+++ /branches/2825-NSGA3/HeuristicLab.Algorithms.NSGA3/3.3/ReferencePoint.cs	(revision 17558)
@@ -0,0 +1,80 @@
+﻿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
+     */
+
+    internal class ReferencePoint
+    {
+        public ReferencePoint(int numberOfDimensions)
+        {
+            NumberOfDimensions = numberOfDimensions;
+            Values = new double[NumberOfDimensions];
+        }
+
+        public ReferencePoint(ReferencePoint other)
+        {
+            NumberOfDimensions = other.NumberOfDimensions;
+            Values = new double[NumberOfDimensions];
+            for (int i = 0; i < NumberOfDimensions; i++)
+                Values[i] = other.Values[i];
+        }
+
+        public int NumberOfDimensions { get; }
+
+        public double[] Values { get; }
+
+        // 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);
+        }
+
+        /// <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);
+                }
+            }
+        }
+    }
+}
Index: /branches/2825-NSGA3/HeuristicLab.Algorithms.NSGA3/3.3/Utility.cs
===================================================================
--- /branches/2825-NSGA3/HeuristicLab.Algorithms.NSGA3/3.3/Utility.cs	(revision 17558)
+++ /branches/2825-NSGA3/HeuristicLab.Algorithms.NSGA3/3.3/Utility.cs	(revision 17558)
@@ -0,0 +1,58 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Data;
+
+namespace HeuristicLab.Algorithms.NSGA3
+{
+    internal static class Utility
+    {
+        /// <summary>
+        /// Returns the number of possible combinations of size <paramref name="r" /> from a set of
+        /// size <paramref name="n" />.
+        /// </summary>
+        /// <param name="n"></param>
+        /// <param name="r"></param>
+        /// <returns></returns>
+        /// <exception cref="ArgumentException">
+        /// Thrown, when <paramref name="r" /> &gt; <paramref name="n" /> or when <paramref name="r"
+        /// /> &lt; 1.
+        /// </exception>
+        internal static int NCR(int n, int r)
+        {
+            if (n < r) throw new ArgumentException($"Constraint was not met: n >= r (n = {n}, r = {r})");
+            if (r < 1) throw new ArgumentException($"Constraint was not met: r >= 1 (r = {r})");
+            if (n == r) return n;
+            return Factorial(n) / (Factorial(r) * Factorial(n - r));
+        }
+
+        internal static int Factorial(int n)
+        {
+            if (n <= 0) throw new ArgumentException($"Constraint for n was not met: 0 < n <= 30 (n = {n})");
+            int product = 1;
+            for (int i = 2; i <= n; i++)
+                product *= i;
+
+            return product;
+        }
+
+        internal static DoubleMatrix ConvertToDoubleMatrix(List<ReferencePoint> referencePoints)
+        {
+            return new DoubleMatrix(ToArray(referencePoints));
+        }
+
+        internal static double[,] ToArray(List<ReferencePoint> referencePoints)
+        {
+            if (referencePoints == null || !referencePoints.Any()) throw new ArgumentException($"{nameof(referencePoints)} is null or empty");
+            int nDim = referencePoints.First().NumberOfDimensions;
+            int pointCount = referencePoints.Count;
+            double[,] array = new double[nDim, pointCount];
+
+            for (int p = 0; p < pointCount; p++)
+                for (int d = 0; d < nDim; d++)
+                    array[d, p] = referencePoints[p].Values[d];
+
+            return array;
+        }
+    }
+}
