- Added bounds checking in most optimizers for initial population

- Added tests for most optimizers for bounds checking for initial population
esa · Mar 6, 2024 · 86e7bc1 · 86e7bc1
1 parent 1166e3e
commit 86e7bc1
Show file tree

Hide file tree

Showing 46 changed files with 1,231 additions and 15 deletions.
diff --git a/src/algorithms/bee_colony.cpp b/src/algorithms/bee_colony.cpp
@@ -94,6 +94,26 @@ population bee_colony::evolve(population pop) const
     if (m_gen == 0u) {
         return pop;
     }
+    // make sure all genes respect the bounds
+    for (decltype(NP) i = 0u; i < NP; ++i) {
+        for (decltype(dim) j = 0u; j < dim; ++j) {
+            double x = pop.get_x()[i][j];
+            if (std::isnan(x)) {
+            pagmo_throw(std::invalid_argument, "Individual " + std::to_string(i) + " has a gene " + std::to_string(j)
+                                                   + " equal to NaN" + std::to_string(x));
+            }
+
+            if (std::isinf(x)) {
+            pagmo_throw(std::invalid_argument, "Individual " + std::to_string(i) + " has a gene " + std::to_string(j)
+                                                   + " equal to infinity" + std::to_string(x));
+            }
+
+            if (x < bounds.first[j] || x > bounds.second[j]) {
+                pagmo_throw(std::invalid_argument, "Individual " + std::to_string(i) + " has a gene " + std::to_string(j)
+                                                       + " out of bounds: " + std::to_string(x));
+            }
+        }
+    }
     // ---------------------------------------------------------------------------------------------------------
 
     // No throws, all valid: we clear the logs

diff --git a/src/algorithms/cmaes.cpp b/src/algorithms/cmaes.cpp
@@ -149,6 +149,30 @@ population cmaes::evolve(population pop) const
                                                    + this->get_name() + " cannot deal with it.");
         }
     }
+    // Verify all decision variables respect the bounds if force_bounds is true
+    if (m_force_bounds)
+    {
+        for (decltype(lam) i = 0u; i < lam; ++i) {
+            for (decltype(dim) j = 0u; j < dim; ++j) {
+                double x = pop.get_x()[i][j];
+                if (std::isnan(x)) {
+                pagmo_throw(std::invalid_argument, "Individual " + std::to_string(i) + " has a gene " + std::to_string(j)
+                                                    + " equal to NaN" + std::to_string(x));
+                }
+
+                if (std::isinf(x)) {
+                pagmo_throw(std::invalid_argument, "Individual " + std::to_string(i) + " has a gene " + std::to_string(j)
+                                                    + " equal to infinity" + std::to_string(x));
+                }
+
+                if (x < bounds.first[j] || x > bounds.second[j]) {
+                    pagmo_throw(std::invalid_argument, "Individual " + std::to_string(i) + " has a gene " + std::to_string(j)
+                                                        + " out of bounds: " + std::to_string(x));
+                }
+            }
+        }
+    }
+
     // Get out if there is nothing to do.
     if (m_gen == 0u) {
         return pop;

diff --git a/src/algorithms/compass_search.cpp b/src/algorithms/compass_search.cpp
@@ -78,6 +78,7 @@ population compass_search::evolve(population pop) const
     // We store some useful variables
     const auto &prob = pop.get_problem(); // This is a const reference, so using set_seed for example will not be
                                           // allowed
+    auto NP = pop.size();
     auto dim = prob.get_nx();             // This getter does not return a const reference but a copy
     const auto bounds = prob.get_bounds();
     const auto &lb = bounds.first;
@@ -105,6 +106,26 @@ population compass_search::evolve(population pop) const
     if (m_max_fevals == 0u) {
         return pop;
     }
+    // Verify all decision variables respect the bounds
+    for (decltype(NP) i = 0u; i < NP; ++i) {
+        for (decltype(dim) j = 0u; j < dim; ++j) {
+            double x = pop.get_x()[i][j];
+            if (std::isnan(x)) {
+            pagmo_throw(std::invalid_argument, "Individual " + std::to_string(i) + " has a gene " + std::to_string(j)
+                                                   + " equal to NaN" + std::to_string(x));
+            }
+
+            if (std::isinf(x)) {
+            pagmo_throw(std::invalid_argument, "Individual " + std::to_string(i) + " has a gene " + std::to_string(j)
+                                                   + " equal to infinity" + std::to_string(x));
+            }
+
+            if (x < bounds.first[j] || x > bounds.second[j]) {
+                pagmo_throw(std::invalid_argument, "Individual " + std::to_string(i) + " has a gene " + std::to_string(j)
+                                                       + " out of bounds: " + std::to_string(x));
+            }
+        }
+    }
     // ---------------------------------------------------------------------------------------------------------
 
     // No throws, all valid: we clear the logs

diff --git a/src/algorithms/cstrs_self_adaptive.cpp b/src/algorithms/cstrs_self_adaptive.cpp
@@ -408,6 +408,7 @@ population cstrs_self_adaptive::evolve(population pop) const
     auto nec = prob.get_nec();            // This getter does not return a const reference but a copy
     const auto bounds = prob.get_bounds();
     auto NP = pop.size();
+    auto dim = prob.get_nx();
 
     auto fevals0 = prob.get_fevals(); // discount for the already made fevals
     unsigned count = 1u;              // regulates the screen output
@@ -429,6 +430,26 @@ population cstrs_self_adaptive::evolve(population pop) const
         pagmo_throw(std::invalid_argument,
                     "Cannot use " + prob.get_name() + " on a population with less than 4 individuals");
     }
+    // Verify all decision variables respect the bounds
+    for (decltype(NP) i = 0u; i < NP; ++i) {
+        for (decltype(dim) j = 0u; j < dim; ++j) {
+            double x = pop.get_x()[i][j];
+            if (std::isnan(x)) {
+            pagmo_throw(std::invalid_argument, "Individual " + std::to_string(i) + " has a gene " + std::to_string(j)
+                                                   + " equal to NaN" + std::to_string(x));
+            }
+
+            if (std::isinf(x)) {
+            pagmo_throw(std::invalid_argument, "Individual " + std::to_string(i) + " has a gene " + std::to_string(j)
+                                                   + " equal to infinity" + std::to_string(x));
+            }
+
+            if (x < bounds.first[j] || x > bounds.second[j]) {
+                pagmo_throw(std::invalid_argument, "Individual " + std::to_string(i) + " has a gene " + std::to_string(j)
+                                                       + " out of bounds: " + std::to_string(x));
+            }
+        }
+    }
     // ---------------------------------------------------------------------------------------------------------
 
     // No throws, all valid: we clear the logs

diff --git a/src/algorithms/de.cpp b/src/algorithms/de.cpp
@@ -110,6 +110,26 @@ population de::evolve(population pop) const
         pagmo_throw(std::invalid_argument, get_name() + " needs at least 5 individuals in the population, "
                                                + std::to_string(pop.size()) + " detected");
     }
+    // Verify all decision variables respect the bounds
+    for (decltype(NP) i = 0u; i < NP; ++i) {
+        for (decltype(dim) j = 0u; j < dim; ++j) {
+            double x = pop.get_x()[i][j];
+            if (std::isnan(x)) {
+            pagmo_throw(std::invalid_argument, "Individual " + std::to_string(i) + " has a gene " + std::to_string(j)
+                                                   + " equal to NaN" + std::to_string(x));
+            }
+
+            if (std::isinf(x)) {
+            pagmo_throw(std::invalid_argument, "Individual " + std::to_string(i) + " has a gene " + std::to_string(j)
+                                                   + " equal to infinity" + std::to_string(x));
+            }
+
+            if (x < bounds.first[j] || x > bounds.second[j]) {
+                pagmo_throw(std::invalid_argument, "Individual " + std::to_string(i) + " has a gene " + std::to_string(j)
+                                                       + " out of bounds: " + std::to_string(x));
+            }
+        }
+    }
     // ---------------------------------------------------------------------------------------------------------
 
     // No throws, all valid: we clear the logs

diff --git a/src/algorithms/de1220.cpp b/src/algorithms/de1220.cpp
@@ -114,6 +114,26 @@ population de1220::evolve(population pop) const
         pagmo_throw(std::invalid_argument, get_name() + " needs at least 7 individuals in the population, "
                                                + std::to_string(pop.size()) + " detected");
     }
+    // Verify all decision variables respect the bounds
+    for (decltype(NP) i = 0u; i < NP; ++i) {
+        for (decltype(dim) j = 0u; j < dim; ++j) {
+            double x = pop.get_x()[i][j];
+            if (std::isnan(x)) {
+            pagmo_throw(std::invalid_argument, "Individual " + std::to_string(i) + " has a gene " + std::to_string(j)
+                                                   + " equal to NaN" + std::to_string(x));
+            }
+
+            if (std::isinf(x)) {
+            pagmo_throw(std::invalid_argument, "Individual " + std::to_string(i) + " has a gene " + std::to_string(j)
+                                                   + " equal to infinity" + std::to_string(x));
+            }
+
+            if (x < bounds.first[j] || x > bounds.second[j]) {
+                pagmo_throw(std::invalid_argument, "Individual " + std::to_string(i) + " has a gene " + std::to_string(j)
+                                                       + " out of bounds: " + std::to_string(x));
+            }
+        }
+    }
     // ---------------------------------------------------------------------------------------------------------
 
     // No throws, all valid: we clear the logs

diff --git a/src/algorithms/gaco.cpp b/src/algorithms/gaco.cpp
@@ -114,6 +114,7 @@ population gaco::evolve(population pop) const
     auto n_x = prob.get_nx(); // This getter does not return a const reference but a copy of the number of
     // all the variables
     auto pop_size = pop.size(); // Population size
+    auto bounds = prob.get_bounds(); // Bounds of the problem
     unsigned count_screen = 1u; // regulates the screen output
 
     // Note that the number of equality and inequality constraints has to be set up manually in the problem
@@ -167,6 +168,26 @@ population gaco::evolve(population pop) const
         pagmo_throw(std::invalid_argument, "Multiple objectives detected in " + prob.get_name() + " instance. "
                                                + get_name() + " cannot deal with them");
     }
+    // Verify all decision variables respect the bounds
+    for (decltype(pop_size) i = 0u; i < pop_size; ++i) {
+        for (decltype(n_x) j = 0u; j < n_x; ++j) {
+            double x = pop.get_x()[i][j];
+            if (std::isnan(x)) {
+            pagmo_throw(std::invalid_argument, "Individual " + std::to_string(i) + " has a gene " + std::to_string(j)
+                                                   + " equal to NaN" + std::to_string(x));
+            }
+
+            if (std::isinf(x)) {
+            pagmo_throw(std::invalid_argument, "Individual " + std::to_string(i) + " has a gene " + std::to_string(j)
+                                                   + " equal to infinity" + std::to_string(x));
+            }
+
+            if (x < bounds.first[j] || x > bounds.second[j]) {
+                pagmo_throw(std::invalid_argument, "Individual " + std::to_string(i) + " has a gene " + std::to_string(j)
+                                                       + " out of bounds: " + std::to_string(x));
+            }
+        }
+    }
 
     // ---------------------------------------------------------------------------------------------------------
 

diff --git a/src/algorithms/gwo.cpp b/src/algorithms/gwo.cpp
@@ -94,6 +94,26 @@ population gwo::evolve(population pop) const
         pagmo_throw(std::invalid_argument, get_name() + " needs at least 3 individuals in the population, "
                                                + std::to_string(pop.size()) + " detected");
     }
+    // Verify all decision variables respect the bounds
+    for (decltype(NP) i = 0u; i < NP; ++i) {
+        for (decltype(dim) j = 0u; j < dim; ++j) {
+            double x = pop.get_x()[i][j];
+            if (std::isnan(x)) {
+            pagmo_throw(std::invalid_argument, "Individual " + std::to_string(i) + " has a gene " + std::to_string(j)
+                                                   + " equal to NaN" + std::to_string(x));
+            }
+
+            if (std::isinf(x)) {
+            pagmo_throw(std::invalid_argument, "Individual " + std::to_string(i) + " has a gene " + std::to_string(j)
+                                                   + " equal to infinity" + std::to_string(x));
+            }
+
+            if (x < bounds.first[j] || x > bounds.second[j]) {
+                pagmo_throw(std::invalid_argument, "Individual " + std::to_string(i) + " has a gene " + std::to_string(j)
+                                                       + " out of bounds: " + std::to_string(x));
+            }
+        }
+    }
     // ---------------------------------------------------------------------------------------------------------
 
     // No throws, all valid: we clear the logs

diff --git a/src/algorithms/ihs.cpp b/src/algorithms/ihs.cpp
@@ -77,6 +77,7 @@ population ihs::evolve(population pop) const
     // We store some useful properties
     const auto &prob = pop.get_problem(); // This is a const reference, so using set_seed for example will not be
                                           // allowed
+    auto NP = pop.size();
     auto dim = prob.get_nx();
     auto int_dim = prob.get_nix();
     const auto bounds = prob.get_bounds();
@@ -90,7 +91,7 @@ population ihs::evolve(population pop) const
     if (m_gen == 0u) {
         return pop;
     }
-    if (!pop.size()) {
+    if (!NP) {
         pagmo_throw(std::invalid_argument, get_name() + " does not work on an empty population");
     }
     if (prob.get_nc() != 0u && prob.get_nobj() > 1u) {
@@ -102,6 +103,26 @@ population ihs::evolve(population pop) const
         pagmo_throw(std::invalid_argument,
                     "The problem appears to be stochastic " + get_name() + " cannot deal with it");
     }
+    // Verify all decision variables respect the bounds
+    for (decltype(NP) i = 0u; i < NP; ++i) {
+        for (decltype(dim) j = 0u; j < dim; ++j) {
+            double x = pop.get_x()[i][j];
+            if (std::isnan(x)) {
+            pagmo_throw(std::invalid_argument, "Individual " + std::to_string(i) + " has a gene " + std::to_string(j)
+                                                   + " equal to NaN" + std::to_string(x));
+            }
+
+            if (std::isinf(x)) {
+            pagmo_throw(std::invalid_argument, "Individual " + std::to_string(i) + " has a gene " + std::to_string(j)
+                                                   + " equal to infinity" + std::to_string(x));
+            }
+
+            if (x < bounds.first[j] || x > bounds.second[j]) {
+                pagmo_throw(std::invalid_argument, "Individual " + std::to_string(i) + " has a gene " + std::to_string(j)
+                                                       + " out of bounds: " + std::to_string(x));
+            }
+        }
+    }
     // ---------------------------------------------------------------------------------------------------------
 
     // No throws, all valid: we clear the logs
@@ -112,15 +133,15 @@ population ihs::evolve(population pop) const
         lu_diff[i] = ub[i] - lb[i];
     }
     // Distributions used
-    std::uniform_int_distribution<decltype(pop.size())> uni_int(0, pop.size() - 1u); // to pick an individual
+    std::uniform_int_distribution<decltype(NP)> uni_int(0, NP - 1u); // to pick an individual
     std::uniform_real_distribution<double> drng(0., 1.);                             // to generate a number in [0, 1)
 
     // Used for parameter control
     const double c = std::log(m_bw_min / m_bw_max) / m_gen;
 
     // Declarations
     vector_double new_x(dim, 0.);
-    std::vector<vector_double::size_type> best_idxs(pop.size());
+    std::vector<vector_double::size_type> best_idxs(NP);
 
     // Main loop
     for (decltype(m_gen) gen = 1u; gen <= m_gen; ++gen) {
@@ -185,10 +206,10 @@ population ihs::evolve(population pop) const
             // we augment the list with the new fitness
             fitnesses.push_back(new_f);
             // select the best pop.size() individuals
-            best_idxs = select_best_N_mo(fitnesses, pop.size());
+            best_idxs = select_best_N_mo(fitnesses, NP);
             // define the new population
-            for (population::size_type i = 0u; i < pop.size(); ++i) {
-                if (best_idxs[i] == pop.size()) { // this is the new guy
+            for (population::size_type i = 0u; i < NP; ++i) {
+                if (best_idxs[i] == NP) { // this is the new guy
                     pop.set_xf(i, new_x, new_f);
                 } else { // these were already in the pop somewhere
                     pop.set_xf(i, pop.get_x()[best_idxs[i]], pop.get_f()[best_idxs[i]]);

diff --git a/src/algorithms/maco.cpp b/src/algorithms/maco.cpp
@@ -100,6 +100,7 @@ population maco::evolve(population pop) const
     const auto &prob = pop.get_problem();
     auto n_x = prob.get_nx();
     auto pop_size = pop.size();
+    auto bounds = prob.get_bounds();
     unsigned count_screen = 1u;       // regulates the screen output
     auto fevals0 = prob.get_fevals(); // discount for the already made fevals
     auto n_f = prob.get_nf();         // n_f=prob.get_nobj()+prob.get_nec()+prob.get_nic()
@@ -148,6 +149,26 @@ population maco::evolve(population pop) const
         pagmo_throw(std::invalid_argument, "This is a multiobjective algorithm, while number of objectives detected in "
                                                + prob.get_name() + " is " + std::to_string(prob.get_nf()));
     }
+    // Verify all decision variables respect the bounds
+    for (decltype(pop_size) i = 0u; i < pop_size; ++i) {
+        for (decltype(n_x) j = 0u; j < n_x; ++j) {
+            double x = pop.get_x()[i][j];
+            if (std::isnan(x)) {
+            pagmo_throw(std::invalid_argument, "Individual " + std::to_string(i) + " has a gene " + std::to_string(j)
+                                                   + " equal to NaN" + std::to_string(x));
+            }
+
+            if (std::isinf(x)) {
+            pagmo_throw(std::invalid_argument, "Individual " + std::to_string(i) + " has a gene " + std::to_string(j)
+                                                   + " equal to infinity" + std::to_string(x));
+            }
+
+            if (x < bounds.first[j] || x > bounds.second[j]) {
+                pagmo_throw(std::invalid_argument, "Individual " + std::to_string(i) + " has a gene " + std::to_string(j)
+                                                       + " out of bounds: " + std::to_string(x));
+            }
+        }
+    }
     // ---------------------------------------------------------------------------------------------------------
 
     // No throws, all valid: we clear the logs

diff --git a/src/algorithms/mbh.cpp b/src/algorithms/mbh.cpp
@@ -141,6 +141,26 @@ population mbh::evolve(population pop) const
                                                + ", while the problem dimension is: " + std::to_string(dim)
                                                + ". They need to be equal for MBH to work.");
     }
+    // Verify all decision variables respect the bounds
+    for (decltype(NP) i = 0u; i < NP; ++i) {
+        for (decltype(dim) j = 0u; j < dim; ++j) {
+            double x = pop.get_x()[i][j];
+            if (std::isnan(x)) {
+            pagmo_throw(std::invalid_argument, "Individual " + std::to_string(i) + " has a gene " + std::to_string(j)
+                                                   + " equal to NaN" + std::to_string(x));
+            }
+
+            if (std::isinf(x)) {
+            pagmo_throw(std::invalid_argument, "Individual " + std::to_string(i) + " has a gene " + std::to_string(j)
+                                                   + " equal to infinity" + std::to_string(x));
+            }
+
+            if (x < bounds.first[j] || x > bounds.second[j]) {
+                pagmo_throw(std::invalid_argument, "Individual " + std::to_string(i) + " has a gene " + std::to_string(j)
+                                                       + " out of bounds: " + std::to_string(x));
+            }
+        }
+    }
     // ---------------------------------------------------------------------------------------------------------
 
     // No throws, all valid: we clear the logs