update solve_newton argument ordering.

Author: charlesm93

stan/math/rev/functor/solve_newton.hpp

@@ -56,11 +56,11 @@ namespace math {
 template <typename F, typename T, typename... Args,
           require_eigen_vector_t<T>* = nullptr,
           require_all_st_arithmetic<Args...>* = nullptr>
-Eigen::VectorXd solve_newton_impl(const F& f, const T& x,
-                                  std::ostream* const msgs,
+Eigen::VectorXd solve_newton_tol(const F& f, const T& x,
                                   const double scaling_step_size,
                                   const double function_tolerance,
                                   const int64_t max_num_steps,
+                                  std::ostream* const msgs,
                                   const Args&... args) {
   const auto& x_ref = to_ref(value_of(x));
 
@@ -135,10 +135,10 @@ Eigen::VectorXd solve_newton_impl(const F& f, const T& x,
 template <typename F, typename T, typename... T_Args,
           require_eigen_vector_t<T>* = nullptr,
           require_any_st_var<T_Args...>* = nullptr>
-Eigen::Matrix<var, Eigen::Dynamic, 1> solve_newton_impl(
-    const F& f, const T& x, std::ostream* const msgs,
-    const double scaling_step_size, const double function_tolerance,
-    const int64_t max_num_steps, const T_Args&... args) {
+Eigen::Matrix<var, Eigen::Dynamic, 1> solve_newton_tol(
+    const F& f, const T& x, const double scaling_step_size,
+    const double function_tolerance, const int64_t max_num_steps,
+    std::ostream* const msgs, const T_Args&... args) {
   const auto& x_ref = to_ref(value_of(x));
   auto arena_args_tuple = make_chainable_ptr(std::make_tuple(eval(args)...));
   auto args_vals_tuple = math::apply(
@@ -234,21 +234,21 @@ Eigen::Matrix<var, Eigen::Dynamic, 1> solve_newton_impl(
  * @throw <code>std::invalid_argument</code> if max_num_steps is not positive.
  * @throw <code>std::domain_error if solver exceeds max_num_steps.
  */
-template <typename F, typename T, typename... T_Args,
-          require_eigen_vector_t<T>* = nullptr>
-Eigen::Matrix<stan::return_type_t<T_Args...>, Eigen::Dynamic, 1>
-solve_newton_tol(const F& f, const T& x, const double scaling_step_size,
-                 const double function_tolerance, const int64_t max_num_steps,
-                 std::ostream* const msgs, const T_Args&... args) {
-  const auto& args_ref_tuple = std::make_tuple(to_ref(args)...);
-  return math::apply(
-      [&](const auto&... args_refs) {
-        return solve_newton_impl(f, x, msgs,
-                                 scaling_step_size, function_tolerance,
-                                 max_num_steps, args_refs...);
-      },
-      args_ref_tuple);
-}
+// template <typename F, typename T, typename... T_Args,
+//           require_eigen_vector_t<T>* = nullptr>
+// Eigen::Matrix<stan::return_type_t<T_Args...>, Eigen::Dynamic, 1>
+// solve_newton_tol(const F& f, const T& x, const double scaling_step_size,
+//                  const double function_tolerance, const int64_t max_num_steps,
+//                  std::ostream* const msgs, const T_Args&... args) {
+//   const auto& args_ref_tuple = std::make_tuple(to_ref(args)...);
+//   return math::apply(
+//       [&](const auto&... args_refs) {
+//         return solve_newton_impl(f, x, msgs,
+//                                  scaling_step_size, function_tolerance,
+//                                  max_num_steps, args_refs...);
+//       },
+//       args_ref_tuple);
+// }
 
 /**
  * Return the solution to the specified system of algebraic
@@ -348,9 +348,9 @@ Eigen::Matrix<scalar_type_t<T2>, Eigen::Dynamic, 1> algebra_solver_newton(
     const double scaling_step_size = 1e-3,
     const double function_tolerance = 1e-6,
     const long int max_num_steps = 200) {  // NOLINT(runtime/int)
-  return solve_newton_impl(algebra_solver_adapter<F>(f), x, msgs,
+  return solve_newton_tol(algebra_solver_adapter<F>(f), x,
                            scaling_step_size, function_tolerance, max_num_steps,
-                           y, dat, dat_int);
+                           msgs, y, dat, dat_int);
 }
 
 }  // namespace math

test/unit/math/rev/functor/solve_newton_test.cpp

@@ -13,15 +13,15 @@
 // Tests for newton solver.
 
 TEST_F(algebra_solver_simple_eq_test, newton_dbl) {
-  int solver_type = 1;
+  bool is_newton = true;
   Eigen::VectorXd theta
-      = simple_eq_test(simple_eq_functor(), y_dbl, solver_type);
+      = simple_eq_test(simple_eq_functor(), y_dbl, is_newton);
 }
 
 TEST_F(algebra_solver_simple_eq_test, newton_tuned_dbl) {
-  int solver_type = 1;
+  bool is_newton = true;
   Eigen::VectorXd theta
-      = simple_eq_test(simple_eq_functor(), y_dbl, solver_type, true,
+      = simple_eq_test(simple_eq_functor(), y_dbl, is_newton, true,
                        scale_step, xtol, ftol, maxfev);
 }
 
@@ -34,22 +34,22 @@ TEST_F(algebra_solver_simple_eq_nopara_test, newton_dbl) {
 }
 
 TEST_F(algebra_solver_non_linear_eq_test, newton_dbl) {
-  int solver_type = 1;
+  bool is_newton = true;
   Eigen::VectorXd theta
-      = non_linear_eq_test(non_linear_eq_functor(), y_dbl, solver_type);
+      = non_linear_eq_test(non_linear_eq_functor(), y_dbl, is_newton);
   EXPECT_FLOAT_EQ(-y_dbl(0), theta(0));
   EXPECT_FLOAT_EQ(-y_dbl(1), theta(1));
   EXPECT_FLOAT_EQ(y_dbl(2), theta(2));
 }
 
 TEST_F(error_message_test, newton_dbl) {
-  int solver_type = 1;
-  error_conditions_test(non_linear_eq_functor(), y_3, solver_type);
+  bool is_newton = true;
+  error_conditions_test(non_linear_eq_functor(), y_3, is_newton);
 }
 
 TEST_F(max_steps_test, newton_dbl) {
-  int solver_type = 1;
-  max_num_steps_test(y, solver_type);
+  bool is_newton = true;
+  max_num_steps_test(y, is_newton);
 }
 
 TEST(MathMatrixRevMat, unsolvable_flag_newton_dbl) {
@@ -112,12 +112,12 @@ TEST_F(degenerate_eq_test, newton_guess_saddle_point_dbl) {
 
 TEST_F(algebra_solver_simple_eq_test, newton) {
   using stan::math::var;
-  int solver_type = 1;
+  bool is_newton = true;
   for (int k = 0; k < n_x; k++) {
     Eigen::Matrix<var, Eigen::Dynamic, 1> y = y_dbl;
 
     Eigen::Matrix<var, Eigen::Dynamic, 1> theta
-        = simple_eq_test(simple_eq_functor(), y, solver_type);
+        = simple_eq_test(simple_eq_functor(), y, is_newton);
 
     std::vector<stan::math::var> y_vec{y(0), y(1), y(2)};
     std::vector<double> g;
@@ -130,12 +130,12 @@ TEST_F(algebra_solver_simple_eq_test, newton) {
 
 TEST_F(algebra_solver_simple_eq_test, newton_tuned) {
   using stan::math::var;
-  int solver_type = 1;
+  bool is_newton = true;
   for (int k = 0; k < n_x; k++) {
     Eigen::Matrix<var, Eigen::Dynamic, 1> y = y_dbl;
 
     Eigen::Matrix<var, Eigen::Dynamic, 1> theta
-        = simple_eq_test(simple_eq_functor(), y, solver_type, true, scale_step,
+        = simple_eq_test(simple_eq_functor(), y, is_newton, true, scale_step,
                          xtol, ftol, maxfev);
 
     std::vector<stan::math::var> y_vec{y(0), y(1), y(2)};
@@ -157,11 +157,11 @@ TEST_F(algebra_solver_simple_eq_test, newton_init_is_para) {
 
 TEST_F(algebra_solver_non_linear_eq_test, newton) {
   using stan::math::var;
-  int solver_type = 1;
+  bool is_newton = true;
   for (int k = 0; k < n_x; k++) {
     Eigen::Matrix<var, Eigen::Dynamic, 1> y = y_dbl;
     Eigen::Matrix<var, Eigen::Dynamic, 1> theta
-        = non_linear_eq_test(non_linear_eq_functor(), y, solver_type);
+        = non_linear_eq_test(non_linear_eq_functor(), y, is_newton);
 
     EXPECT_FLOAT_EQ(-y(0).val(), theta(0).val());
     EXPECT_FLOAT_EQ(-y(1).val(), theta(1).val());
@@ -178,14 +178,14 @@ TEST_F(algebra_solver_non_linear_eq_test, newton) {
 
 TEST_F(error_message_test, newton) {
   using stan::math::var;
-  int solver_type = 1;
+  bool is_newton = true;
   Eigen::Matrix<var, Eigen::Dynamic, 1> y = y_2;
-  error_conditions_test(non_linear_eq_functor(), y, solver_type);
+  error_conditions_test(non_linear_eq_functor(), y, is_newton);
 }
 
 TEST_F(max_steps_test, newton) {
-  int solver_type = 1;
-  max_num_steps_test(y_var, solver_type);
+  bool is_newton = true;
+  max_num_steps_test(y_var, is_newton);
 }
 
 TEST(MathMatrixRevMat, unsolvable_flag_newton) {
@@ -238,7 +238,7 @@ TEST_F(degenerate_eq_test, newton_guess2) {
 
 TEST_F(variadic_test, newton) {
   using stan::math::var;
-  int solver_type = 1;
+  bool is_newton = true;
   bool is_impl = false;
   bool use_tol = false;
   for (int k = 0; k < n_x; k++) {
@@ -247,7 +247,7 @@ TEST_F(variadic_test, newton) {
     var y_3 = y_3_dbl;
 
     Eigen::Matrix<var, Eigen::Dynamic, 1> theta = variadic_eq_impl_test(
-        A, y_1, y_2, y_3, i, solver_type, is_impl, use_tol, scaling_step_size,
+        A, y_1, y_2, y_3, i, is_newton, use_tol, scaling_step_size,
         relative_tolerance, function_tolerance, max_num_steps);
     std::vector<var> y_vec{y_1, y_2, y_3};
     std::vector<double> g;
@@ -261,12 +261,13 @@ TEST_F(variadic_test, newton) {
 // Additional tests for deprecated signature (with and without tol)
 TEST_F(algebra_solver_simple_eq_test, newton_deprecated) {
   using stan::math::var;
-  int solver_type = 3;
+  bool is_newton = true;
   for (int k = 0; k < n_x; k++) {
     Eigen::Matrix<var, Eigen::Dynamic, 1> y = y_dbl;
 
     Eigen::Matrix<var, Eigen::Dynamic, 1> theta
-        = simple_eq_test(simple_eq_functor(), y, solver_type);
+        = simple_eq_non_varia_test(simple_eq_non_varia_functor(), y,
+                                   is_newton);
 
     std::vector<stan::math::var> y_vec{y(0), y(1), y(2)};
     std::vector<double> g;
@@ -279,13 +280,14 @@ TEST_F(algebra_solver_simple_eq_test, newton_deprecated) {
 
 TEST_F(algebra_solver_simple_eq_test, newton_tuned_deprecated) {
   using stan::math::var;
-  int solver_type = 3;
+  bool is_newton = true;
   for (int k = 0; k < n_x; k++) {
     Eigen::Matrix<var, Eigen::Dynamic, 1> y = y_dbl;
 
     Eigen::Matrix<var, Eigen::Dynamic, 1> theta
-        = simple_eq_test(simple_eq_functor(), y, solver_type, true, scale_step,
-                         xtol, ftol, maxfev);
+        = simple_eq_non_varia_test(simple_eq_non_varia_functor(), y,
+                                   is_newton, true,
+                                   scale_step, xtol, ftol, maxfev);
 
     std::vector<stan::math::var> y_vec{y(0), y(1), y(2)};
     std::vector<double> g;