Fix unused parameter warnings

SleipnirGroup · Jun 22, 2024 · 8d0444b · 8d0444b
1 parent 4aa8562
commit 8d0444b
Show file tree

Hide file tree

Showing 18 changed files with 211 additions and 118 deletions.
diff --git a/benchmarks/scalability/Util.hpp b/benchmarks/scalability/Util.hpp
@@ -40,7 +40,7 @@ constexpr double ToMilliseconds(
 template <typename Problem>
 void RunBenchmark(std::ofstream& results,
                   sleipnir::function_ref<Problem()> setup,
-                  sleipnir::function_ref<void(Problem&)> solve) {
+                  sleipnir::function_ref<void(Problem& problem)> solve) {
   // Record setup time
   auto setupStartTime = std::chrono::system_clock::now();
   auto problem = setup();
@@ -86,7 +86,8 @@ template <typename Problem>
 int RunBenchmarksAndLog(
     std::string_view filename, bool diagnostics,
     std::chrono::duration<double> T, std::span<int> sampleSizesToTest,
-    sleipnir::function_ref<Problem(std::chrono::duration<double>, int)> setup) {
+    sleipnir::function_ref<Problem(std::chrono::duration<double> dt, int N)>
+        setup) {
   std::ofstream results{std::string{filename}};
   if (!results.is_open()) {
     return 1;

diff --git a/cmake/modules/CompilerFlags.cmake b/cmake/modules/CompilerFlags.cmake
@@ -2,7 +2,7 @@ macro(compiler_flags target)
     if(NOT MSVC)
         target_compile_options(
             ${target}
-            PRIVATE -Wall -pedantic -Wextra -Werror -Wno-unused-parameter
+            PRIVATE -Wall -pedantic -Wextra -Werror
         )
     else()
         # Suppress the following warnings:

diff --git a/examples/FlywheelOCP/src/Main.cpp b/examples/FlywheelOCP/src/Main.cpp
@@ -25,8 +25,8 @@ int main() {
   Eigen::Matrix<double, 1, 1> A_discrete{std::exp(A(0) * dt.count())};
   Eigen::Matrix<double, 1, 1> B_discrete{(1.0 - A_discrete(0)) * B(0)};
 
-  auto f_discrete = [=](sleipnir::Variable t, sleipnir::VariableMatrix x,
-                        sleipnir::VariableMatrix u, sleipnir::Variable dt) {
+  auto f_discrete = [=](sleipnir::VariableMatrix x,
+                        sleipnir::VariableMatrix u) {
     return A_discrete * x + B_discrete * u;
   };
 

diff --git a/include/sleipnir/autodiff/Expression.hpp b/include/sleipnir/autodiff/Expression.hpp
@@ -225,15 +225,15 @@ struct SLEIPNIR_DLLEXPORT Expression {
 
     return MakeExpressionPtr(
         type, [](double lhs, double rhs) { return lhs * rhs; },
-        [](double lhs, double rhs, double parentAdjoint) {
+        [](double, double rhs, double parentAdjoint) {
           return parentAdjoint * rhs;
         },
-        [](double lhs, double rhs, double parentAdjoint) {
+        [](double lhs, double, double parentAdjoint) {
           return parentAdjoint * lhs;
         },
-        [](const ExpressionPtr& lhs, const ExpressionPtr& rhs,
+        [](const ExpressionPtr&, const ExpressionPtr& rhs,
            const ExpressionPtr& parentAdjoint) { return parentAdjoint * rhs; },
-        [](const ExpressionPtr& lhs, const ExpressionPtr& rhs,
+        [](const ExpressionPtr& lhs, const ExpressionPtr&,
            const ExpressionPtr& parentAdjoint) { return parentAdjoint * lhs; },
         lhs, rhs);
   }
@@ -271,13 +271,13 @@ struct SLEIPNIR_DLLEXPORT Expression {
 
     return MakeExpressionPtr(
         type, [](double lhs, double rhs) { return lhs / rhs; },
-        [](double lhs, double rhs, double parentAdjoint) {
+        [](double, double rhs, double parentAdjoint) {
           return parentAdjoint / rhs;
         },
         [](double lhs, double rhs, double parentAdjoint) {
           return parentAdjoint * -lhs / (rhs * rhs);
         },
-        [](const ExpressionPtr& lhs, const ExpressionPtr& rhs,
+        [](const ExpressionPtr&, const ExpressionPtr& rhs,
            const ExpressionPtr& parentAdjoint) { return parentAdjoint / rhs; },
         [](const ExpressionPtr& lhs, const ExpressionPtr& rhs,
            const ExpressionPtr& parentAdjoint) {
@@ -311,15 +311,11 @@ struct SLEIPNIR_DLLEXPORT Expression {
     return MakeExpressionPtr(
         std::max(lhs->type, rhs->type),
         [](double lhs, double rhs) { return lhs + rhs; },
-        [](double lhs, double rhs, double parentAdjoint) {
-          return parentAdjoint;
-        },
-        [](double lhs, double rhs, double parentAdjoint) {
-          return parentAdjoint;
-        },
-        [](const ExpressionPtr& lhs, const ExpressionPtr& rhs,
+        [](double, double, double parentAdjoint) { return parentAdjoint; },
+        [](double, double, double parentAdjoint) { return parentAdjoint; },
+        [](const ExpressionPtr&, const ExpressionPtr&,
            const ExpressionPtr& parentAdjoint) { return parentAdjoint; },
-        [](const ExpressionPtr& lhs, const ExpressionPtr& rhs,
+        [](const ExpressionPtr&, const ExpressionPtr&,
            const ExpressionPtr& parentAdjoint) { return parentAdjoint; },
         lhs, rhs);
   }
@@ -354,15 +350,11 @@ struct SLEIPNIR_DLLEXPORT Expression {
     return MakeExpressionPtr(
         std::max(lhs->type, rhs->type),
         [](double lhs, double rhs) { return lhs - rhs; },
-        [](double lhs, double rhs, double parentAdjoint) {
-          return parentAdjoint;
-        },
-        [](double lhs, double rhs, double parentAdjoint) {
-          return -parentAdjoint;
-        },
-        [](const ExpressionPtr& lhs, const ExpressionPtr& rhs,
+        [](double, double, double parentAdjoint) { return parentAdjoint; },
+        [](double, double, double parentAdjoint) { return -parentAdjoint; },
+        [](const ExpressionPtr&, const ExpressionPtr&,
            const ExpressionPtr& parentAdjoint) { return parentAdjoint; },
-        [](const ExpressionPtr& lhs, const ExpressionPtr& rhs,
+        [](const ExpressionPtr&, const ExpressionPtr&,
            const ExpressionPtr& parentAdjoint) { return -parentAdjoint; },
         lhs, rhs);
   }
@@ -388,8 +380,8 @@ struct SLEIPNIR_DLLEXPORT Expression {
 
     return MakeExpressionPtr(
         lhs->type, [](double lhs, double) { return -lhs; },
-        [](double lhs, double, double parentAdjoint) { return -parentAdjoint; },
-        [](const ExpressionPtr& lhs, const ExpressionPtr& rhs,
+        [](double, double, double parentAdjoint) { return -parentAdjoint; },
+        [](const ExpressionPtr&, const ExpressionPtr&,
            const ExpressionPtr& parentAdjoint) { return -parentAdjoint; },
         lhs);
   }
@@ -964,9 +956,8 @@ SLEIPNIR_DLLEXPORT inline ExpressionPtr sign(const ExpressionPtr& x) {
           return 1.0;
         }
       },
-      [](double x, double, double parentAdjoint) { return 0.0; },
-      [](const ExpressionPtr& x, const ExpressionPtr&,
-         const ExpressionPtr& parentAdjoint) {
+      [](double, double, double) { return 0.0; },
+      [](const ExpressionPtr&, const ExpressionPtr&, const ExpressionPtr&) {
         // Return zero
         return MakeExpressionPtr();
       },

diff --git a/include/sleipnir/autodiff/ExpressionGraph.hpp b/include/sleipnir/autodiff/ExpressionGraph.hpp
@@ -192,7 +192,7 @@ class SLEIPNIR_DLLEXPORT ExpressionGraph {
    * @param func A function that takes two arguments: an int for the gradient
    *   row, and a double for the adjoint (gradient value).
    */
-  void ComputeAdjoints(function_ref<void(int, double)> func) {
+  void ComputeAdjoints(function_ref<void(int row, double adjoint)> func) {
     // Zero adjoints. The root node's adjoint is 1.0 as df/df is always 1.
     m_adjointList[0]->adjoint = 1.0;
     for (auto it = m_adjointList.begin() + 1; it != m_adjointList.end(); ++it) {

diff --git a/include/sleipnir/control/OCPSolver.hpp b/include/sleipnir/control/OCPSolver.hpp
@@ -16,18 +16,6 @@
 
 namespace sleipnir {
 
-/**
- * Function representing an explicit or implicit ODE, or a discrete state
- * transition function.
- *
- * - Explicit: dx/dt = f(t, x, u, *)
- * - Implicit: f(t, [x dx/dt]', u, *) = 0
- * - State transition: xₖ₊₁ = f(t, xₖ, uₖ, dt)
- */
-using DynamicsFunction =
-    function_ref<VariableMatrix(const Variable&, const VariableMatrix&,
-                                const VariableMatrix&, const Variable&)>;
-
 /**
  * Performs 4th order Runge-Kutta integration of dx/dt = f(t, x, u) for dt.
  *
@@ -122,15 +110,61 @@ class SLEIPNIR_DLLEXPORT OCPSolver : public OptimizationProblem {
    * @param numInputs The number of system inputs.
    * @param dt The timestep for fixed-step integration.
    * @param numSteps The number of control points.
-   * @param dynamics The system evolution function, either an explicit ODE or a
-   * discrete state transition function.
+   * @param dynamics Function representing an explicit or implicit ODE, or a
+   *   discrete state transition function.
+   *   - Explicit: dx/dt = f(x, u, *)
+   *   - Implicit: f([x dx/dt]', u, *) = 0
+   *   - State transition: xₖ₊₁ = f(xₖ, uₖ)
    * @param dynamicsType The type of system evolution function.
    * @param timestepMethod The timestep method.
    * @param method The transcription method.
    */
   OCPSolver(
       int numStates, int numInputs, std::chrono::duration<double> dt,
-      int numSteps, DynamicsFunction dynamics,
+      int numSteps,
+      function_ref<VariableMatrix(const VariableMatrix& x,
+                                  const VariableMatrix& u)>
+          dynamics,
+      DynamicsType dynamicsType = DynamicsType::kExplicitODE,
+      TimestepMethod timestepMethod = TimestepMethod::kFixed,
+      TranscriptionMethod method = TranscriptionMethod::kDirectTranscription)
+      : OCPSolver{numStates,
+                  numInputs,
+                  dt,
+                  numSteps,
+                  [=]([[maybe_unused]] const VariableMatrix& t,
+                      const VariableMatrix& x, const VariableMatrix& u,
+                      [[maybe_unused]]
+                      const VariableMatrix& dt) -> VariableMatrix {
+                    return dynamics(x, u);
+                  },
+                  dynamicsType,
+                  timestepMethod,
+                  method} {}
+
+  /**
+   * Build an optimization problem using a system evolution function (explicit
+   * ODE or discrete state transition function).
+   *
+   * @param numStates The number of system states.
+   * @param numInputs The number of system inputs.
+   * @param dt The timestep for fixed-step integration.
+   * @param numSteps The number of control points.
+   * @param dynamics Function representing an explicit or implicit ODE, or a
+   *   discrete state transition function.
+   *   - Explicit: dx/dt = f(t, x, u, *)
+   *   - Implicit: f(t, [x dx/dt]', u, *) = 0
+   *   - State transition: xₖ₊₁ = f(t, xₖ, uₖ, dt)
+   * @param dynamicsType The type of system evolution function.
+   * @param timestepMethod The timestep method.
+   * @param method The transcription method.
+   */
+  OCPSolver(
+      int numStates, int numInputs, std::chrono::duration<double> dt,
+      int numSteps,
+      function_ref<VariableMatrix(const Variable& t, const VariableMatrix& x,
+                                  const VariableMatrix& u, const Variable& dt)>
+          dynamics,
       DynamicsType dynamicsType = DynamicsType::kExplicitODE,
       TimestepMethod timestepMethod = TimestepMethod::kFixed,
       TranscriptionMethod method = TranscriptionMethod::kDirectTranscription)
@@ -203,6 +237,24 @@ class SLEIPNIR_DLLEXPORT OCPSolver : public OptimizationProblem {
     SubjectTo(FinalState() == finalState);
   }
 
+  /**
+   * Set the constraint evaluation function. This function is called
+   * `numSteps+1` times, with the corresponding state and input
+   * VariableMatrices.
+   *
+   * @param callback The callback f(x, u) where x is the state and u is the
+   *     input vector.
+   */
+  void ForEachStep(
+      const function_ref<void(const VariableMatrix& x, const VariableMatrix& u)>
+          callback) {
+    for (int i = 0; i < m_numSteps + 1; ++i) {
+      auto x = X().Col(i);
+      auto u = U().Col(i);
+      callback(x, u);
+    }
+  }
+
   /**
    * Set the constraint evaluation function. This function is called
    * `numSteps+1` times, with the corresponding state and input
@@ -212,8 +264,8 @@ class SLEIPNIR_DLLEXPORT OCPSolver : public OptimizationProblem {
    *   vector, u is the input vector, and dt is the timestep duration.
    */
   void ForEachStep(
-      const function_ref<void(const Variable&, const VariableMatrix&,
-                              const VariableMatrix&, const Variable&)>
+      const function_ref<void(const Variable& t, const VariableMatrix& x,
+                              const VariableMatrix& u, const Variable& dt)>
           callback) {
     Variable time = 0.0;
 
@@ -365,9 +417,9 @@ class SLEIPNIR_DLLEXPORT OCPSolver : public OptimizationProblem {
       Variable dt = DT()(0, i);
 
       if (m_dynamicsType == DynamicsType::kExplicitODE) {
-        SubjectTo(x_end ==
-                  RK4<const DynamicsFunction&, VariableMatrix, VariableMatrix,
-                      Variable>(m_dynamicsFunction, x_begin, u, time, dt));
+        SubjectTo(x_end == RK4<const decltype(m_dynamicsFunction)&,
+                               VariableMatrix, VariableMatrix, Variable>(
+                               m_dynamicsFunction, x_begin, u, time, dt));
       } else if (m_dynamicsType == DynamicsType::kDiscrete) {
         SubjectTo(x_end == m_dynamicsFunction(time, x_begin, u, dt));
       }
@@ -386,8 +438,9 @@ class SLEIPNIR_DLLEXPORT OCPSolver : public OptimizationProblem {
       Variable dt = DT()(0, i);
 
       if (m_dynamicsType == DynamicsType::kExplicitODE) {
-        x_end = RK4<const DynamicsFunction&, VariableMatrix, VariableMatrix,
-                    Variable>(m_dynamicsFunction, x_begin, u, time, dt);
+        x_end = RK4<const decltype(m_dynamicsFunction)&, VariableMatrix,
+                    VariableMatrix, Variable>(m_dynamicsFunction, x_begin, u,
+                                              time, dt);
       } else if (m_dynamicsType == DynamicsType::kDiscrete) {
         x_end = m_dynamicsFunction(time, x_begin, u, dt);
       }
@@ -403,7 +456,10 @@ class SLEIPNIR_DLLEXPORT OCPSolver : public OptimizationProblem {
   TranscriptionMethod m_transcriptionMethod;
 
   DynamicsType m_dynamicsType;
-  DynamicsFunction m_dynamicsFunction;
+
+  function_ref<VariableMatrix(const Variable& t, const VariableMatrix& x,
+                              const VariableMatrix& u, const Variable& dt)>
+      m_dynamicsFunction;
 
   TimestepMethod m_timestepMethod;
 

diff --git a/include/sleipnir/optimization/Multistart.hpp b/include/sleipnir/optimization/Multistart.hpp
@@ -40,7 +40,8 @@ struct MultistartResult {
  */
 template <typename DecisionVariables>
 MultistartResult<DecisionVariables> Multistart(
-    function_ref<MultistartResult<DecisionVariables>(const DecisionVariables&)>
+    function_ref<MultistartResult<DecisionVariables>(
+        const DecisionVariables& initialGuess)>
         solve,
     std::span<const DecisionVariables> initialGuesses) {
   small_vector<std::future<MultistartResult<DecisionVariables>>> futures;

diff --git a/include/sleipnir/optimization/OptimizationProblem.hpp b/include/sleipnir/optimization/OptimizationProblem.hpp
@@ -372,7 +372,7 @@ class SLEIPNIR_DLLEXPORT OptimizationProblem {
   small_vector<Variable> m_inequalityConstraints;
 
   // The user callback
-  std::function<bool(const SolverIterationInfo&)> m_callback =
+  std::function<bool(const SolverIterationInfo& info)> m_callback =
       [](const SolverIterationInfo&) { return false; };
 
   // The solver status

diff --git a/include/sleipnir/optimization/solver/InteriorPoint.hpp b/include/sleipnir/optimization/solver/InteriorPoint.hpp
@@ -48,7 +48,7 @@ SLEIPNIR_DLLEXPORT void InteriorPoint(
     std::span<Variable> decisionVariables,
     std::span<Variable> equalityConstraints,
     std::span<Variable> inequalityConstraints, Variable& f,
-    function_ref<bool(const SolverIterationInfo&)> callback,
+    function_ref<bool(const SolverIterationInfo& info)> callback,
     const SolverConfig& config, bool feasibilityRestoration, Eigen::VectorXd& x,
     Eigen::VectorXd& s, SolverStatus* status);
 

diff --git a/include/sleipnir/util/Pool.hpp b/include/sleipnir/util/Pool.hpp
@@ -39,7 +39,8 @@ class SLEIPNIR_DLLEXPORT PoolResource {
    * @param alignment Alignment of the block (unused).
    */
   [[nodiscard]]
-  void* allocate(size_t bytes, size_t alignment = alignof(std::max_align_t)) {
+  void* allocate(size_t bytes, [[maybe_unused]] size_t alignment =
+                                   alignof(std::max_align_t)) {
     if (m_freeList.empty()) {
       AddChunk(bytes);
     }
@@ -56,8 +57,9 @@ class SLEIPNIR_DLLEXPORT PoolResource {
    * @param bytes Number of bytes in the block (unused).
    * @param alignment Alignment of the block (unused).
    */
-  void deallocate(void* p, size_t bytes,
-                  size_t alignment = alignof(std::max_align_t)) {
+  void deallocate(
+      void* p, [[maybe_unused]] size_t bytes,
+      [[maybe_unused]] size_t alignment = alignof(std::max_align_t)) {
     m_freeList.emplace_back(p);
   }