Merge commit '3a196d410415ee2cc56c0e51ec73a2e1970a08a4' into HEAD

Author: yashikno

.github/ISSUE_TEMPLATE.md

@@ -25,4 +25,4 @@ If this is a **feature request**, show what you expect to happen if the feature
 
 
 #### Current Version:
-v5.0.0
+v5.1.0

doxygen/doxygen.cfg

@@ -48,7 +48,7 @@ PROJECT_NAME           = "Stan Math Library"
 # could be handy for archiving the generated documentation or if some version
 # control system is used.
 
-PROJECT_NUMBER         = 5.0.0
+PROJECT_NUMBER         = 5.1.0
 
 # Using the PROJECT_BRIEF tag one can provide an optional one line description
 # for a project that appears at the top of each page and should give viewer a

stan/math/mix/functor/laplace_likelihood.hpp

@@ -226,8 +226,6 @@ inline auto compute_s2(F&& f, Theta&& theta, AMat&& A,
   Matrix<fvar<fvar<var>>, Dynamic, 1> theta_ffvar(theta_size);
   auto shallow_copy_args
       = shallow_copy_vargs<fvar<fvar<var>>>(std::forward_as_tuple(args...));
-  // build a “row” index 0,1,2,…,total-1
-  Eigen::Index total = n_blocks * hessian_block_size;
   for (Eigen::Index i = 0; i < hessian_block_size; ++i) {
     nested_rev_autodiff nested;
     v.setZero();

stan/math/mix/functor/laplace_marginal_density.hpp

@@ -2,7 +2,6 @@
 #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>
@@ -315,7 +314,9 @@ inline void set_zero_adjoint(Output&& output) {
             static_assert(
                 sizeof(std::decay_t<output_i_t>*) == 0,
                 "INTERNAL ERROR:(laplace_marginal_lpdf) set_zero_adjoints was "
-                "not able to deduce the actions needed for the given type.");
+                "not able to deduce the actions needed for the given type. "
+                "This is an internal error, please report it: "
+                "https://github.com/stan-dev/math/issues");
           }
         },
         std::forward<Output>(output));
@@ -360,7 +361,9 @@ inline void collect_adjoints(Output& output, Input&& input) {
           static_assert(
               sizeof(std::decay_t<output_i_t>*) == 0,
               "INTERNAL ERROR:(laplace_marginal_lpdf) set_zero_adjoints was "
-              "not able to deduce the actions needed for the given type.");
+              "not able to deduce the actions needed for the given type. "
+              "This is an internal error, please report it: "
+              "https://github.com/stan-dev/math/issues");
         }
       },
       std::forward<Output>(output), std::forward<Input>(input));
@@ -497,7 +500,7 @@ inline auto laplace_marginal_density_est(LLFun&& ll_fun, LLTupleArgs&& ll_args,
   };
   auto ll_args_vals = value_of(ll_args);
   const Eigen::Index theta_size = theta_0.size();
-  std::decay_t<ThetaVec> theta = theta_0;
+  Eigen::VectorXd theta = std::forward<ThetaVec>(theta_0);
   double objective_old = std::numeric_limits<double>::lowest();
   double objective_new = std::numeric_limits<double>::lowest() + 1;
   Eigen::VectorXd a_prev = Eigen::VectorXd::Zero(theta_size);
@@ -814,7 +817,9 @@ inline void collect_adjoints(Output&& output, Input&& input) {
           static_assert(
               sizeof(std::decay_t<output_i_t>*) == 0,
               "INTERNAL ERROR:(laplace_marginal_lpdf) set_zero_adjoints was "
-              "not able to deduce the actions needed for the given type.");
+              "not able to deduce the actions needed for the given type. "
+              "This is an internal error, please report it: "
+              "https://github.com/stan-dev/math/issues");
         }
       },
       std::forward<Output>(output), std::forward<Input>(input));
@@ -864,7 +869,9 @@ inline void copy_compute_s2(Output&& output, Input&& input) {
           static_assert(
               sizeof(std::decay_t<output_i_t>*) == 0,
               "INTERNAL ERROR:(laplace_marginal_lpdf) set_zero_adjoints was "
-              "not able to deduce the actions needed for the given type.");
+              "not able to deduce the actions needed for the given type. "
+              "This is an internal error, please report it: "
+              "https://github.com/stan-dev/math/issues");
         }
       },
       std::forward<Output>(output), std::forward<Input>(input));
@@ -921,11 +928,11 @@ template <typename Output, typename Input>
 inline void collect_adjoints(Output&& output, const vari* ret, Input&& input) {
   if constexpr (is_tuple_v<Output>) {
     static_assert(sizeof(std::decay_t<Output>*) == 0,
-                  "INTERNAL ERROR:(laplace_marginal_lpdf)"
+                  "INTERNAL ERROR:(laplace_marginal_lpdf) "
                   "Accumulate Adjoints called on a tuple, but tuples cannot be "
-                  "on the reverse mode stack!"
-                  "This is an internal error, please report it to the stan "
-                  "github as an issue.");
+                  "on the reverse mode stack! "
+                  "This is an internal error, please report it: "
+                  "https://github.com/stan-dev/math/issues");
   } else if constexpr (is_std_vector_v<Output>) {
     if constexpr (!is_var_v<value_type_t<Output>>) {
       const auto output_size = output.size();
@@ -1032,7 +1039,7 @@ inline auto laplace_marginal_density(const LLFun& ll_fun, LLTupleArgs&& ll_args,
     // Solver 3
     arena_t<Eigen::MatrixXd> LU_solve_covariance;
     // Solver 1, 2, 3
-    arena_t<promote_scalar_t<double, std::decay_t<ThetaVec>>> s2(
+    arena_t<promote_scalar_t<double, plain_type_t<std::decay_t<ThetaVec>>>> s2(
         theta_0.size());
     // Make one hard copy here
     using laplace_likelihood::internal::conditional_copy_and_promote;

stan/math/prim/fun/cholesky_decompose.hpp

@@ -28,15 +28,11 @@ namespace math {
  */
 template <typename EigMat, require_eigen_t<EigMat>* = nullptr,
           require_not_eigen_vt<is_var, EigMat>* = nullptr>
-inline Eigen::Matrix<value_type_t<EigMat>, EigMat::RowsAtCompileTime,
-                     EigMat::ColsAtCompileTime>
-cholesky_decompose(const EigMat& m) {
-  const eval_return_type_t<EigMat>& m_eval = m.eval();
+inline plain_type_t<EigMat> cholesky_decompose(const EigMat& m) {
+  auto&& m_eval = to_ref(m);
   check_symmetric("cholesky_decompose", "m", m_eval);
   check_not_nan("cholesky_decompose", "m", m_eval);
-  Eigen::LLT<Eigen::Matrix<value_type_t<EigMat>, EigMat::RowsAtCompileTime,
-                           EigMat::ColsAtCompileTime>>
-      llt = m_eval.llt();
+  Eigen::LLT<plain_type_t<EigMat>> llt = m_eval.llt();
   check_pos_definite("cholesky_decompose", "m", llt);
   return llt.matrixL();
 }

stan/math/prim/fun/promote_scalar.hpp

@@ -3,7 +3,6 @@
 
 #include <stan/math/prim/fun/Eigen.hpp>
 #include <stan/math/prim/functor/apply.hpp>
-#include <test/unit/pretty_print_types.hpp>
 #include <stan/math/prim/meta.hpp>
 #include <vector>
 #include <tuple>
@@ -45,9 +44,11 @@ inline constexpr auto promote_scalar(UnPromotedTypes&& x) {
   } else if constexpr (is_stan_scalar_v<UnPromotedTypes>) {
     return PromotionScalars(std::forward<UnPromotedTypes>(x));
   } else {
-    throw std::domain_error(
-        "promote_scalar: "
-        "Unrecognized type for promotion");
+    static_assert(sizeof(std::decay_t<UnPromotedTypes>*) == 0,
+                  "INTERNAL ERROR:(promote_scalar) "
+                  "Unrecognized type for promotion. "
+                  "This is an internal error, please report it: "
+                  "https://github.com/stan-dev/math/issues");
   }
 }
 

stan/math/prim/meta/forward_as.hpp

@@ -54,12 +54,38 @@ inline T_actual&& forward_as(T_actual&& a) {  // NOLINT
  * @return nothing, this always throws
  * @throw always throws std::runtime_error
  */
+template <
+    typename T_desired, typename T_actual,
+    require_any_not_eigen_t<T_desired, T_actual>* = nullptr,
+    typename = std::enable_if_t<
+        !std::is_same<std::decay<T_actual>, std::decay<T_desired>>::value
+        && !(std::is_floating_point_v<std::decay_t<
+                 T_desired>> && std::is_integral_v<std::decay_t<T_actual>>)>>
+inline T_desired forward_as(const T_actual& a) {
+  throw std::runtime_error("Wrong type assumed! Please file a bug report.");
+}
+
+/** \ingroup type_trait
+ * Assume which type we get. If actual type is not convertible to assumed type
+ * or in case of eigen types compile time rows and columns are not the same and
+ * desired sizes are not dynamic this has return type of \c T_desired, but it
+ * only throws. This version should only be used where it is optimized away so
+ * the throw should never happen.
+ *
+ * This handles the edge case where both types are simple arithmetic types
+ * and we would like to just convert one to another.
+ *
+ * @tparam T_desired type of output we need to avoid compile time errors
+ * @tparam T_actual actual type of the argument
+ * @param a input value
+ * @return a
+ */
 template <typename T_desired, typename T_actual,
           typename = std::enable_if_t<
-              !std::is_same<std::decay<T_actual>, std::decay<T_desired>>::value
-              && (!is_eigen<T_desired>::value || !is_eigen<T_actual>::value)>>
+              std::is_floating_point_v<std::decay_t<
+                  T_desired>> && std::is_integral_v<std::decay_t<T_actual>>>>
 inline T_desired forward_as(const T_actual& a) {
-  throw std::runtime_error("Wrong type assumed! Please file a bug report.");
+  return static_cast<T_desired>(a);
 }
 
 /** \ingroup type_trait

stan/math/version.hpp

@@ -12,7 +12,7 @@
 #endif
 
 #define STAN_MATH_MAJOR 5
-#define STAN_MATH_MINOR 0
+#define STAN_MATH_MINOR 1
 #define STAN_MATH_PATCH 0
 
 namespace stan {