update laplace with review comments

Author: SteveBronder

Jenkinsfile

@@ -337,10 +337,11 @@ pipeline {
                     }
                     steps {
                         unstash 'MathSetup'
-                        sh "echo CXXFLAGS += -fsanitize=address -march=native -mtune=native >> make/local"
+                        sh "echo CXXFLAGS += -march=native -mtune=native >> make/local"
+                        sh "echo O=3 >> make/local"
                         script {
                             if (!(params.optimizeUnitTests || isBranch('develop') || isBranch('master'))) {
-                                sh "echo O=3 >> make/local"
+                                sh "echo CXXFLAGS += -fsanitize=address >> make/local"
                             }
                             runTests("test/unit/math/laplace/*_test.cpp", false)
                         }

stan/math/mix/functor/laplace_likelihood.hpp

@@ -31,6 +31,10 @@ inline auto log_likelihood(F&& f, Theta&& theta, Stream* msgs, Args&&... args) {
                             std::forward<Args>(args)..., msgs);
 }
 
+/**
+ * Decide if object should be deep or shallow copied when
+ * using @ref conditional_copy_and_promote .
+ */
 enum class COPY_TYPE { SHALLOW = 0, DEEP = 1 };
 
 /**
@@ -54,7 +58,7 @@ inline auto conditional_copy_and_promote(Args&&... args) {
         if constexpr (is_tuple_v<decltype(arg)>) {
           return stan::math::apply(
               [](auto&&... inner_args) {
-                return partially_forward_as_tuple(
+                return make_holder_tuple(
                     conditional_copy_and_promote<Filter, PromotedType,
                                                  CopyType>(
                         std::forward<decltype(inner_args)>(inner_args))...);
@@ -289,12 +293,12 @@ inline auto diff_eta_implicit(F&& f, V_t&& v, Theta&& theta, Stream* msgs,
   }
   auto shallow_copy_args
       = shallow_copy_vargs<fvar<var>>(std::forward_as_tuple(args...));
-  fvar<var> f_fvar = stan::math::apply(
+  fvar<var> f_sum = stan::math::apply(
       [](auto&& f, auto&& theta_fvar, auto&& msgs, auto&&... inner_args) {
         return f(theta_fvar, inner_args..., msgs);
       },
       shallow_copy_args, f, theta_fvar, msgs);
-  grad(f_fvar.d_.vi_);
+  grad(f_sum.d_.vi_);
 }
 
 }  // namespace internal

stan/math/mix/functor/laplace_marginal_density.hpp

@@ -2,15 +2,16 @@
 #define STAN_MATH_MIX_FUNCTOR_LAPLACE_MARGINAL_DENSITY_HPP
 #include <stan/math/prim/fun/Eigen.hpp>
 #include <stan/math/mix/functor/laplace_likelihood.hpp>
+#include <test/unit/pretty_print_types.hpp>
 #include <stan/math/rev/meta.hpp>
 #include <stan/math/rev/core.hpp>
 #include <stan/math/rev/fun.hpp>
 #include <stan/math/rev/fun/value_of.hpp>
 #include <stan/math/rev/functor.hpp>
 #include <stan/math/prim/fun/to_ref.hpp>
 #include <stan/math/prim/fun/quad_form_diag.hpp>
-#include <stan/math/prim/functor/iter_tuple_n.hpp>
-
+#include <stan/math/prim/functor/iter_tuple_nested.hpp>
+#include <unsupported/Eigen/MatrixFunctions>
 #include <cmath>
 
 /**
@@ -43,7 +44,7 @@ struct laplace_options {
    */
   double tolerance{1e-6};
   /* Maximum number of steps*/
-  int64_t max_num_steps{100};
+  int max_num_steps{100};
 };
 
 namespace internal {
@@ -297,7 +298,7 @@ inline void set_zero_adjoint(Output&& output) {
   if constexpr (is_all_arithmetic_scalar_v<Output>) {
     return;
   } else {
-    return iter_tuple_n(
+    return iter_tuple_nested(
         [](auto&& output_i) {
           using output_i_t = std::decay_t<decltype(output_i)>;
           if constexpr (is_all_arithmetic_scalar_v<output_i_t>) {
@@ -312,9 +313,9 @@ inline void set_zero_adjoint(Output&& output) {
             output_i.adj() = 0;
           } else {
             static_assert(
-                1,
+                sizeof(Output*) == 0,
                 "INTERNAL ERROR:(laplace_marginal_lpdf) set_zero_adjoints was "
-                "not able to deduce the actiopns needed for the given type.");
+                "not able to deduce the actions needed for the given type.");
           }
         },
         std::forward<Output>(output));
@@ -333,7 +334,7 @@ template <bool ZeroInput = false, typename Output, typename Input,
           require_t<is_all_arithmetic_scalar<Output>>* = nullptr,
           require_t<is_all_var_scalar<Input>>* = nullptr>
 inline void collect_adjoints(Output& output, Input&& input) {
-  return iter_tuple_n(
+  return iter_tuple_nested(
       [](auto&& output_i, auto&& input_i) {
         using output_i_t = std::decay_t<decltype(output_i)>;
         if constexpr (is_std_vector_v<output_i_t>) {
@@ -357,7 +358,7 @@ inline void collect_adjoints(Output& output, Input&& input) {
           }
         } else {
           static_assert(
-              1,
+              sizeof(Output*) == 0,
               "INTERNAL ERROR:(laplace_marginal_lpdf) collect_adjoints was not "
               "able to deduce the actiopns needed for the given type.");
         }
@@ -557,7 +558,7 @@ inline auto laplace_marginal_density_est(LLFun&& ll_fun, LLTupleArgs&& ll_args,
               std::move(covariance),
               std::move(theta),
               std::move(W),
-              std::move(Eigen::MatrixXd(L)),
+              Eigen::MatrixXd(L),
               std::move(a),
               std::move(theta_grad),
               Eigen::PartialPivLU<Eigen::MatrixXd>{},
@@ -624,7 +625,7 @@ inline auto laplace_marginal_density_est(LLFun&& ll_fun, LLTupleArgs&& ll_args,
               std::move(covariance),
               std::move(theta),
               std::move(W_r),
-              std::move(Eigen::MatrixXd(L)),
+              Eigen::MatrixXd(L),
               std::move(a),
               std::move(theta_grad),
               Eigen::PartialPivLU<Eigen::MatrixXd>{},
@@ -796,7 +797,7 @@ template <typename Output, typename Input,
           require_t<is_all_arithmetic_scalar<Output>>* = nullptr,
           require_t<is_all_arithmetic_scalar<Input>>* = nullptr>
 inline void collect_adjoints(Output&& output, Input&& input) {
-  return iter_tuple_n(
+  return iter_tuple_nested(
       [](auto&& output_i, auto&& input_i) {
         using output_i_t = std::decay_t<decltype(output_i)>;
         if constexpr (is_std_vector_v<output_i_t>) {
@@ -811,7 +812,7 @@ inline void collect_adjoints(Output&& output, Input&& input) {
           output_i += input_i;
         } else {
           static_assert(
-              1,
+              sizeof(Output*) == 0,
               "INTERNAL ERROR:(laplace_marginal_lpdf) collect_adjoints was not "
               "able to deduce the actiopns needed for the given type.");
         }
@@ -837,7 +838,7 @@ template <bool ZeroInput = false, typename Output, typename Input,
           require_t<is_all_arithmetic_scalar<Output>>* = nullptr,
           require_t<is_any_var_scalar<Input>>* = nullptr>
 inline void copy_compute_s2(Output&& output, Input&& input) {
-  return iter_tuple_n(
+  return iter_tuple_nested(
       [](auto&& output_i, auto&& input_i) {
         using output_i_t = std::decay_t<decltype(output_i)>;
         if constexpr (is_std_vector_v<output_i_t>) {
@@ -861,14 +862,21 @@ inline void copy_compute_s2(Output&& output, Input&& input) {
           }
         } else {
           static_assert(
-              1,
+              sizeof(Output*) == 0,
               "INTERNAL ERROR:(laplace_marginal_lpdf) copy_compute_s2 was not "
               "able to deduce the actiopns needed for the given type.");
         }
       },
       std::forward<Output>(output), std::forward<Input>(input));
 }
 
+template <typename T>
+inline constexpr decltype(auto) filter_var_scalar_types(T&& t) {
+  return stan::math::filter_map<is_any_var_scalar>(
+    [](auto&& arg) -> decltype(auto) {
+      return std::forward<decltype(arg)>(arg);
+    }, std::forward<T>(t));
+}
 /**
  * Creates an arena type from the input with initialized with zeros
  * @tparam Input Possibly a tuple, std::vector, Eigen type, or scalar
@@ -900,37 +908,6 @@ inline constexpr auto make_zeroed_arena(Input&& input) {
   }
 }
 
-/**
- * Helper function for printing out adjoints
- */
-template <typename Output, require_t<is_any_var_scalar<Output>>* = nullptr>
-inline void print_adjoint(Output&& output) {
-  if constexpr (is_tuple_v<Output>) {
-    std::cout << "tuple adj\n";
-    return stan::math::for_each(
-        [](auto&& output_i) { return print_adjoint(output_i); }, output);
-  } else if constexpr (is_std_vector_v<Output>) {
-    if constexpr (is_var_v<value_type_t<Output>>) {
-      Eigen::Map<const Eigen::Matrix<var, -1, -1>> map_x(output.data(),
-                                                         output.size());
-      std::cout << "eigen adj: \n" << map_x.adj() << std::endl;
-    } else {
-      std::cout << "stdvec adjoint\n";
-      for (int i = 0; i < output.size(); ++i) {
-        print_adjoint(output[i]);
-      }
-    }
-  } else if constexpr (is_eigen_v<Output>) {
-    std::cout << "adj: \n" << output.adj() << std::endl;
-  } else if constexpr (is_stan_scalar_v<Output>) {
-    std::cout << "adj: " << output.adj() << std::endl;
-  } else {
-    static_assert(1,
-                  "INTERNAL ERROR:(laplace_marginal_lpdf) print_adjoint was "
-                  "not able to deduce the actiopns needed for the given type.");
-  }
-}
-
 /**
  * Used in reverse pass to collect adjoints to the output
  * @tparam Output A tuple or type where all scalar types are `var` types
@@ -942,7 +919,7 @@ inline void print_adjoint(Output&& output) {
 template <typename Output, typename Input>
 inline void collect_adjoints(Output&& output, const vari* ret, Input&& input) {
   if constexpr (is_tuple_v<Output>) {
-    static_assert(1,
+    static_assert(!is_tuple_v<Output>,
                   "INTERNAL ERROR:(laplace_marginal_lpdf)"
                   "Accumulate Adjoints called on a tuple, but tuples cannot be "
                   "on the reverse mode stack!"
@@ -1067,11 +1044,7 @@ inline auto laplace_marginal_density(const LLFun& ll_fun, LLTupleArgs&& ll_args,
         ll_fun, ll_args_copy, value_of(theta_0), covariance_function,
         value_of(covar_args_refs), options, msgs);
     // Return references to var types
-    auto ll_args_filter = stan::math::filter_map<is_any_var_scalar>(
-        [](auto&& arg) -> decltype(auto) {
-          return std::forward<decltype(arg)>(arg);
-        },
-        ll_args_copy);
+    auto ll_args_filter = internal::filter_var_scalar_types(ll_args_copy);
     stan::math::for_each(
         [](auto&& output_i, auto&& ll_arg_i) {
           if (is_any_var_scalar_v<decltype(ll_arg_i)>) {
@@ -1171,11 +1144,7 @@ inline auto laplace_marginal_density(const LLFun& ll_fun, LLTupleArgs&& ll_args,
           K_var.adj().array() += vi.adj() * K_adj_arena.array();
         });
         grad(Z.vi_);
-        auto covar_args_filter = stan::math::filter_map<is_any_var_scalar>(
-            [](auto&& arg) -> decltype(auto) {
-              return std::forward<decltype(arg)>(arg);
-            },
-            covar_args_copy);
+        auto covar_args_filter = internal::filter_var_scalar_types(covar_args_copy);
         internal::collect_adjoints(covar_args_adj, covar_args_filter);
       }();
     }
@@ -1194,14 +1163,12 @@ inline auto laplace_marginal_density(const LLFun& ll_fun, LLTupleArgs&& ll_args,
   }
   var ret(lmd);
   if constexpr (is_any_var_scalar_v<CovarArgs>) {
-    auto covar_args_filter = stan::math::filter_map<is_any_var_scalar>(
-        [](auto&& arg) -> decltype(auto) { return arg; }, covar_args_refs);
+    auto covar_args_filter = internal::filter_var_scalar_types(covar_args_refs);
     internal::reverse_pass_collect_adjoints(ret, covar_args_filter,
                                             covar_args_adj);
   }
   if constexpr (ll_args_contain_var) {
-    auto ll_args_filter = stan::math::filter_map<is_any_var_scalar>(
-        [](auto&& arg) -> decltype(auto) { return arg; }, ll_args_refs);
+    auto ll_args_filter = internal::filter_var_scalar_types(ll_args_refs);
     internal::reverse_pass_collect_adjoints(ret, ll_args_filter, partial_parm);
   }
   return ret;

stan/math/mix/prob/laplace_latent_bernoulli_logit_rng.hpp

@@ -31,7 +31,7 @@ template <typename ThetaVec, typename CovarFun, typename CovarArgs,
 inline Eigen::VectorXd laplace_latent_tol_bernoulli_logit_rng(
     const std::vector<int>& y, const std::vector<int>& n_samples,
     ThetaVec&& theta_0, CovarFun&& covariance_function, CovarArgs&& covar_args,
-    const double tolerance, const int64_t max_num_steps,
+    const double tolerance, const int max_num_steps,
     const int hessian_block_size, const int solver,
     const int max_steps_line_search, RNG& rng, std::ostream* msgs) {
   laplace_options ops{hessian_block_size, solver, max_steps_line_search,

stan/math/mix/prob/laplace_latent_neg_binomial_2_log_rng.hpp

@@ -37,7 +37,7 @@ template <typename Eta, typename ThetaVec, typename CovarFun,
 inline Eigen::VectorXd laplace_latent_tol_neg_binomial_2_log_rng(
     const std::vector<int>& y, const std::vector<int>& y_index, Eta&& eta,
     ThetaVec&& theta_0, CovarFun&& covariance_function, CovarArgs&& covar_args,
-    const double tolerance, const int64_t max_num_steps,
+    const double tolerance, const int max_num_steps,
     const int hessian_block_size, const int solver,
     const int max_steps_line_search, RNG& rng, std::ostream* msgs) {
   laplace_options ops{hessian_block_size, solver, max_steps_line_search,

stan/math/mix/prob/laplace_latent_poisson_log_exposure_rng.hpp

@@ -33,7 +33,7 @@ template <typename YeVec, typename ThetaVec, typename CovarFun,
 inline auto laplace_latent_tol_poisson_2_log_rng(
     const std::vector<int>& y, const std::vector<int>& y_index, const YeVec& ye,
     ThetaVec&& theta_0, CovarFun&& covariance_function, CovarArgs&& covar_args,
-    const double tolerance, const int64_t max_num_steps,
+    const double tolerance, const int max_num_steps,
     const int hessian_block_size, const int solver,
     const int max_steps_line_search, RNG& rng, std::ostream* msgs) {
   laplace_options ops{hessian_block_size, solver, max_steps_line_search,

stan/math/mix/prob/laplace_latent_poisson_log_rng.hpp

@@ -31,7 +31,7 @@ template <typename ThetaVec, typename CovarFun, typename CovarArgs,
 inline Eigen::VectorXd laplace_latent_tol_poisson_log_rng(
     const std::vector<int>& y, const std::vector<int>& y_index,
     ThetaVec&& theta_0, CovarFun&& covariance_function, CovarArgs&& covar_args,
-    const double tolerance, const int64_t max_num_steps,
+    const double tolerance, const int max_num_steps,
     const int hessian_block_size, const int solver,
     const int max_steps_line_search, RNG& rng, std::ostream* msgs) {
   laplace_options ops{hessian_block_size, solver, max_steps_line_search,

stan/math/mix/prob/laplace_latent_rng.hpp

@@ -32,7 +32,7 @@ template <typename LLFunc, typename LLArgs, typename ThetaVec,
 inline auto laplace_latent_tol_rng(
     LLFunc&& L_f, LLArgs&& ll_args, ThetaVec&& theta_0,
     CovarFun&& covariance_function, CovarArgs&& covar_args,
-    const double tolerance, const int64_t max_num_steps,
+    const double tolerance, const int max_num_steps,
     const int hessian_block_size, const int solver,
     const int max_steps_line_search, RNG& rng, std::ostream* msgs) {
   const laplace_options ops{hessian_block_size, solver, max_steps_line_search,

stan/math/mix/prob/laplace_marginal.hpp

@@ -31,9 +31,8 @@ template <bool propto = false, typename LFun, typename LArgs, typename CovarFun,
 inline auto laplace_marginal_tol(
     LFun&& L_f, LArgs&& l_args, const ThetaVec& theta_0,
     CovarFun&& covariance_function, CovarArgs&& covar_args, double tolerance,
-    int64_t max_num_steps, const int hessian_block_size, const int solver,
+    int max_num_steps, const int hessian_block_size, const int solver,
     const int max_steps_line_search, std::ostream* msgs) {
-  // TEST: provisional signature to agree with parser.
   laplace_options ops{hessian_block_size, solver, max_steps_line_search,
                       tolerance, max_num_steps};
   return laplace_marginal_density(

stan/math/mix/prob/laplace_marginal_bernoulli_logit_lpmf.hpp

@@ -50,7 +50,7 @@ template <bool propto = false, typename ThetaVec, typename CovarFun,
 inline auto laplace_marginal_tol_bernoulli_logit_lpmf(
     const std::vector<int>& y, const std::vector<int>& n_samples,
     const ThetaVec& theta_0, CovarFun&& covariance_function,
-    CovarArgs&& covar_args, double tolerance, int64_t max_num_steps,
+    CovarArgs&& covar_args, double tolerance, int max_num_steps,
     const int hessian_block_size, const int solver,
     const int max_steps_line_search, std::ostream* msgs) {
   laplace_options ops{hessian_block_size, solver, max_steps_line_search,