update filter_map to handle arrays of tuples

Author: SteveBronder

stan/math/mix/functor/laplace_likelihood.hpp

@@ -1,7 +1,6 @@
 #ifndef STAN_MATH_MIX_FUNCTOR_LAPLACE_LIKELIHOOD_HPP
 #define STAN_MATH_MIX_FUNCTOR_LAPLACE_LIKELIHOOD_HPP
 
-// #include <stan/math/mix/laplace/hessian_times_vector.hpp>
 #include <stan/math/mix/functor/hessian_block_diag.hpp>
 #include <stan/math/prim/functor.hpp>
 #include <stan/math/prim/fun.hpp>
@@ -61,6 +60,14 @@ inline auto conditional_copy_and_promote(Args&&... args) {
                         std::forward<decltype(inner_args)>(inner_args))...);
               },
               std::forward<decltype(arg)>(arg));
+        } else if constexpr (is_std_vector_v<decltype(arg)>) {
+          std::vector<decltype(conditional_copy_and_promote<Filter, PromotedType,
+                                                 CopyType>(arg[0]))> ret;
+          for (std::size_t i = 0; i < arg.size(); ++i) {
+            ret.push_back(conditional_copy_and_promote<Filter, PromotedType,
+                                                       CopyType>(arg[i]));
+          }
+          return ret;
         } else {
           if constexpr (CopyType == COPY_TYPE::DEEP) {
             return stan::math::eval(promote_scalar<PromotedType>(

stan/math/mix/functor/laplace_marginal_density.hpp

@@ -296,9 +296,7 @@ inline void set_zero_adjoint(Output&& output) {
           } else if constexpr (is_stan_scalar_v<output_i_t>) {
             output_i.adj() = 0;
           } else {
-            static_assert(1,
-                          "set_zero_adjoint missed!!! This is an internal "
-                          "error please report an issue on the Stan github");
+            static_assert(1, "INTERNAL ERROR:(laplace_marginal_lpdf) set_zero_adjoints was not able to deduce the actiopns needed for the given type.");
           }
         },
         std::forward<Output>(output));
@@ -331,7 +329,7 @@ inline void collect_adjoints(Output& output, Input1&& precalc) {
             precalc_i.adj() = 0;
           }
         } else {
-          static_assert(1, "We missed!!!");
+          static_assert(1, "INTERNAL ERROR:(laplace_marginal_lpdf) collect_adjoints was not able to deduce the actiopns needed for the given type.");
         }
       },
       std::forward<Output>(output), std::forward<Input1>(precalc));
@@ -769,9 +767,10 @@ template <typename Output, typename Input1>
 inline void collect_adjoints(Output&& output, const vari* ret,
                              Input1&& precalc) {
   if constexpr (is_tuple_v<Output>) {
-    static_assert(1,
+    static_assert(1,"INTERNAL ERROR:(laplace_marginal_lpdf)"
                   "Accumulate Adjoints called on a tuple, but tuples cannot be "
-                  "on the reverse mode stack!");
+                  "on the reverse mode stack!"
+                  "This is an internal error, please report it to the stan github as an issue.");
   } else if constexpr (is_std_vector_v<Output>) {
     if constexpr (!is_var_v<value_type_t<Output>>) {
       const auto output_size = output.size();
@@ -809,10 +808,7 @@ inline void collect_adjoints(Output&& output, Input1&& precalc) {
         } else if constexpr (is_stan_scalar_v<output_i_t>) {
           output_i += precalc_i;
         } else {
-          static_assert(1,
-                        "collect_adjoints was given an unexpected type! This "
-                        "is an internal bug. Please file an issue on Stan's "
-                        "github repository.");
+          static_assert(1, "INTERNAL ERROR:(laplace_marginal_lpdf) collect_adjoints was not able to deduce the actiopns needed for the given type.");
         }
       },
       std::forward<Output>(output), std::forward<Input1>(precalc));
@@ -838,17 +834,12 @@ inline void copy_compute_s2(Output&& output, Input1&& precalc) {
         } else if constexpr (is_stan_scalar_v<output_i_t>) {
           output_i += (0.5 * precalc_i.adj());
         } else {
-          static_assert(1, "We missed!!!");
+          static_assert(1, "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<Input1>(precalc));
 }
 
-template <typename T>
-static constexpr bool is_dbl_nothrow_constructible_v
-    = std::is_nothrow_constructible<
-        promote_scalar_t<double, std::decay_t<T>>>::value;
-
 template <typename Output>
 inline constexpr auto make_zero(Output&& output) {
   if constexpr (is_tuple_v<Output>) {
@@ -857,7 +848,7 @@ inline constexpr auto make_zero(Output&& output) {
   } else if constexpr (is_std_vector_v<Output>) {
     if constexpr (!is_var_v<value_type_t<Output>>) {
       const auto output_size = output.size();
-      arena_t<promote_scalar_t<double, Output>> ret;
+      arena_t<std::vector<decltype(make_zero(output[0]))>> ret;
       ret.reserve(output_size);
       for (Eigen::Index i = 0; i < output_size; ++i) {
         ret.push_back(make_zero(output[i]));
@@ -897,10 +888,11 @@ inline void print_adjoint(Output&& output) {
   } else if constexpr (is_stan_scalar_v<Output>) {
     std::cout << "adj: " << output.adj() << std::endl;
   } else {
-    static_assert(1, "print missed!!!");
+          static_assert(1, "INTERNAL ERROR:(laplace_marginal_lpdf) print_adjoint was not able to deduce the actiopns needed for the given type.");
   }
 }
 
+
 template <typename Arg, typename Precalc>
 inline void laplace_tuple_collect_adjoints(var ret, Arg&& arg,
                                            Precalc&& precalc) {
@@ -912,6 +904,10 @@ inline void laplace_tuple_collect_adjoints(var ret, Arg&& arg,
               std::forward<decltype(inner_precalc)>(inner_precalc));
         },
         std::forward<Arg>(arg), std::forward<Precalc>(precalc));
+  } else if constexpr (is_std_vector_containing_tuple_v<Arg>) {
+    for (std::size_t i = 0; i < arg.size(); ++i) {
+      laplace_tuple_collect_adjoints(ret, arg[i], precalc[i]);
+    }
   } else {
     reverse_pass_callback(
         [vi = ret.vi_, arg_arena = to_arena(std::forward<Arg>(arg)),
@@ -1108,13 +1104,7 @@ inline auto laplace_marginal_density(const LLFun& ll_fun, LLTupleArgs&& ll_args,
               return std::forward<decltype(arg)>(arg);
             },
             covar_args_copy);
-        //      std::cout << "\ncovar args: " << std::endl;
-        //      print_adjoint(covar_args_filter);
         collect_adjoints(covar_args_adj, covar_args_filter);
-        //      std::cout << "\n______________\n";
-        //      std::cout << "covar args adj: " << std::endl;
-        //      print_adjoint(covar_args_adj);
-        //      std::cout << "\n==============\n";
       }();
     }
     if constexpr (ll_args_contain_var) {
@@ -1133,13 +1123,13 @@ inline auto laplace_marginal_density(const LLFun& ll_fun, LLTupleArgs&& ll_args,
   }
   var ret(lmd);
   if constexpr (is_any_var_scalar_v<CovarTupleArgs>) {
-    auto covar_args_arena = stan::math::filter_map<is_any_var_scalar>(
-        [](auto&& arg) { return to_arena(arg); }, covar_args_refs);
-    laplace_tuple_collect_adjoints(ret, covar_args_arena, covar_args_adj);
+    auto covar_args_filter = stan::math::filter_map<is_any_var_scalar>(
+        [](auto&& arg) -> decltype(auto) { return arg; }, covar_args_refs);
+    laplace_tuple_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) { return to_arena(arg); }, ll_args_refs);
+        [](auto&& arg) -> decltype(auto) { return arg; }, ll_args_refs);
     laplace_tuple_collect_adjoints(ret, ll_args_filter, partial_parm);
   }
   return ret;

stan/math/prim/fun/promote_scalar.hpp

@@ -10,103 +10,39 @@
 namespace stan {
 namespace math {
 
-/**
- * Promote a scalar to another scalar type
- *
- * @tparam PromotionScalar scalar type of output.
- * @tparam UnPromotedType input type. `UnPromotedType` must be constructible
- * from `PromotionScalar`
- * @param x input scalar to be promoted to `PromotionScalar` type
- */
-template <typename PromotionScalar, typename UnPromotedType,
-          require_constructible_t<PromotionScalar, UnPromotedType>* = nullptr,
-          require_not_same_t<PromotionScalar, UnPromotedType>* = nullptr,
-          require_all_not_tuple_t<PromotionScalar, UnPromotedType>* = nullptr>
-inline constexpr auto promote_scalar(UnPromotedType&& x) {
-  return PromotionScalar(std::forward<UnPromotedType>(x));
-}
-
-/**
- * No-op overload when promoting a type's scalar to the type it already has.
- *
- * @tparam PromotionScalar scalar type of output.
- * @tparam UnPromotedType input type. `UnPromotedType`'s `scalar_type` must be
- * equal to `PromotionScalar`
- * @param x input
- */
-template <
-    typename PromotionScalar, typename UnPromotedType,
-    require_same_t<PromotionScalar, scalar_type_t<UnPromotedType>>* = nullptr>
-inline constexpr auto promote_scalar(UnPromotedType&& x) noexcept {
-  return std::forward<UnPromotedType>(x);
-}
-
-/**
- * Promote the scalar type of an eigen matrix to the requested type.
- *
- * @tparam PromotionScalar scalar type of output.
- * @tparam UnPromotedType input type. The `PromotionScalar` type must be
- * constructible from `UnPromotedType`'s `scalar_type`
- * @param x input
- */
-template <typename PromotionScalar, typename UnPromotedType,
-          require_eigen_t<UnPromotedType>* = nullptr,
-          require_not_same_t<PromotionScalar,
-                             value_type_t<UnPromotedType>>* = nullptr>
-inline auto promote_scalar(UnPromotedType&& x) {
-  return x.template cast<PromotionScalar>();
-}
-
-// Forward decl for iterating over tuples used in std::vector<tuple>
-template <typename PromotionScalars, typename UnPromotedTypes,
-          require_all_tuple_t<PromotionScalars, UnPromotedTypes>* = nullptr,
-          require_not_same_t<PromotionScalars, UnPromotedTypes>* = nullptr>
-inline constexpr promote_scalar_t<PromotionScalars, UnPromotedTypes>
-promote_scalar(UnPromotedTypes&& x);
 
-/**
- * Promote the scalar type of an standard vector to the requested type.
- *
- * @tparam PromotionScalar scalar type of output.
- * @tparam UnPromotedType input type. The `PromotionScalar` type must be
- * constructible from `UnPromotedType`'s `scalar_type`
- * @param x input
- */
-template <typename PromotionScalar, typename UnPromotedType,
-          require_std_vector_t<UnPromotedType>* = nullptr,
-          require_not_same_t<PromotionScalar,
-                             scalar_type_t<UnPromotedType>>* = nullptr>
-inline auto promote_scalar(UnPromotedType&& x) {
-  const auto x_size = x.size();
-  promote_scalar_t<PromotionScalar, UnPromotedType> ret(x_size);
-  for (size_t i = 0; i < x_size; ++i) {
-    ret[i] = promote_scalar<PromotionScalar>(x[i]);
-  }
-  return ret;
-}
-
-/**
- * Promote the scalar type of a tuples elements to the requested types.
- *
- * @tparam PromotionScalars A tuple of scalar types that is the same size as the
- * tuple of `UnPromotedTypes`.
- * @tparam UnPromotedTypes tuple input. Each `PromotionScalars` element must be
- * constructible from it's associated element of `UnPromotedTypes` `scalar_type`
- * @param x input
- */
-template <typename PromotionScalars, typename UnPromotedTypes,
-          require_all_tuple_t<PromotionScalars, UnPromotedTypes>*,
-          require_not_same_t<PromotionScalars, UnPromotedTypes>*>
-inline constexpr promote_scalar_t<PromotionScalars, UnPromotedTypes>
-promote_scalar(UnPromotedTypes&& x) {
-  return index_apply<std::tuple_size<std::decay_t<UnPromotedTypes>>::value>(
+template <typename PromotionScalars, typename UnPromotedTypes>
+inline constexpr auto promote_scalar(UnPromotedTypes&& x) {
+  if constexpr (std::is_same_v<PromotionScalars, scalar_type_t<UnPromotedTypes>>) {
+    return std::forward<UnPromotedTypes>(x);
+  } else if constexpr (is_tuple_v<PromotionScalars> && is_tuple_v<UnPromotedTypes>) {
+    return index_apply<std::tuple_size<std::decay_t<UnPromotedTypes>>::value>(
       [&x](auto... Is) {
         return std::make_tuple(
             promote_scalar<std::decay_t<decltype(std::get<Is>(
                 std::declval<PromotionScalars>()))>>(std::get<Is>(x))...);
       });
+  } else if constexpr (is_tuple_v<UnPromotedTypes>) {
+    return stan::math::apply([](auto&&... args) {
+      return std::make_tuple(promote_scalar<PromotionScalars>(std::forward<decltype(args)>(args))...);
+    }, std::forward<UnPromotedTypes>(x));
+  } else if constexpr (is_std_vector_v<UnPromotedTypes>) {
+    const auto x_size = x.size();
+    promote_scalar_t<PromotionScalars, UnPromotedTypes> ret(x_size);
+    for (size_t i = 0; i < x_size; ++i) {
+      ret[i] = promote_scalar<PromotionScalars>(x[i]);
+    }
+    return ret;
+  } else if constexpr (is_eigen_v<UnPromotedTypes>) {
+    return std::forward<UnPromotedTypes>(x).template cast<PromotionScalars>();
+  } else if constexpr (is_stan_scalar_v<UnPromotedTypes>) {
+    return PromotionScalars(std::forward<UnPromotedTypes>(x));
+  } else {
+    static_assert(1, "Missed type in promote_scalar!");
+  }
 }
 
+
 }  // namespace math
 }  // namespace stan