Adds var<mat> specializations for lower/upper bounds

stan/math/prim/err/check_less.hpp

@@ -7,73 +7,145 @@
 #include <stan/math/prim/fun/get.hpp>
 #include <stan/math/prim/fun/scalar_seq_view.hpp>
 #include <stan/math/prim/fun/size.hpp>
-#include <stan/math/prim/fun/to_ref.hpp>
+#include <stan/math/prim/fun/as_array_or_scalar.hpp>
 #include <string>
 
 namespace stan {
 namespace math {
 
-namespace internal {
-template <typename T_y, typename T_high, bool is_vec>
-struct less {
-  static void check(const char* function, const char* name, const T_y& y,
-                    const T_high& high) {
-    scalar_seq_view<T_high> high_vec(high);
-    for (size_t n = 0; n < stan::math::size(high); n++) {
-      if (!(y < high_vec[n])) {
+/**
+ * Check if <code>y</code> is strictly less than <code>high</code>.
+ * This function is vectorized and will check each element of
+ * <code>y</code> against each element of <code>high</code>.
+ * @tparam T_y Type of y
+ * @tparam T_high Type of upper bound
+ * @param function Function name (for error messages)
+ * @param name Variable name (for error messages)
+ * @param y Variable to check
+ * @param high Upper bound
+ * @throw <code>domain_error</code> if y is not less than low
+ *   or if any element of y or high is NaN.
+ */
+template <typename T_y, typename T_high,
+          require_all_stan_scalar_t<T_y, T_high>* = nullptr>
+inline void check_less(const char* function, const char* name, const T_y& y,
+                       const T_high& high) {
+  if (!(y < high)) {
+    [&]() STAN_COLD_PATH {
+      std::stringstream msg;
+      msg << ", but must be less than ";
+      msg << high;
+      std::string msg_str(msg.str());
+      throw_domain_error(function, name, y, "is ", msg_str.c_str());
+    }();
+  }
+}
+
+/**
+ * Check if <code>y</code> is strictly less than <code>high</code>.
+ * This function is vectorized and will check each element of
+ * <code>y</code> against each element of <code>high</code>.
+ * @tparam T_y A container type
+ * @tparam T_high A container type
+ * @param function Function name (for error messages)
+ * @param name Variable name (for error messages)
+ * @param y Variable to check
+ * @param high Upper bound
+ * @throw <code>domain_error</code> if y is not less than low
+ *   or if any element of y or high is NaN.
+ */
+template <typename T_y, typename T_high,
+          require_all_container_t<T_y, T_high>* = nullptr>
+inline void check_less(const char* function, const char* name, const T_y& y,
+                       const T_high& high) {
+  const auto& high_ref = as_array_or_scalar(high);
+  const auto& y_ref = as_array_or_scalar(y);
+  Eigen::Index n = 0;
+  for (Eigen::Index j = 0; j < y_ref.cols(); ++j) {
+    for (Eigen::Index i = 0; i < y_ref.rows(); ++i) {
+      if (!(y_ref.coeff(i, j) < high_ref.coeff(i, j))) {
         [&]() STAN_COLD_PATH {
           std::stringstream msg;
           msg << ", but must be less than ";
-          msg << high_vec[n];
+          msg << high_ref.coeff(i, j);
           std::string msg_str(msg.str());
-          throw_domain_error(function, name, y, "is ", msg_str.c_str());
+          throw_domain_error_vec(function, name, y_ref.coeff(i, j), i + j,
+                                 "is ", msg_str.c_str());
         }();
       }
     }
   }
-};
+}
 
-template <typename T_y, typename T_high>
-struct less<T_y, T_high, true> {
-  static void check(const char* function, const char* name, const T_y& y,
-                    const T_high& high) {
-    scalar_seq_view<T_high> high_vec(high);
-    const auto& y_ref = to_ref(y);
-    for (size_t n = 0; n < stan::math::size(y_ref); n++) {
-      if (!(stan::get(y_ref, n) < high_vec[n])) {
+/**
+ * Check if <code>y</code> is strictly less than <code>high</code>.
+ * This function is vectorized and will check each element of
+ * <code>y</code> against each element of <code>high</code>.
+ * @tparam T_y A container type
+ * @tparam T_high A scalar type
+ * @param function Function name (for error messages)
+ * @param name Variable name (for error messages)
+ * @param y Variable to check
+ * @param high Upper bound
+ * @throw <code>domain_error</code> if y is not less than low
+ *   or if any element of y or high is NaN.
+ */
+template <typename T_y, typename T_high, require_container_t<T_y>* = nullptr,
+          require_stan_scalar_t<T_high>* = nullptr>
+inline void check_less(const char* function, const char* name, const T_y& y,
+                       const T_high& high) {
+  const auto& y_ref = as_array_or_scalar(y);
+  Eigen::Index n = 0;
+  for (Eigen::Index j = 0; j < y_ref.cols(); ++j) {
+    for (Eigen::Index i = 0; i < y_ref.rows(); ++i) {
+      if (!(y_ref.coeff(i, j) < high)) {
         [&]() STAN_COLD_PATH {
           std::stringstream msg;
           msg << ", but must be less than ";
-          msg << high_vec[n];
+          msg << high;
           std::string msg_str(msg.str());
-          throw_domain_error_vec(function, name, y_ref, n, "is ",
-                                 msg_str.c_str());
+          throw_domain_error_vec(function, name, y_ref.coeff(i, j), i + j,
+                                 "is ", msg_str.c_str());
         }();
       }
     }
   }
-};
-}  // namespace internal
+}
 
 /**
  * Check if <code>y</code> is strictly less than <code>high</code>.
  * This function is vectorized and will check each element of
  * <code>y</code> against each element of <code>high</code>.
- * @tparam T_y Type of y
- * @tparam T_high Type of upper bound
+ * @tparam T_y A container type
+ * @tparam T_high A scalar type
  * @param function Function name (for error messages)
  * @param name Variable name (for error messages)
  * @param y Variable to check
  * @param high Upper bound
  * @throw <code>domain_error</code> if y is not less than low
  *   or if any element of y or high is NaN.
  */
-template <typename T_y, typename T_high>
+template <typename T_y, typename T_high, require_container_t<T_high>* = nullptr,
+          require_stan_scalar_t<T_y>* = nullptr>
 inline void check_less(const char* function, const char* name, const T_y& y,
                        const T_high& high) {
-  internal::less<T_y, T_high, is_vector_like<T_y>::value>::check(function, name,
-                                                                 y, high);
+  const auto& high_ref = as_array_or_scalar(high);
+  Eigen::Index n = 0;
+  for (Eigen::Index j = 0; j < high_ref.cols(); ++j) {
+    for (Eigen::Index i = 0; i < high_ref.rows(); ++i) {
+      if (!(y < high_ref.coeff(i, j))) {
+        [&]() STAN_COLD_PATH {
+          std::stringstream msg;
+          msg << ", but must be less than ";
+          msg << high_ref(i, j);
+          std::string msg_str(msg.str());
+          throw_domain_error(function, name, y, "is ", msg_str.c_str());
+        }();
+      }
+    }
+  }
 }
+
 }  // namespace math
 }  // namespace stan
 #endif

stan/math/prim/fun/as_array_or_scalar.hpp

@@ -20,14 +20,27 @@ inline T as_array_or_scalar(T&& v) {
   return std::forward<T>(v);
 }
 
+/**
+ * Returns specified input value.
+ *
+ * @tparam T Type of element.
+ * @param v Specified value.
+ * @return Same value.
+ */
+template <typename T, require_eigen_array_t<T>* = nullptr>
+inline T as_array_or_scalar(T&& v) {
+  return std::forward<T>(v);
+}
+
 /**
  * Converts a matrix type to an array.
  *
  * @tparam T Type of \c Eigen \c Matrix or expression
  * @param v Specified \c Eigen \c Matrix or expression.
  * @return Matrix converted to an array.
  */
-template <typename T, require_eigen_t<T>* = nullptr>
+template <typename T, typename = require_eigen_t<T>,
+          require_not_eigen_array_t<T>* = nullptr>
 inline auto as_array_or_scalar(T&& v) {
   return make_holder([](auto& x) { return x.array(); }, std::forward<T>(v));
 }

stan/math/prim/fun/constants.hpp

@@ -29,22 +29,22 @@ inline double pi() { return boost::math::constants::pi<double>(); }
 /**
  * Smallest positive value.
  */
-const double EPSILON = std::numeric_limits<double>::epsilon();
+constexpr double EPSILON = std::numeric_limits<double>::epsilon();
 
 /**
  * Positive infinity.
  */
-const double INFTY = std::numeric_limits<double>::infinity();
+constexpr double INFTY = std::numeric_limits<double>::infinity();
 
 /**
  * Negative infinity.
  */
-const double NEGATIVE_INFTY = -INFTY;
+constexpr double NEGATIVE_INFTY = -INFTY;
 
 /**
  * (Quiet) not-a-number value.
  */
-const double NOT_A_NUMBER = std::numeric_limits<double>::quiet_NaN();
+constexpr double NOT_A_NUMBER = std::numeric_limits<double>::quiet_NaN();
 
 /**
  * Twice the value of \f$ \pi \f$,
@@ -182,29 +182,29 @@ const double POISSON_MAX_RATE = std::pow(2.0, 30);
  *
  * @return Positive infinity.
  */
-inline double positive_infinity() { return INFTY; }
+static constexpr inline double positive_infinity() { return INFTY; }
 
 /**
  * Return negative infinity.
  *
  * @return Negative infinity.
  */
-inline double negative_infinity() { return NEGATIVE_INFTY; }
+static constexpr inline double negative_infinity() { return NEGATIVE_INFTY; }
 
 /**
  * Return (quiet) not-a-number.
  *
  * @return Quiet not-a-number.
  */
-inline double not_a_number() { return NOT_A_NUMBER; }
+static constexpr inline double not_a_number() { return NOT_A_NUMBER; }
 
 /**
  * Returns the difference between 1.0 and the next value
  * representable.
  *
  * @return Minimum positive number.
  */
-inline double machine_precision() { return EPSILON; }
+static constexpr inline double machine_precision() { return EPSILON; }
 
 /**
  * Returns the natural logarithm of ten.

stan/math/prim/fun/elt_multiply.hpp

@@ -1,9 +1,10 @@
 #ifndef STAN_MATH_PRIM_FUN_ELT_MULTIPLY_HPP
 #define STAN_MATH_PRIM_FUN_ELT_MULTIPLY_HPP
 
+#include <stan/math/prim/fun/Eigen.hpp>
 #include <stan/math/prim/meta.hpp>
 #include <stan/math/prim/err.hpp>
-#include <stan/math/prim/fun/Eigen.hpp>
+#include <stan/math/prim/fun/multiply.hpp>
 
 namespace stan {
 namespace math {
@@ -44,6 +45,24 @@ auto elt_multiply(const Scalar1& a, const Scalar2& b) {
   return a * b;
 }
 
+/**
+ * Return specified matrix multiplied by specified scalar.
+ *
+ * One argument is a matrix and one is a scalar.
+ *
+ * @tparam T1 type of the first argument
+ * @tparam T2 type of the second argument
+ *
+ * @param A first argument
+ * @param B second argument
+ * @return product of matrix and scalar
+ */
+template <typename T1, typename T2, require_any_matrix_t<T1, T2>* = nullptr,
+          require_any_stan_scalar_t<T1, T2>* = nullptr>
+inline auto elt_multiply(const T1& A, const T2& B) {
+  return multiply(A, B);
+}
+
 }  // namespace math
 }  // namespace stan
 

stan/math/prim/fun/identity_constrain.hpp

@@ -13,13 +13,13 @@ namespace math {
  * <p>This method is effectively a no-op and is mainly useful as a
  * placeholder in auto-generated code.
  *
- * @tparam T Type of scalar.
- * @param[in] x free scalar
+ * @tparam T Any type.
+ * @param[in] x object
  * @return transformed input
  */
 template <typename T>
-inline T identity_constrain(const T& x) {
-  return x;
+inline auto identity_constrain(T&& x) {
+  return std::forward<T>(x);
 }
 
 /**
@@ -30,15 +30,15 @@ inline T identity_constrain(const T& x) {
  * <p>This method is effectively a no-op and mainly useful as a
  * placeholder in auto-generated code.
  *
- * @tparam T type of scalar
+ * @tparam T Any type
  * @tparam S type of log probability
- * @param[in] x scalar
+ * @param[in] x object
  * @param[in] lp log density reference
  * @return transformed input
  */
 template <typename T, typename S>
-inline T identity_constrain(const T& x, S& lp) {
-  return x;
+inline auto identity_constrain(T&& x, S& lp) {
+  return std::forward<T>(x);
 }
 
 }  // namespace math

stan/math/prim/fun/identity_free.hpp

@@ -18,8 +18,8 @@ namespace math {
  * @return value
  */
 template <typename T>
-inline T identity_free(const T& y) {
-  return y;
+inline auto identity_free(T&& y) {
+  return std::forward<T>(y);
 }
 
 }  // namespace math