Use range algorithms (SleipnirGroup#711)

calcmogul · Jan 23, 2025 · 4089073 · 4089073
1 parent 982c3b7
commit 4089073
Show file tree

Hide file tree

Showing 9 changed files with 91 additions and 69 deletions.
diff --git a/benchmarks/CmdlineArguments.hpp b/benchmarks/CmdlineArguments.hpp
@@ -28,7 +28,7 @@ class CmdlineArgs {
    * commandline arguments.
    */
   bool Contains(std::string_view arg) const {
-    return std::find(args.begin(), args.end(), arg) != args.end();
+    return std::ranges::find(args, arg) != args.end();
   }
 
  private:

diff --git a/include/sleipnir/autodiff/Variable.hpp b/include/sleipnir/autodiff/Variable.hpp
@@ -612,9 +612,9 @@ struct SLEIPNIR_DLLEXPORT EqualityConstraints {
    * Implicit conversion operator to bool.
    */
   operator bool() {  // NOLINT
-    return std::all_of(
-        constraints.begin(), constraints.end(),
-        [](auto& constraint) { return constraint.Value() == 0.0; });
+    return std::ranges::all_of(constraints, [](auto& constraint) {
+      return constraint.Value() == 0.0;
+    });
   }
 };
 
@@ -676,9 +676,9 @@ struct SLEIPNIR_DLLEXPORT InequalityConstraints {
    * Implicit conversion operator to bool.
    */
   operator bool() {  // NOLINT
-    return std::all_of(
-        constraints.begin(), constraints.end(),
-        [](auto& constraint) { return constraint.Value() >= 0.0; });
+    return std::ranges::all_of(constraints, [](auto& constraint) {
+      return constraint.Value() >= 0.0;
+    });
   }
 };
 

diff --git a/include/sleipnir/autodiff/VariableBlock.hpp b/include/sleipnir/autodiff/VariableBlock.hpp
@@ -659,23 +659,29 @@ class VariableBlock {
     using pointer = Variable*;
     using reference = Variable&;
 
-    iterator(VariableBlock<Mat>* mat, int index) : m_mat{mat}, m_index{index} {}
+    constexpr iterator() noexcept = default;
 
-    iterator& operator++() {
+    constexpr iterator(VariableBlock<Mat>* mat, int index) noexcept
+        : m_mat{mat}, m_index{index} {}
+
+    constexpr iterator& operator++() noexcept {
       ++m_index;
       return *this;
     }
-    iterator operator++(int) {
+
+    constexpr iterator operator++(int) noexcept {
       iterator retval = *this;
       ++(*this);
       return retval;
     }
-    bool operator==(const iterator&) const = default;
-    reference operator*() { return (*m_mat)(m_index); }
+
+    constexpr bool operator==(const iterator&) const noexcept = default;
+
+    constexpr reference operator*() const noexcept { return (*m_mat)(m_index); }
 
    private:
-    VariableBlock<Mat>* m_mat;
-    int m_index;
+    VariableBlock<Mat>* m_mat = nullptr;
+    int m_index = 0;
   };
 
   class const_iterator {
@@ -686,24 +692,31 @@ class VariableBlock {
     using pointer = Variable*;
     using const_reference = const Variable&;
 
-    const_iterator(const VariableBlock<Mat>* mat, int index)
+    constexpr const_iterator() noexcept = default;
+
+    constexpr const_iterator(const VariableBlock<Mat>* mat, int index) noexcept
         : m_mat{mat}, m_index{index} {}
 
-    const_iterator& operator++() {
+    constexpr const_iterator& operator++() noexcept {
       ++m_index;
       return *this;
     }
-    const_iterator operator++(int) {
+
+    constexpr const_iterator operator++(int) noexcept {
       const_iterator retval = *this;
       ++(*this);
       return retval;
     }
-    bool operator==(const const_iterator&) const = default;
-    const_reference operator*() const { return (*m_mat)(m_index); }
+
+    constexpr bool operator==(const const_iterator&) const noexcept = default;
+
+    constexpr const_reference operator*() const noexcept {
+      return (*m_mat)(m_index);
+    }
 
    private:
-    const VariableBlock<Mat>* m_mat;
-    int m_index;
+    const VariableBlock<Mat>* m_mat = nullptr;
+    int m_index = 0;
   };
 
   /**

diff --git a/include/sleipnir/autodiff/VariableMatrix.hpp b/include/sleipnir/autodiff/VariableMatrix.hpp
@@ -95,7 +95,7 @@ class SLEIPNIR_DLLEXPORT VariableMatrix {
 
     m_storage.reserve(Rows() * Cols());
     for (const auto& row : list) {
-      std::copy(row.begin(), row.end(), std::back_inserter(m_storage));
+      std::ranges::copy(row, std::back_inserter(m_storage));
     }
   }
 
@@ -122,7 +122,7 @@ class SLEIPNIR_DLLEXPORT VariableMatrix {
 
     m_storage.reserve(Rows() * Cols());
     for (const auto& row : list) {
-      std::copy(row.begin(), row.end(), std::back_inserter(m_storage));
+      std::ranges::copy(row, std::back_inserter(m_storage));
     }
   }
 
@@ -149,7 +149,7 @@ class SLEIPNIR_DLLEXPORT VariableMatrix {
 
     m_storage.reserve(Rows() * Cols());
     for (const auto& row : list) {
-      std::copy(row.begin(), row.end(), std::back_inserter(m_storage));
+      std::ranges::copy(row, std::back_inserter(m_storage));
     }
   }
 
@@ -840,19 +840,25 @@ class SLEIPNIR_DLLEXPORT VariableMatrix {
     using pointer = Variable*;
     using reference = Variable&;
 
-    explicit iterator(small_vector<Variable>::iterator it) : m_it{it} {}
+    constexpr iterator() noexcept = default;
 
-    iterator& operator++() {
+    explicit constexpr iterator(small_vector<Variable>::iterator it) noexcept
+        : m_it{it} {}
+
+    constexpr iterator& operator++() noexcept {
       ++m_it;
       return *this;
     }
-    iterator operator++(int) {
+
+    constexpr iterator operator++(int) noexcept {
       iterator retval = *this;
       ++(*this);
       return retval;
     }
-    bool operator==(const iterator&) const = default;
-    reference operator*() { return *m_it; }
+
+    constexpr bool operator==(const iterator&) const noexcept = default;
+
+    constexpr reference operator*() const noexcept { return *m_it; }
 
    private:
     small_vector<Variable>::iterator m_it;
@@ -866,20 +872,26 @@ class SLEIPNIR_DLLEXPORT VariableMatrix {
     using pointer = Variable*;
     using const_reference = const Variable&;
 
-    explicit const_iterator(small_vector<Variable>::const_iterator it)
+    constexpr const_iterator() noexcept = default;
+
+    explicit constexpr const_iterator(
+        small_vector<Variable>::const_iterator it) noexcept
         : m_it{it} {}
 
-    const_iterator& operator++() {
+    constexpr const_iterator& operator++() noexcept {
       ++m_it;
       return *this;
     }
-    const_iterator operator++(int) {
+
+    constexpr const_iterator operator++(int) noexcept {
       const_iterator retval = *this;
       ++(*this);
       return retval;
     }
-    bool operator==(const const_iterator&) const = default;
-    const_reference operator*() const { return *m_it; }
+
+    constexpr bool operator==(const const_iterator&) const noexcept = default;
+
+    constexpr const_reference operator*() const noexcept { return *m_it; }
 
    private:
     small_vector<Variable>::const_iterator m_it;

diff --git a/include/sleipnir/optimization/Multistart.hpp b/include/sleipnir/optimization/Multistart.hpp
@@ -58,17 +58,16 @@ MultistartResult<DecisionVariables> Multistart(
     results.emplace_back(future.get());
   }
 
-  return *std::min_element(
-      results.cbegin(), results.cend(), [](const auto& a, const auto& b) {
-        // Prioritize successful solve
-        if (a.status.exitCondition == SolverExitCondition::kSuccess &&
-            b.status.exitCondition != SolverExitCondition::kSuccess) {
-          return true;
-        }
+  return *std::ranges::min_element(results, [](const auto& a, const auto& b) {
+    // Prioritize successful solve
+    if (a.status.exitCondition == SolverExitCondition::kSuccess &&
+        b.status.exitCondition != SolverExitCondition::kSuccess) {
+      return true;
+    }
 
-        // Otherwise prioritize solution with lower cost
-        return a.status.cost < b.status.cost;
-      });
+    // Otherwise prioritize solution with lower cost
+    return a.status.cost < b.status.cost;
+  });
 }
 
 }  // namespace sleipnir
diff --git a/include/sleipnir/optimization/OptimizationProblem.hpp b/include/sleipnir/optimization/OptimizationProblem.hpp
@@ -196,8 +196,8 @@ class SLEIPNIR_DLLEXPORT OptimizationProblem {
 
     m_equalityConstraints.reserve(m_equalityConstraints.size() +
                                   constraint.constraints.size());
-    std::copy(constraint.constraints.begin(), constraint.constraints.end(),
-              std::back_inserter(m_equalityConstraints));
+    std::ranges::copy(constraint.constraints,
+                      std::back_inserter(m_equalityConstraints));
   }
 
   /**
@@ -215,8 +215,8 @@ class SLEIPNIR_DLLEXPORT OptimizationProblem {
 
     m_equalityConstraints.reserve(m_equalityConstraints.size() +
                                   constraint.constraints.size());
-    std::copy(constraint.constraints.begin(), constraint.constraints.end(),
-              std::back_inserter(m_equalityConstraints));
+    std::ranges::copy(constraint.constraints,
+                      std::back_inserter(m_equalityConstraints));
   }
 
   /**
@@ -234,8 +234,8 @@ class SLEIPNIR_DLLEXPORT OptimizationProblem {
 
     m_inequalityConstraints.reserve(m_inequalityConstraints.size() +
                                     constraint.constraints.size());
-    std::copy(constraint.constraints.begin(), constraint.constraints.end(),
-              std::back_inserter(m_inequalityConstraints));
+    std::ranges::copy(constraint.constraints,
+                      std::back_inserter(m_inequalityConstraints));
   }
 
   /**
@@ -253,8 +253,8 @@ class SLEIPNIR_DLLEXPORT OptimizationProblem {
 
     m_inequalityConstraints.reserve(m_inequalityConstraints.size() +
                                     constraint.constraints.size());
-    std::copy(constraint.constraints.begin(), constraint.constraints.end(),
-              std::back_inserter(m_inequalityConstraints));
+    std::ranges::copy(constraint.constraints,
+                      std::back_inserter(m_inequalityConstraints));
   }
 
   /**

diff --git a/jormungandr/cpp/Docstrings.hpp b/jormungandr/cpp/Docstrings.hpp
@@ -1212,6 +1212,8 @@ static const char *__doc_sleipnir_VariableBlock_const_iterator = R"doc()doc";
 
 static const char *__doc_sleipnir_VariableBlock_const_iterator_const_iterator = R"doc()doc";
 
+static const char *__doc_sleipnir_VariableBlock_const_iterator_const_iterator_2 = R"doc()doc";
+
 static const char *__doc_sleipnir_VariableBlock_const_iterator_m_index = R"doc()doc";
 
 static const char *__doc_sleipnir_VariableBlock_const_iterator_m_mat = R"doc()doc";
@@ -1232,6 +1234,8 @@ static const char *__doc_sleipnir_VariableBlock_iterator = R"doc()doc";
 
 static const char *__doc_sleipnir_VariableBlock_iterator_iterator = R"doc()doc";
 
+static const char *__doc_sleipnir_VariableBlock_iterator_iterator_2 = R"doc()doc";
+
 static const char *__doc_sleipnir_VariableBlock_iterator_m_index = R"doc()doc";
 
 static const char *__doc_sleipnir_VariableBlock_iterator_m_mat = R"doc()doc";
@@ -1656,6 +1660,8 @@ static const char *__doc_sleipnir_VariableMatrix_const_iterator = R"doc()doc";
 
 static const char *__doc_sleipnir_VariableMatrix_const_iterator_const_iterator = R"doc()doc";
 
+static const char *__doc_sleipnir_VariableMatrix_const_iterator_const_iterator_2 = R"doc()doc";
+
 static const char *__doc_sleipnir_VariableMatrix_const_iterator_m_it = R"doc()doc";
 
 static const char *__doc_sleipnir_VariableMatrix_const_iterator_operator_eq = R"doc()doc";
@@ -1676,6 +1682,8 @@ static const char *__doc_sleipnir_VariableMatrix_iterator = R"doc()doc";
 
 static const char *__doc_sleipnir_VariableMatrix_iterator_iterator = R"doc()doc";
 
+static const char *__doc_sleipnir_VariableMatrix_iterator_iterator_2 = R"doc()doc";
+
 static const char *__doc_sleipnir_VariableMatrix_iterator_m_it = R"doc()doc";
 
 static const char *__doc_sleipnir_VariableMatrix_iterator_operator_eq = R"doc()doc";

diff --git a/src/optimization/solver/util/FeasibilityRestoration.hpp b/src/optimization/solver/util/FeasibilityRestoration.hpp
@@ -140,12 +140,9 @@ inline void FeasibilityRestoration(
   small_vector<Variable> fr_inequalityConstraints;
 
   // pₑ ≥ 0
-  std::copy(p_e.begin(), p_e.end(),
-            std::back_inserter(fr_inequalityConstraints));
-
   // nₑ ≥ 0
-  std::copy(n_e.begin(), n_e.end(),
-            std::back_inserter(fr_inequalityConstraints));
+  std::ranges::copy(p_e, std::back_inserter(fr_inequalityConstraints));
+  std::ranges::copy(n_e, std::back_inserter(fr_inequalityConstraints));
 
   Variable J = 0.0;
 
@@ -339,20 +336,13 @@ inline void FeasibilityRestoration(
   }
 
   // pₑ ≥ 0
-  std::copy(p_e.begin(), p_e.end(),
-            std::back_inserter(fr_inequalityConstraints));
-
   // pᵢ ≥ 0
-  std::copy(p_i.begin(), p_i.end(),
-            std::back_inserter(fr_inequalityConstraints));
-
   // nₑ ≥ 0
-  std::copy(n_e.begin(), n_e.end(),
-            std::back_inserter(fr_inequalityConstraints));
-
   // nᵢ ≥ 0
-  std::copy(n_i.begin(), n_i.end(),
-            std::back_inserter(fr_inequalityConstraints));
+  std::ranges::copy(p_e, std::back_inserter(fr_inequalityConstraints));
+  std::ranges::copy(p_i, std::back_inserter(fr_inequalityConstraints));
+  std::ranges::copy(n_e, std::back_inserter(fr_inequalityConstraints));
+  std::ranges::copy(n_i, std::back_inserter(fr_inequalityConstraints));
 
   Variable J = 0.0;
 

diff --git a/src/optimization/solver/util/Filter.hpp b/src/optimization/solver/util/Filter.hpp
@@ -173,7 +173,7 @@ class Filter {
 
     // If current filter entry is better than all prior ones in some respect,
     // accept it
-    return std::all_of(m_filter.begin(), m_filter.end(), [&](const auto& elem) {
+    return std::ranges::all_of(m_filter, [&](const auto& elem) {
       return entry.cost <= elem.cost - γCost * elem.constraintViolation ||
              entry.constraintViolation <=
                  (1.0 - γConstraint) * elem.constraintViolation;