Implement the NSGA-III algorithm

CMakeLists.txt

@@ -259,6 +259,7 @@ set(PAGMO_SRC_FILES
     "${CMAKE_CURRENT_SOURCE_DIR}/src/algorithms/moead.cpp"
     "${CMAKE_CURRENT_SOURCE_DIR}/src/algorithms/moead_gen.cpp"
     "${CMAKE_CURRENT_SOURCE_DIR}/src/algorithms/nsga2.cpp"
+    "${CMAKE_CURRENT_SOURCE_DIR}/src/algorithms/nsga3.cpp"
     "${CMAKE_CURRENT_SOURCE_DIR}/src/algorithms/gaco.cpp"
     "${CMAKE_CURRENT_SOURCE_DIR}/src/algorithms/de1220.cpp"
     "${CMAKE_CURRENT_SOURCE_DIR}/src/algorithms/gwo.cpp"
@@ -293,6 +294,7 @@ set(PAGMO_SRC_FILES
     "${CMAKE_CURRENT_SOURCE_DIR}/src/utils/hv_algos/hv_hv2d.cpp"
     "${CMAKE_CURRENT_SOURCE_DIR}/src/utils/hv_algos/hv_hv3d.cpp"
     "${CMAKE_CURRENT_SOURCE_DIR}/src/utils/hv_algos/hv_hvwfg.cpp"
+    "${CMAKE_CURRENT_SOURCE_DIR}/src/utils/reference_point.cpp"
     # Detail.
     "${CMAKE_CURRENT_SOURCE_DIR}/src/detail/base_sr_policy.cpp"
     "${CMAKE_CURRENT_SOURCE_DIR}/src/detail/bfe_impl.cpp"

include/pagmo/algorithms/nsga3.hpp

@@ -0,0 +1,67 @@
+#ifndef PAGMO_ALGORITHMS_NSGA3_HPP
+#define PAGMO_ALGORITHMS_NSGA3_HPP
+
+#include <string>
+#include <tuple>
+#include <vector>
+
+#include <pagmo/rng.hpp>  // random_device, random_engine_type
+#include <pagmo/detail/visibility.hpp>  // PAGMO_DLL_PUBLIC
+#include <pagmo/population.hpp>  // population
+#include <pagmo/utils/reference_point.hpp>  // ReferencePoint
+
+
+namespace pagmo{
+
+class PAGMO_DLL_PUBLIC nsga3{
+    public:
+        typedef struct{
+            std::vector<std::vector<double>> v_extreme;
+            std::vector<double> v_ideal;
+            std::vector<double> v_nadir;
+        } NSGA3Memory;
+        // Log line format: (gen, fevals, ideal_point)
+        typedef std::tuple<unsigned, unsigned long long, vector_double> log_line_type;
+        typedef std::vector<log_line_type> log_type;
+        // Defaults from IEEE ToEC Vol.18 Iss.4 Aug, 2014
+        nsga3(unsigned gen = 1u, double cr = 1.0, double eta_c = 30.0,
+              double mut = 0.10, double eta_mut = 20.0, size_t divisions = 12u,
+              unsigned seed = pagmo::random_device::next(), bool use_memory = false);
+        std::string get_name() const{ return "NSGA-III:"; }
+        population evolve(population) const;
+        std::vector<size_t> selection(population &, size_t) const;
+        std::vector<ReferencePoint> generate_uniform_reference_points(size_t nobjs, size_t divisions) const;
+        std::vector<std::vector<double>> translate_objectives(population) const;
+        std::vector<std::vector<double>> find_extreme_points(population, std::vector<std::vector<pop_size_t>> &, std::vector<std::vector<double>> &) const;
+        std::vector<double> find_intercepts(population, std::vector<std::vector<double>> &) const;
+        std::vector<std::vector<double>> normalize_objectives(std::vector<std::vector<double>> &, std::vector<double> &) const;
+        const log_type &get_log() const { return m_log; }
+        void set_verbosity(unsigned level) { m_verbosity = level; }
+        unsigned get_verbosity() const { return m_verbosity; }
+        void set_seed(unsigned seed) { m_reng.seed(seed); m_seed = seed; }
+        unsigned get_seed() const { return m_seed; }
+        bool has_memory() const {return m_use_memory; }
+    private:
+        unsigned m_gen;
+        double m_cr;        // crossover
+        double m_eta_c;     // eta crossover
+        double m_mut;       // mutation
+        double m_eta_mut;   // eta mutation
+        size_t m_divisions; // Reference Point hyperplane subdivisions
+        unsigned m_seed;    // Seed for PRNG initialisation
+        bool m_use_memory;  // Preserve extremes, ideal, nadir across generations
+        mutable NSGA3Memory m_memory{};
+        mutable detail::random_engine_type m_reng;  // Defaults to std::mt19937
+        mutable log_type m_log;
+        unsigned m_verbosity {0};
+        mutable std::vector<ReferencePoint> m_refpoints;
+        // Serialisation support
+        friend class boost::serialization::access;
+        template <typename Archive>
+        void serialize(Archive &, unsigned int);
+};
+
+}  // namespace pagmo
+
+PAGMO_S11N_ALGORITHM_EXPORT_KEY(pagmo::nsga3)
+#endif

include/pagmo/utils/multi_objective.hpp

@@ -42,6 +42,7 @@ see https://www.gnu.org/licenses/. */
 
 #include <pagmo/detail/visibility.hpp>
 #include <pagmo/exceptions.hpp>
+#include <pagmo/rng.hpp>
 #include <pagmo/types.hpp>
 #include <pagmo/utils/discrepancy.hpp>
 #include <pagmo/utils/generic.hpp>
@@ -215,6 +216,23 @@ inline std::vector<vector_double> decomposition_weights(vector_double::size_type
 PAGMO_DLL_PUBLIC vector_double decompose_objectives(const vector_double &, const vector_double &, const vector_double &,
                                                     const std::string &);
 
+// Gaussian Elimination
+PAGMO_DLL_PUBLIC vector_double gaussian_elimination(std::vector<std::vector<double>>, const vector_double &);
+
+// Achievement Scalarization Function
+PAGMO_DLL_PUBLIC double achievement(const vector_double &, const vector_double &);
+
+// Perpendicular distance to reference point vectors
+PAGMO_DLL_PUBLIC double perpendicular_distance(const std::vector<double> &, const std::vector<double> &);
+
+/* Choose single random element from vector container */
+template <class T>
+T choose_random_element(const std::vector<T> &container){
+    std::vector<T> choice;
+    std::sample(container.begin(), container.end(), std::back_inserter(choice), 1, std::mt19937{random_device::next()});
+    return choice[0];
+}
+
 } // namespace pagmo
 
 #endif

include/pagmo/utils/reference_point.hpp

@@ -0,0 +1,63 @@
+/*
+ *  Defines a ReferencePoint type used by the NSGA-III algorithm
+ *
+ */
+
+#ifndef PAGMO_UTILS_REFERENCE_POINT
+#define PAGMO_UTILS_REFERENCE_POINT
+
+#include <iostream>
+#include <optional>
+#include <string>
+#include <sstream>
+#include <vector>
+
+#include <pagmo/detail/visibility.hpp>  // PAGMO_DLL_PUBLIC
+#include <pagmo/population.hpp>         // pop_size_t
+
+
+namespace pagmo{
+
+class PAGMO_DLL_PUBLIC ReferencePoint{
+    public:
+        ReferencePoint(size_t nobj);
+        size_t dim() const;
+        //double& operator[](int);
+        double& operator[](size_t);
+        friend PAGMO_DLL_PUBLIC std::ostream& operator<<(std::ostream& ostr, const ReferencePoint& rp);
+        void increment_members(){ ++nmembers; }
+        void decrement_members(){ --nmembers; }
+        size_t member_count() const{ return nmembers; }
+        void add_candidate(size_t, double);
+        void remove_candidate(size_t index);
+        size_t candidate_count() const{ return candidates.size(); }
+        std::vector<double> get_coeffs(){ return coeffs; }
+        std::optional<size_t> nearest_candidate() const;
+        std::optional<size_t> random_candidate() const;
+        std::optional<size_t> select_member() const;
+    protected:
+        std::vector<double> coeffs{0};
+        size_t nmembers{0};
+        std::vector<std::pair<size_t, double>> candidates;
+};
+
+std::vector<ReferencePoint> generate_reference_point_level(
+    ReferencePoint& rp,
+    size_t remain,
+    size_t level,
+    size_t total
+);
+
+void associate_with_reference_points(
+    std::vector<ReferencePoint> &,          // Reference points
+    std::vector<std::vector<double>>,       // Normalized objectives
+    std::vector<std::vector<pop_size_t>>    // NDS Fronts
+);
+
+size_t identify_niche_point(std::vector<ReferencePoint> &);
+
+size_t n_choose_k(size_t, size_t);
+
+}  // namespace pagmo
+
+#endif