Refactor constraints to IP-compatible box formulation (#157)

astomodynamics · web-flow · commit d351fd40819a · 2026-03-29T00:10:57.000-04:00
This PR refactors box-style constraints to a single interior-point-friendly formulation and aligns all call sites and tests with the new API.
diff --git a/examples/cddp_acrobot.cpp b/examples/cddp_acrobot.cpp
@@ -88,7 +88,7 @@ int main() {
     
     // Add control constraint
     cddp_solver.addPathConstraint("ControlConstraint", 
-        std::make_unique<cddp::ControlConstraint>(control_upper_bound));
+        std::make_unique<cddp::ControlConstraint>(-control_upper_bound, control_upper_bound));
     
     // Initial trajectory
     std::vector<Eigen::VectorXd> X_init(horizon + 1, Eigen::VectorXd::Zero(state_dim));
diff --git a/examples/cddp_bicycle.cpp b/examples/cddp_bicycle.cpp
@@ -55,9 +55,9 @@ int main()
     control_lower_bound << -10.0, -M_PI / 5;
     Eigen::VectorXd control_upper_bound(control_dim);
     control_upper_bound << 10.0, M_PI / 5;
-    cddp_solver.addPathConstraint("ControlBoxConstraint",
-                                  std::make_unique<cddp::ControlBoxConstraint>(control_lower_bound, control_upper_bound));
-    auto constraint = cddp_solver.getConstraint<cddp::ControlBoxConstraint>("ControlBoxConstraint");
+    cddp_solver.addPathConstraint("ControlConstraint",
+                                  std::make_unique<cddp::ControlConstraint>(control_lower_bound, control_upper_bound));
+    auto constraint = cddp_solver.getConstraint<cddp::ControlConstraint>("ControlConstraint");
     std::vector<Eigen::VectorXd> X(horizon + 1, Eigen::VectorXd::Zero(state_dim));
     std::vector<Eigen::VectorXd> U(horizon, Eigen::VectorXd::Zero(control_dim));
     cddp_solver.setInitialTrajectory(X, U);
diff --git a/examples/cddp_car.cpp b/examples/cddp_car.cpp
@@ -188,8 +188,8 @@ int main()
         options
     );
 
-    cddp_solver.addPathConstraint("ControlBoxConstraint",
-                              std::make_unique<cddp::ControlBoxConstraint>(
+    cddp_solver.addPathConstraint("ControlConstraint",
+                              std::make_unique<cddp::ControlConstraint>(
                                   control_lower_bound, control_upper_bound));
 
     // Initialize with random controls
diff --git a/examples/cddp_car_ipddp.cpp b/examples/cddp_car_ipddp.cpp
@@ -187,7 +187,7 @@ int main() {
     control_lower_bound << -0.5, -2.0;  // [steering_angle, acceleration]
     Eigen::VectorXd control_upper_bound(control_dim);
     control_upper_bound << 0.5, 2.0;
-    cddp_solver.addPathConstraint("ControlConstraint", std::make_unique<cddp::ControlConstraint>(control_upper_bound));
+    cddp_solver.addPathConstraint("ControlConstraint", std::make_unique<cddp::ControlConstraint>(-control_upper_bound, control_upper_bound));
 
     // Initialize the trajectory with zero controls
     std::vector<Eigen::VectorXd> X(horizon + 1, Eigen::VectorXd::Zero(state_dim));
diff --git a/examples/cddp_cartpole.cpp b/examples/cddp_cartpole.cpp
@@ -92,11 +92,11 @@ int main() {
     
     // FIXME: For MSIPDDP 
     cddp_solver.addPathConstraint("ControlConstraint", 
-        std::make_unique<cddp::ControlConstraint>( control_upper_bound));
+        std::make_unique<cddp::ControlConstraint>(-control_upper_bound, control_upper_bound));
 
     // FIXME: For CLDDP
-    // cddp_solver.addPathConstraint("ControlBoxConstraint", 
-    //     std::make_unique<cddp::ControlBoxConstraint>( control_lower_bound, control_upper_bound));
+    // cddp_solver.addPathConstraint("ControlConstraint", 
+    //     std::make_unique<cddp::ControlConstraint>( control_lower_bound, control_upper_bound));
 
     // Initial trajectory.
     std::vector<Eigen::VectorXd> X(horizon + 1, Eigen::VectorXd::Zero(state_dim));
diff --git a/examples/cddp_forklift_ipddp.cpp b/examples/cddp_forklift_ipddp.cpp
@@ -218,13 +218,13 @@ int main() {
     control_upper_bound << 1.5, 0.4;   
     cddp_solver.addPathConstraint("ControlConstraint", 
                                  std::make_unique<cddp::ControlConstraint>(
-                                     control_upper_bound, control_lower_bound));
+                                     control_lower_bound, control_upper_bound));
 
     // State constraints 
     Eigen::VectorXd state_upper_bound(2);
     state_upper_bound << 2.0, max_steering_angle; 
     cddp_solver.addPathConstraint("StateConstraint",
-                                 std::make_unique<cddp::StateConstraint>(state_upper_bound));
+                                 std::make_unique<cddp::StateConstraint>(-state_upper_bound, state_upper_bound));
 
     // Initialize trajectory for back-in parking maneuver
     std::vector<Eigen::VectorXd> X(horizon + 1, Eigen::VectorXd::Zero(state_dim));
diff --git a/examples/cddp_hcw.cpp b/examples/cddp_hcw.cpp
@@ -113,8 +113,8 @@ int main() {
     umin << -1.0, -1.0, -1.0;
     umax <<  1.0,  1.0,  1.0;
 
-    cddp_solver.addPathConstraint("ControlBoxConstraint",
-        std::make_unique<cddp::ControlBoxConstraint>(umin, umax));
+    cddp_solver.addPathConstraint("ControlConstraint",
+        std::make_unique<cddp::ControlConstraint>(umin, umax));
 
     // Initialize the trajectory (X,U) with something nontrivial
     std::vector<Eigen::VectorXd> X(horizon + 1, Eigen::VectorXd::Zero(STATE_DIM));
diff --git a/examples/cddp_lti_system.cpp b/examples/cddp_lti_system.cpp
@@ -109,8 +109,8 @@ int main() {
     Eigen::VectorXd control_lower_bound = -0.6 * Eigen::VectorXd::Ones(control_dim);
     Eigen::VectorXd control_upper_bound = 0.6 * Eigen::VectorXd::Ones(control_dim);
 
-    cddp_solver.addPathConstraint("ControlBoxConstraint", 
-        std::make_unique<cddp::ControlBoxConstraint>(
+    cddp_solver.addPathConstraint("ControlConstraint", 
+        std::make_unique<cddp::ControlConstraint>(
             control_lower_bound, control_upper_bound));
 
     // Initialize trajectories
diff --git a/examples/cddp_manipulator.cpp b/examples/cddp_manipulator.cpp
@@ -73,8 +73,8 @@ int main() {
     double max_torque = 50.0;
     Eigen::VectorXd control_lower_bound = -max_torque * Eigen::VectorXd::Ones(control_dim);
     Eigen::VectorXd control_upper_bound =  max_torque * Eigen::VectorXd::Ones(control_dim);
-    cddp_solver.addPathConstraint("ControlBoxConstraint", 
-        std::make_unique<cddp::ControlBoxConstraint>(control_lower_bound, control_upper_bound));
+    cddp_solver.addPathConstraint("ControlConstraint", 
+        std::make_unique<cddp::ControlConstraint>(control_lower_bound, control_upper_bound));
 
     // Initialize trajectories: here we use linear interpolation between initial and goal state
     std::vector<Eigen::VectorXd> X(horizon + 1, Eigen::VectorXd::Zero(state_dim));
diff --git a/examples/cddp_pendulum.cpp b/examples/cddp_pendulum.cpp
@@ -94,8 +94,8 @@ int main() {
         options
     );
     
-    cddp_solver.addPathConstraint("ControlBoxConstraint",
-        std::make_unique<cddp::ControlBoxConstraint>(control_lower_bound, control_upper_bound));
+    cddp_solver.addPathConstraint("ControlConstraint",
+        std::make_unique<cddp::ControlConstraint>(control_lower_bound, control_upper_bound));
     
     // Set initial trajectory for the solver
     std::vector<Eigen::VectorXd> X(horizon + 1, Eigen::VectorXd::Zero(state_dim));
diff --git a/examples/cddp_quadrotor_circle.cpp b/examples/cddp_quadrotor_circle.cpp
@@ -220,7 +220,7 @@ int main()
     Eigen::VectorXd control_upper_bound = max_force * Eigen::VectorXd::Ones(control_dim);
     Eigen::VectorXd control_lower_bound = min_force * Eigen::VectorXd::Ones(control_dim);
     // cddp_solver.addConstraint("ControlConstraint",
-    //                            std::make_unique<cddp::ControlConstraint>(control_upper_bound, control_lower_bound));
+    //                            std::make_unique<cddp::ControlConstraint>(control_lower_bound, control_upper_bound));
 
     // Initial trajectory: allocate state and control trajectories
     std::vector<Eigen::VectorXd> X(horizon + 1, Eigen::VectorXd::Zero(state_dim));
diff --git a/examples/cddp_quadrotor_figure_eight_horizontal.cpp b/examples/cddp_quadrotor_figure_eight_horizontal.cpp
@@ -216,7 +216,7 @@ int main()
     double max_force = 4.0;
     Eigen::VectorXd control_upper_bound = max_force * Eigen::VectorXd::Ones(control_dim);
     Eigen::VectorXd control_lower_bound = min_force * Eigen::VectorXd::Ones(control_dim);
-    // cddp_solver.addConstraint("ControlConstraint", std::make_unique<cddp::ControlConstraint>(control_upper_bound, control_lower_bound));
+    // cddp_solver.addConstraint("ControlConstraint", std::make_unique<cddp::ControlConstraint>(control_lower_bound, control_upper_bound));
 
     // Initial trajectory guess
     std::vector<Eigen::VectorXd> X(horizon + 1, Eigen::VectorXd::Zero(state_dim));
diff --git a/examples/cddp_quadrotor_figure_eight_horizontal_safe.cpp b/examples/cddp_quadrotor_figure_eight_horizontal_safe.cpp
@@ -228,7 +228,7 @@ int main()
     double max_force = 4.0;
     Eigen::VectorXd control_upper_bound = max_force * Eigen::VectorXd::Ones(control_dim);
     Eigen::VectorXd control_lower_bound = min_force * Eigen::VectorXd::Ones(control_dim);
-    cddp_solver.addPathConstraint("ControlConstraint", std::make_unique<cddp::ControlConstraint>(control_upper_bound, control_lower_bound));
+    cddp_solver.addPathConstraint("ControlConstraint", std::make_unique<cddp::ControlConstraint>(control_lower_bound, control_upper_bound));
 
     // Initial trajectory guess (use reference trajectory like benchmark)
     double hover_thrust = mass * 9.81 / 4.0;
@@ -252,7 +252,7 @@ int main()
         std::make_unique<cddp::QuadraticObjective>(
             Q, R, Qf, goal_state, figure8_reference_states, timestep),
         options);
-    solver_ball.addPathConstraint("ControlConstraint", std::make_unique<cddp::ControlConstraint>(control_upper_bound, control_lower_bound));
+    solver_ball.addPathConstraint("ControlConstraint", std::make_unique<cddp::ControlConstraint>(control_lower_bound, control_upper_bound));
 
     // Ball constraint
     double ball_radius = 0.5; // 50 cm
diff --git a/examples/cddp_quadrotor_figure_eight_vertical.cpp b/examples/cddp_quadrotor_figure_eight_vertical.cpp
@@ -218,7 +218,7 @@ int main()
     double max_force = 4.0; // Maximum thrust per motor
     Eigen::VectorXd control_upper_bound = max_force * Eigen::VectorXd::Ones(control_dim);
     Eigen::VectorXd control_lower_bound = min_force * Eigen::VectorXd::Ones(control_dim);
-    cddp_solver.addPathConstraint("ControlConstraint", std::make_unique<cddp::ControlConstraint>(control_upper_bound));
+    cddp_solver.addPathConstraint("ControlConstraint", std::make_unique<cddp::ControlConstraint>(-control_upper_bound, control_upper_bound));
 
     // Initial trajectory: allocate state and control trajectories
     std::vector<Eigen::VectorXd> X(horizon + 1, Eigen::VectorXd::Zero(state_dim));
diff --git a/examples/cddp_quadrotor_point.cpp b/examples/cddp_quadrotor_point.cpp
@@ -179,7 +179,7 @@ int main()
     Eigen::VectorXd control_lower_bound = min_force * Eigen::VectorXd::Ones(control_dim);
     Eigen::VectorXd control_upper_bound = max_force * Eigen::VectorXd::Ones(control_dim);
     cddp_solver.addPathConstraint("ControlConstraint",
-                                  std::make_unique<cddp::ControlConstraint>(control_upper_bound));
+                                  std::make_unique<cddp::ControlConstraint>(-control_upper_bound, control_upper_bound));
 
     // Initial trajectory: allocate state and control trajectories
     std::vector<Eigen::VectorXd> X(horizon + 1, Eigen::VectorXd::Zero(state_dim));
diff --git a/examples/cddp_spacecraft_linear_docking.cpp b/examples/cddp_spacecraft_linear_docking.cpp
@@ -150,7 +150,7 @@ int main() {
     // Add Control  Constraint
     Eigen::VectorXd u_upper = Eigen::VectorXd::Constant(3, u_max);
     cddp_solver.addPathConstraint("ControlConstraint",
-        std::make_unique<cddp::ControlConstraint>(u_upper));
+        std::make_unique<cddp::ControlConstraint>(-u_upper, u_upper));
 
     // Add Linear Constraints for X-Y Plane Cone Boundary (|y| <= x * tan(fov) for x >= 0)
     // Constraint 1: -tan(fov)*x + y <= 0
diff --git a/examples/cddp_spacecraft_linear_rpo.cpp b/examples/cddp_spacecraft_linear_rpo.cpp
@@ -200,7 +200,7 @@ int main()
     // Add Control Constraint
     Eigen::VectorXd u_upper = Eigen::VectorXd::Constant(3, u_max);
     cddp_solver.addPathConstraint("ControlConstraint",
-        std::make_unique<cddp::ControlConstraint>(u_upper));
+        std::make_unique<cddp::ControlConstraint>(-u_upper, u_upper));
 
     // // Add Thrust Magnitude Constraint
     // cddp_solver.addConstraint("MaxThrustMagnitudeConstraint",
diff --git a/examples/cddp_spacecraft_nonlinear_rpo.cpp b/examples/cddp_spacecraft_nonlinear_rpo.cpp
@@ -211,7 +211,7 @@ int main()
     // Add Control Constraint
     Eigen::VectorXd u_upper = Eigen::VectorXd::Constant(3, u_max);
     cddp_solver.addPathConstraint("ControlConstraint",
-        std::make_unique<cddp::ControlConstraint>(u_upper));
+        std::make_unique<cddp::ControlConstraint>(-u_upper, u_upper));
 
     // // Add Thrust Magnitude Constraint
     // cddp_solver.addConstraint("MaxThrustMagnitudeConstraint",
diff --git a/examples/cddp_spacecraft_roe_rpo.cpp b/examples/cddp_spacecraft_roe_rpo.cpp
@@ -316,7 +316,7 @@ int main()
     // // Add Control Constraint 
     // Eigen::VectorXd u_upper_accel = Eigen::VectorXd::Constant(control_dim, u_force_max_N);
     // cddp_solver.addPathConstraint("ControlConstraint",
-    //     std::make_unique<cddp::ControlConstraint>(u_upper_accel));
+    //     std::make_unique<cddp::ControlConstraint>(-u_upper_accel, u_upper_accel));
 
     // Solve the Trajectory Optimization Problem
     cddp::CDDPSolution solution = cddp_solver.solve("IPDDP");
diff --git a/examples/cddp_spacecraft_rpo.cpp b/examples/cddp_spacecraft_rpo.cpp
@@ -200,7 +200,7 @@ int main()
     // Add Control Constraint
     Eigen::VectorXd u_upper = Eigen::VectorXd::Constant(3, u_max);
     cddp_solver.addPathConstraint("ControlConstraint",
-        std::make_unique<cddp::ControlConstraint>(u_upper));
+        std::make_unique<cddp::ControlConstraint>(-u_upper, u_upper));
 
     // // Add Thrust Magnitude Constraint
     // cddp_solver.addConstraint("MaxThrustMagnitudeConstraint",
diff --git a/examples/cddp_spacecraft_rpo_fuel.cpp b/examples/cddp_spacecraft_rpo_fuel.cpp
@@ -232,7 +232,7 @@ int main()
     // Add Control Constraint
     Eigen::VectorXd u_upper = Eigen::VectorXd::Constant(3, u_max);
     cddp_solver.addPathConstraint("ControlConstraint",
-        std::make_unique<cddp::ControlConstraint>(u_upper));
+        std::make_unique<cddp::ControlConstraint>(-u_upper, u_upper));
     // Add Thrust Magnitude Constraint
     cddp_solver.addPathConstraint("ThrustMagnitudeConstraint",
         std::make_unique<cddp::ThrustMagnitudeConstraint>(u_min_norm, u_max_norm));
diff --git a/examples/cddp_spacecraft_rpo_mc.cpp b/examples/cddp_spacecraft_rpo_mc.cpp
@@ -226,7 +226,7 @@ int main()
         // Add Control Constraint
         Eigen::VectorXd u_upper = Eigen::VectorXd::Constant(3, u_max);
         cddp_solver.addPathConstraint("ControlConstraint",
-                                  std::make_unique<cddp::ControlConstraint>(u_upper));
+                                  std::make_unique<cddp::ControlConstraint>(-u_upper, u_upper));
 
         // Solve the Trajectory Optimization Problem
         cddp::CDDPSolution solution = cddp_solver.solve("MSIPDDP");
diff --git a/examples/cddp_unicycle.cpp b/examples/cddp_unicycle.cpp
@@ -70,8 +70,8 @@ int main() {
     control_upper_bound << 1.0, M_PI;
     
     // Add the constraint to the solver
-    cddp_solver.addPathConstraint(std::string("ControlBoxConstraint"), std::make_unique<cddp::ControlBoxConstraint>(control_lower_bound, control_upper_bound));
-    auto constraint = cddp_solver.getConstraint<cddp::ControlBoxConstraint>("ControlBoxConstraint");
+    cddp_solver.addPathConstraint(std::string("ControlConstraint"), std::make_unique<cddp::ControlConstraint>(control_lower_bound, control_upper_bound));
+    auto constraint = cddp_solver.getConstraint<cddp::ControlConstraint>("ControlConstraint");
 
     // Set initial trajectory
     std::vector<Eigen::VectorXd> X(horizon + 1, Eigen::VectorXd::Zero(state_dim));
diff --git a/examples/cddp_unicycle_mpc.cpp b/examples/cddp_unicycle_mpc.cpp
@@ -161,7 +161,7 @@ int main()
         }
         
         cddp_solver.addPathConstraint("ControlConstraint",
-            std::make_unique<cddp::ControlConstraint>(control_upper_bound, control_lower_bound));
+            std::make_unique<cddp::ControlConstraint>(control_lower_bound, control_upper_bound));
         cddp_solver.addPathConstraint("BallConstraint",
             std::make_unique<cddp::BallConstraint>(closest_obstacle(2), closest_obstacle.head(2)));
 
diff --git a/examples/cddp_unicycle_safe.cpp b/examples/cddp_unicycle_safe.cpp
@@ -93,8 +93,8 @@ int main() {
     );
 
     // Set constraints
-    solver_baseline.addPathConstraint("ControlBoxConstraint",
-        std::make_unique<cddp::ControlBoxConstraint>(control_lower_bound, control_upper_bound));
+    solver_baseline.addPathConstraint("ControlConstraint",
+        std::make_unique<cddp::ControlConstraint>(control_lower_bound, control_upper_bound));
 
     // Simple initial guess: states = initial_state, controls = zeros
     std::vector<Eigen::VectorXd> X_baseline(horizon + 1, initial_state);
@@ -117,8 +117,8 @@ int main() {
         std::make_unique<cddp::QuadraticObjective>(Q, R, Qf, goal_state, empty_reference_states, timestep),
         options
     );
-    solver_ball.addPathConstraint("ControlBoxConstraint",
-        std::make_unique<cddp::ControlBoxConstraint>(control_lower_bound, control_upper_bound));
+    solver_ball.addPathConstraint("ControlConstraint",
+        std::make_unique<cddp::ControlConstraint>(control_lower_bound, control_upper_bound));
 
     // Add the BallConstraint
     double radius = 0.4;
diff --git a/examples/cddp_unicycle_safe_ipddp.cpp b/examples/cddp_unicycle_safe_ipddp.cpp
@@ -107,7 +107,7 @@ int main() {
 
     // Add a control constraint
     solver_baseline.addPathConstraint("ControlConstraint",
-        std::make_unique<cddp::ControlConstraint>(control_upper_bound));
+        std::make_unique<cddp::ControlConstraint>(-control_upper_bound, control_upper_bound));
 
     // Naive initial trajectory
     std::vector<Eigen::VectorXd> X_baseline_init(horizon + 1, initial_state);
@@ -137,7 +137,7 @@ int main() {
 
     // Add constraints
     solver_ball.addPathConstraint("ControlConstraint",
-        std::make_unique<cddp::ControlConstraint>(control_upper_bound));
+        std::make_unique<cddp::ControlConstraint>(-control_upper_bound, control_upper_bound));
     solver_ball.addPathConstraint("BallConstraint",
         std::make_unique<cddp::BallConstraint>(radius, center));
 
@@ -169,7 +169,7 @@ int main() {
 
     // Add constraints
     solver_ball_with_baseline.addPathConstraint("ControlConstraint",
-        std::make_unique<cddp::ControlConstraint>(control_upper_bound));
+        std::make_unique<cddp::ControlConstraint>(-control_upper_bound, control_upper_bound));
     solver_ball_with_baseline.addPathConstraint("BallConstraint",
         std::make_unique<cddp::BallConstraint>(radius, center));
 
diff --git a/examples/cddp_unicycle_safe_ipddp_v2.cpp b/examples/cddp_unicycle_safe_ipddp_v2.cpp
@@ -94,7 +94,7 @@ int main() {
 
     // Add constraints
     cddp_solver.addPathConstraint("ControlConstraint",
-        std::make_unique<cddp::ControlConstraint>(control_upper_bound));
+        std::make_unique<cddp::ControlConstraint>(-control_upper_bound, control_upper_bound));
 
     // First ball constraint
     double radius1 = 0.4;
diff --git a/examples/cddp_unicycle_safe_ipddp_v3.cpp b/examples/cddp_unicycle_safe_ipddp_v3.cpp
@@ -95,7 +95,7 @@ int main() {
     // Add constraints
     // Control constraint
     cddp_solver.addPathConstraint("ControlConstraint",
-        std::make_unique<cddp::ControlConstraint>(control_upper_bound));
+        std::make_unique<cddp::ControlConstraint>(-control_upper_bound, control_upper_bound));
 
     // First ball constraint
     double radius1 = 0.4;
diff --git a/examples/mpc_hcw.cpp b/examples/mpc_hcw.cpp
@@ -200,8 +200,8 @@ int main() {
         u_lower << u_min, u_min, u_min;
         u_upper << u_max, u_max, u_max;
         cddp_solver.addPathConstraint(
-            "ControlBoxConstraint",
-            std::make_unique<cddp::ControlBoxConstraint>(u_lower, u_upper)
+            "ControlConstraint",
+            std::make_unique<cddp::ControlConstraint>(u_lower, u_upper)
         );
 
         // ---------------------------------------------------------------------
diff --git a/examples/test_barrier_strategies.cpp b/examples/test_barrier_strategies.cpp
@@ -72,7 +72,7 @@ int main()
             u_upper << 1.0, 2.0;  // max linear vel, max angular vel
             
             cddp_solver.addPathConstraint("ControlConstraint",
-                std::make_unique<cddp::ControlConstraint>(u_upper));
+                std::make_unique<cddp::ControlConstraint>(-u_upper, u_upper));
             
             // State bounds (keep robot in a region)
             Eigen::VectorXd x_lower(state_dim), x_upper_state(state_dim);
diff --git a/include/cddp-cpp/cddp_core/constraint.hpp b/include/cddp-cpp/cddp_core/constraint.hpp
diff --git a/src/cddp_core/clddp_solver.cpp b/src/cddp_core/clddp_solver.cpp
diff --git a/tests/cddp_core/test_cddp_core.cpp b/tests/cddp_core/test_cddp_core.cpp
diff --git a/tests/cddp_core/test_clddp_solver.cpp b/tests/cddp_core/test_clddp_solver.cpp
diff --git a/tests/cddp_core/test_constraint.cpp b/tests/cddp_core/test_constraint.cpp
diff --git a/tests/cddp_core/test_ipddp_core.cpp b/tests/cddp_core/test_ipddp_core.cpp
diff --git a/tests/cddp_core/test_ipddp_solver.cpp b/tests/cddp_core/test_ipddp_solver.cpp
diff --git a/tests/cddp_core/test_logddp_solver.cpp b/tests/cddp_core/test_logddp_solver.cpp
diff --git a/tests/cddp_core/test_msipddp_core.cpp b/tests/cddp_core/test_msipddp_core.cpp
diff --git a/tests/cddp_core/test_msipddp_solver.cpp b/tests/cddp_core/test_msipddp_solver.cpp
diff --git a/tests/test_ipddp_car.cpp b/tests/test_ipddp_car.cpp
diff --git a/tests/test_ipddp_pendulum.cpp b/tests/test_ipddp_pendulum.cpp
diff --git a/tests/test_ipddp_quadrotor.cpp b/tests/test_ipddp_quadrotor.cpp
diff --git a/tests/test_msipddp_car.cpp b/tests/test_msipddp_car.cpp
