Fix NewtonState and WolfeInfo constructors

Author: SteveBronder

stan/math/mix/functor/laplace_marginal_density_estimator.hpp

@@ -359,27 +359,6 @@ struct NewtonState {
    */
   bool final_loop = false;
 
-  /**
-   * @brief Constructs Newton state with given dimensions and functors.
-   *
-   * @tparam ThetaInitializer Type of the initial theta provider
-   * @param theta_size Dimension of the latent space
-   * @param obj_fun Objective function: (a, theta) -> double
-   * @param theta_grad_f Gradient function: theta -> grad
-   * @param theta_init Initial theta value or provider
-   */
-  template <typename ObjFun, typename ThetaGradFun, typename ThetaInitializer>
-  NewtonState(int theta_size, ObjFun&& obj_fun, ThetaGradFun&& theta_grad_f,
-              ThetaInitializer&& theta_init)
-      : wolfe_info(std::forward<ObjFun>(obj_fun), theta_size,
-                   std::forward<ThetaInitializer>(theta_init),
-                   std::forward<ThetaGradFun>(theta_grad_f)),
-        b(theta_size),
-        B(theta_size, theta_size),
-        prev_g(theta_size) {
-    wolfe_status.num_backtracks_ = -1;  // Safe initial value for BB step
-  }
-
   /**
    * @brief Constructs Newton state with a consistent (a_init, theta_init) pair.
    *
@@ -392,12 +371,12 @@ struct NewtonState {
    * @param a_init Initial a value consistent with theta_init
    * @param theta_init Initial theta value
    */
-  template <typename ObjFun, typename ThetaGradFun, typename ThetaInitializer>
+  template <typename ObjFun, typename ThetaGradFun, typename CovarianceT, typename ThetaInitializer>
   NewtonState(int theta_size, ObjFun&& obj_fun, ThetaGradFun&& theta_grad_f,
-              const Eigen::VectorXd& a_init, ThetaInitializer&& theta_init)
-      : wolfe_info(std::forward<ObjFun>(obj_fun), a_init,
+              CovarianceT&& covariance, ThetaInitializer&& theta_init)
+      : wolfe_info(std::forward<ObjFun>(obj_fun), covariance.llt().solve(theta_init),
                    std::forward<ThetaInitializer>(theta_init),
-                   std::forward<ThetaGradFun>(theta_grad_f), 0),
+                   std::forward<ThetaGradFun>(theta_grad_f)),
         b(theta_size),
         B(theta_size, theta_size),
         prev_g(theta_size) {
@@ -1213,16 +1192,7 @@ inline auto laplace_marginal_density_est(
   // the prior term -0.5 * a'*theta vanishes (a=0 while theta!=0), inflating
   // the initial objective and causing the Wolfe line search to reject the
   // first Newton step.
-  auto make_state = [&](auto&& theta_0) {
-    if constexpr (InitTheta) {
-      Eigen::VectorXd a_init = covariance.llt().solve(Eigen::VectorXd(theta_0));
-      return internal::NewtonState(theta_size, obj_fun, theta_grad_f, a_init,
-                                   theta_0);
-    } else {
-      return internal::NewtonState(theta_size, obj_fun, theta_grad_f, theta_0);
-    }
-  };
-  auto state = make_state(theta_init);
+  auto state = NewtonState(theta_size, obj_fun, theta_grad_f, covariance, theta_init);
   // Start with safe step size
   auto update_fun = create_update_fun(
       std::move(obj_fun), std::move(theta_grad_f), covariance, options);

stan/math/mix/functor/wolfe_line_search.hpp

@@ -499,19 +499,7 @@ struct WolfeInfo {
   Eigen::VectorXd p_;
   // Initial directional derivative
   double init_dir_;
-  template <typename ObjFun, typename Theta0, typename ThetaGradF>
-  WolfeInfo(ObjFun&& obj_fun, Eigen::Index n, Theta0&& theta0,
-            ThetaGradF&& theta_grad_f)
-      : curr_(std::forward<ObjFun>(obj_fun), n, std::forward<Theta0>(theta0),
-              std::forward<ThetaGradF>(theta_grad_f)),
-        prev_(curr_),
-        scratch_(n) {
-    if (!std::isfinite(curr_.obj())) {
-      throw std::domain_error(
-          "laplace_marginal_density: log likelihood is not finite at initial "
-          "theta and likelihood arguments.");
-    }
-  }
+
   /**
    * Construct WolfeInfo with a consistent (a_init, theta_init) pair.
    *
@@ -521,10 +509,10 @@ struct WolfeInfo {
    * an inflated initial objective (the prior term -0.5 * a'*theta would
    * otherwise vanish when a is zero but theta is not).
    */
-  template <typename ObjFun, typename Theta0, typename ThetaGradF>
-  WolfeInfo(ObjFun&& obj_fun, const Eigen::VectorXd& a_init, Theta0&& theta0,
-            ThetaGradF&& theta_grad_f, int /*tag*/)
-      : curr_(std::forward<ObjFun>(obj_fun), a_init,
+  template <typename ObjFun, typename Theta0, typename AInit, typename ThetaGradF>
+  WolfeInfo(ObjFun&& obj_fun, AInit&& a_init, Theta0&& theta0,
+            ThetaGradF&& theta_grad_f)
+      : curr_(std::forward<ObjFun>(obj_fun), std::forward<AInit>(a_init),
               std::forward<Theta0>(theta0),
               std::forward<ThetaGradF>(theta_grad_f)),
         prev_(curr_),