structure for int-handling

Author: jacobdenobel

include/bounds.hpp

@@ -14,8 +14,6 @@ namespace parameters
 
 namespace bounds
 {
-	using Mask = Eigen::Array<bool, Eigen::Dynamic, 1>;
-
 	Mask is_out_of_bounds(const Vector &xi, const Vector &lb, const Vector &ub);
 	bool any_out_of_bounds(const Vector &xi, const Vector &lb, const Vector &ub);
 

include/common.hpp

@@ -28,6 +28,8 @@ using Matrix = Eigen::Matrix<Float, -1, -1>;
 using Vector = Eigen::Matrix<Float, -1, 1>;
 using Array = Eigen::Array<Float, -1, 1>;
 using size_to = std::optional<size_t>;
+using Mask = Eigen::Array<bool, Eigen::Dynamic, 1>;
+using Indices = Eigen::ArrayXi;
 
 template <typename T>
 std::ostream &operator<<(std::ostream &os, const std::vector<T> &x);

include/integer.hpp

@@ -0,0 +1,54 @@
+#pragma once
+
+#include "common.hpp"
+
+namespace parameters
+{
+	struct Parameters;
+}
+
+
+namespace integer
+{
+
+    struct IntegerHandling
+    {
+        Float lb_sigma;
+        Vector ones;
+        Vector effective_y;
+
+        IntegerHandling(const size_t d, const Float mueff) 
+            : 
+            lb_sigma(std::min(0.2, mueff / static_cast<Float>(d))), 
+            ones(Vector::Ones(d)), 
+            effective_y(Vector::Ones(d))
+        {
+        }
+
+        virtual void update_diagonal(const parameters::Parameters& p);
+
+        virtual Array get_effective_sigma(const parameters::Parameters& p, const size_t idx); 
+
+        virtual void round_to_integer(Eigen::Ref<Vector> x, const Indices iidx) 
+        {
+            for (const auto& idx: iidx)
+                x[idx] = std::round(x[idx]);
+        }
+    };
+
+    struct NoIntegerHandling : IntegerHandling
+    {
+        using IntegerHandling::IntegerHandling;
+
+        // virtual void get_effective_sigma(const parameters::Parameters& p) override {}
+        // void round_to_integer(Eigen::Ref<Vector>  x, const Indices iidx) override {}
+    };
+
+    inline std::shared_ptr<IntegerHandling> get(const Indices &idx, const size_t d, const Float mueff)
+    {
+        if (idx.size() == 0)
+            return std::make_shared<NoIntegerHandling>(d, mueff);
+
+        return std::make_shared<IntegerHandling>(d, mueff);
+    }
+}

include/parameters.hpp

@@ -12,6 +12,7 @@
 #include "weights.hpp"
 #include "repelling.hpp"
 #include "center_placement.hpp"
+#include "integer.hpp"
 
 namespace parameters
 {
@@ -39,7 +40,8 @@ namespace parameters
         std::shared_ptr<bounds::BoundCorrection> bounds;
         std::shared_ptr<repelling::Repelling> repelling;
         std::shared_ptr<center::Placement> center_placement;
-
+        std::shared_ptr<integer::IntegerHandling> integer_handling;
+        
         Parameters(const size_t dim);
 
         Parameters(const Settings &settings);

include/settings.hpp

@@ -22,6 +22,7 @@ namespace parameters
 
 		Vector lb;
 		Vector ub;
+		Indices integer_variables;
 		Vector db;
 		Vector center;
 		Float diameter; 
@@ -49,6 +50,7 @@ namespace parameters
 			std::optional<Vector> x0 = std::nullopt,
 			std::optional<Vector> lb = std::nullopt,
 			std::optional<Vector> ub = std::nullopt,
+			std::optional<Indices> integer_variables = std::nullopt,
 			std::optional<Float> cs = std::nullopt,
 			std::optional<Float> cc = std::nullopt,
 			std::optional<Float> cmu = std::nullopt,
@@ -68,6 +70,7 @@ namespace parameters
 			x0(x0),
 			lb(lb.value_or(Vector::Ones(dim) * -5)),
 			ub(ub.value_or(Vector::Ones(dim) * 5)),
+			integer_variables(integer_variables.value_or(Indices{})),
 			db(this->ub - this->lb),
 			center(this->lb + (db * 0.5)),
 			diameter(db.norm()),			

src/integer.cpp

@@ -0,0 +1,24 @@
+#include "integer.hpp"
+#include "parameters.hpp"
+
+namespace integer
+{
+    void IntegerHandling::update_diagonal(const parameters::Parameters& p) 
+    {
+        if (p.settings.integer_variables.size() == 0)
+            return;
+        
+        effective_y = p.adaptation->compute_y(ones);
+    }
+
+    Array IntegerHandling::get_effective_sigma(const parameters::Parameters& p, const size_t idx) 
+    {
+        Array effective_sigma = Array::Constant(p.settings.dim, p.pop.s(idx));
+        for (const auto& iidx: p.settings.integer_variables)
+        {
+            
+        }
+
+        return effective_sigma;
+    }
+}

src/interface.cpp

@@ -11,7 +11,6 @@
 #include "c_maes.hpp"
 #include "to_string.hpp"
 #include "es.hpp"
-
 namespace py = pybind11;
 
 PYBIND11_MAKE_OPAQUE(restart::vCriteria);
@@ -604,7 +603,7 @@ void define_parameters(py::module &main)
 	py::class_<Settings, std::shared_ptr<Settings>>(m, "Settings")
 		.def(py::init<size_t, std::optional<Modules>, std::optional<Float>, size_to, size_to, std::optional<Float>,
 					  std::optional<size_t>, std::optional<size_t>, std::optional<Vector>,
-					  std::optional<Vector>, std::optional<Vector>,
+					  std::optional<Vector>, std::optional<Vector>, std::optional<Indices>,
 					  std::optional<Float>, std::optional<Float>, std::optional<Float>,
 					  std::optional<Float>, std::optional<Float>, std::optional<Float>,
 					  bool, bool>(),
@@ -619,6 +618,7 @@ void define_parameters(py::module &main)
 			 py::arg("x0") = std::nullopt,
 			 py::arg("lb") = std::nullopt,
 			 py::arg("ub") = std::nullopt,
+			 py::arg("integer_variables") = std::nullopt,
 			 py::arg("cs") = std::nullopt,
 			 py::arg("cc") = std::nullopt,
 			 py::arg("cmu") = std::nullopt,
@@ -668,6 +668,7 @@ void define_parameters(py::module &main)
 				ss << " x0: " << to_string(settings.x0);
 				ss << " lb: " << settings.lb.transpose();
 				ss << " ub: " << settings.ub.transpose();
+				ss << " integer_variables: " << settings.integer_variables.transpose();
 				ss << " cs: " << to_string(settings.cs);
 				ss << " cc: " << to_string(settings.cc);
 				ss << " cmu: " << to_string(settings.cmu);

src/mutation.cpp

@@ -37,8 +37,12 @@ namespace mutation
 					zi, p.settings.diameter, p.settings.budget, p.stats.evaluations);
 				p.pop.Z.col(i).noalias() = zi_scaled;
 				p.pop.Y.col(i).noalias() = p.adaptation->compute_y(p.pop.Z.col(i));
-				p.pop.X.col(i).noalias() = p.pop.Y.col(i) * p.pop.s(i) + p.adaptation->m;
+				
+				const auto effective_sigma = p.integer_handling->get_effective_sigma(p, i);
+				p.pop.X.col(i).array() = p.pop.Y.col(i).array() * effective_sigma + p.adaptation->m.array();
 				p.bounds->correct(i, p);
+
+				p.integer_handling->round_to_integer(p.pop.X.col(i), p.settings.integer_variables);
 			} while (
 				(p.settings.modules.bound_correction == parameters::CorrectionMethod::RESAMPLE &&
 				 n_rej++ < 5 * p.settings.dim && p.bounds->is_out_of_bounds(p.pop.X.col(i), p.settings).any()) ||

src/parameters.cpp

@@ -30,7 +30,8 @@ namespace parameters
 			settings.budget)),
 		bounds(bounds::get(settings.modules.bound_correction, settings.dim)),
 		repelling(repelling::get(settings.modules)),
-		center_placement(center::get(settings.modules.center_placement))
+		center_placement(center::get(settings.modules.center_placement)),
+		integer_handling(integer::get(settings.integer_variables, settings.dim, weights.mueff))
 	{
 		criteria.reset(*this);
 	}
@@ -80,8 +81,8 @@ namespace parameters
 			mutation->sigma = std::min(std::max(mutation->sigma, restart::MinSigma::tolerance), restart::MaxSigma::tolerance);
 
 		successfull_adaptation = adaptation->adapt_matrix(weights, settings.modules, pop, mu, settings, stats);
-
 		criteria.update(*this);
+		integer_handling->update_diagonal(*this);
 		stats.t++;
 	}
 

tests/test_c_integer.py

@@ -0,0 +1,21 @@
+import unittest
+from modcma import c_maes
+
+
+def sphere(x):
+    return sum(xi**2 for xi in x)
+
+
+class TestInteger(unittest.TestCase):
+    def test_int(self):
+        settings = c_maes.settings_from_dict(2, integer_variables=[0])
+        cma = c_maes.ModularCMAES(settings)
+        
+        for _ in range(3):
+            cma.mutate(sphere)
+            cma.select()
+            cma.recombine()
+            cma.adapt()
+            
+        # breakpoint()
+