Merge pull request #3191 from stan-dev/fix/3189-forward-as-int-workaround

Allow forward_as to convert integers to doubles

Author: WardBrian

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

test/unit/math/prim/meta/forward_as_test.cpp

@@ -9,5 +9,5 @@ TEST(MathMetaPrim, ForwardAsScalar) {
 
   EXPECT_NO_THROW(forward_as<int>(a) = 2);
   EXPECT_EQ(a, 2);
-  EXPECT_THROW(forward_as<double>(a), std::runtime_error);
+  EXPECT_FLOAT_EQ(forward_as<double>(a), 2.0);
 }

test/unit/math/rev/prob/normal_id_glm_lpdf_test.cpp

@@ -745,3 +745,23 @@ TEST(ProbDistributionsNormalIdGLM, glm_matches_normal_id_error_checking) {
   EXPECT_THROW(stan::math::normal_id_glm_lpdf(y, x, alpha, beta, sigmaw3),
                std::domain_error);
 }
+
+TEST(ProbDistributionsNormalIdGLM, glm_type_issue_3189) {
+  // regression test for https://github.com/stan-dev/math/issues/3189
+  using Eigen::Dynamic;
+  using Eigen::Matrix;
+  using stan::math::var;
+  int J = 3;
+  int K = 2;
+
+  Eigen::Matrix<double, -1, -1> x(J, K);
+  x << 1.0, 2.0, 3.0, 4.0, 5.0, 6.0;
+
+  Eigen::Matrix<stan::math::var, -1, 1> y(J);
+  y << 0.1, 0.2, 0.3;
+  Eigen::Matrix<stan::math::var, -1, 1> beta(K);
+  beta << 0.5, 0.6;
+
+  EXPECT_FLOAT_EQ(stan::math::normal_id_glm_lpdf<false>(y, x, 0, beta, 1).val(),
+                  -27.701815);
+}