Merge pull request #2461 from stan-dev/feature/unary-var-matrix

Adds simple vectorized functions for var<matrix>

Author: SteveBronder

stan/math/prim/fun/bessel_first_kind.hpp

@@ -51,7 +51,8 @@ inline T2 bessel_first_kind(int v, const T2 z) {
  * @param b Second input
  * @return Bessel first kind function applied to the two inputs.
  */
-template <typename T1, typename T2, require_any_container_t<T1, T2>* = nullptr>
+template <typename T1, typename T2, require_any_container_t<T1, T2>* = nullptr,
+          require_not_var_matrix_t<T2>* = nullptr>
 inline auto bessel_first_kind(const T1& a, const T2& b) {
   return apply_scalar_binary(a, b, [&](const auto& c, const auto& d) {
     return bessel_first_kind(c, d);

stan/math/prim/fun/beta.hpp

@@ -65,7 +65,8 @@ inline return_type_t<T1, T2> beta(const T1 a, const T2 b) {
  * @param b Second input
  * @return Beta function applied to the two inputs.
  */
-template <typename T1, typename T2, require_any_container_t<T1, T2>* = nullptr>
+template <typename T1, typename T2, require_any_container_t<T1, T2>* = nullptr,
+          require_all_not_var_matrix_t<T1, T2>* = nullptr>
 inline auto beta(const T1& a, const T2& b) {
   return apply_scalar_binary(
       a, b, [&](const auto& c, const auto& d) { return beta(c, d); });

stan/math/prim/fun/binary_log_loss.hpp

@@ -42,7 +42,8 @@ inline T binary_log_loss(int y, const T& y_hat) {
  * @param b Second input
  * @return Binary log loss function applied to the two inputs.
  */
-template <typename T1, typename T2, require_any_container_t<T1, T2>* = nullptr>
+template <typename T1, typename T2, require_any_container_t<T1, T2>* = nullptr,
+          require_not_var_matrix_t<T2>* = nullptr>
 inline auto binary_log_loss(const T1& a, const T2& b) {
   return apply_scalar_binary(a, b, [&](const auto& c, const auto& d) {
     return binary_log_loss(c, d);

stan/math/prim/fun/ceil.hpp

@@ -50,7 +50,8 @@ inline auto ceil(const Container& x) {
  * @return Least integer >= each value in x.
  */
 template <typename Container,
-          require_container_st<std::is_arithmetic, Container>* = nullptr>
+          require_container_st<std::is_arithmetic, Container>* = nullptr,
+          require_not_var_matrix_t<Container>* = nullptr>
 inline auto ceil(const Container& x) {
   return apply_vector_unary<Container>::apply(
       x, [](const auto& v) { return v.array().ceil(); });

stan/math/prim/fun/erf.hpp

@@ -31,8 +31,10 @@ struct erf_fun {
  * @param x container
  * @return Error function applied to each value in x.
  */
-template <typename T, require_all_not_nonscalar_prim_or_rev_kernel_expression_t<
-                          T>* = nullptr>
+template <
+    typename T,
+    require_all_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr,
+    require_not_var_matrix_t<T>* = nullptr>
 inline auto erf(const T& x) {
   return apply_scalar_unary<erf_fun, T>::apply(x);
 }

stan/math/prim/fun/erfc.hpp

@@ -32,8 +32,10 @@ struct erfc_fun {
  * @param x container
  * @return Complementary error function applied to each value in x.
  */
-template <typename T, require_all_not_nonscalar_prim_or_rev_kernel_expression_t<
-                          T>* = nullptr>
+template <
+    typename T,
+    require_all_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr,
+    require_not_var_matrix_t<T>* = nullptr>
 inline auto erfc(const T& x) {
   return apply_scalar_unary<erfc_fun, T>::apply(x);
 }

stan/math/prim/fun/exp2.hpp

@@ -35,8 +35,10 @@ struct exp2_fun {
  * @param x container
  * @return Elementwise exp2 of members of container.
  */
-template <typename T, require_all_not_nonscalar_prim_or_rev_kernel_expression_t<
-                          T>* = nullptr>
+template <
+    typename T,
+    require_all_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr,
+    require_not_var_matrix_t<T>* = nullptr>
 inline auto exp2(const T& x) {
   return apply_scalar_unary<exp2_fun, T>::apply(x);
 }

stan/math/prim/fun/expm1.hpp

@@ -32,8 +32,10 @@ struct expm1_fun {
  * @param x container
  * @return Natural exponential of each value in x minus one.
  */
-template <typename T, require_all_not_nonscalar_prim_or_rev_kernel_expression_t<
-                          T>* = nullptr>
+template <
+    typename T,
+    require_all_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr,
+    require_not_var_matrix_t<T>* = nullptr>
 inline auto expm1(const T& x) {
   return apply_scalar_unary<expm1_fun, T>::apply(x);
 }

stan/math/prim/fun/falling_factorial.hpp

@@ -62,7 +62,7 @@ namespace math {
  */
 template <typename T, require_arithmetic_t<T>* = nullptr>
 inline return_type_t<T> falling_factorial(const T& x, int n) {
-  static const char* function = "falling_factorial";
+  constexpr const char* function = "falling_factorial";
   check_not_nan(function, "first argument", x);
   check_nonnegative(function, "second argument", n);
   return boost::math::falling_factorial(x, n, boost_policy_t<>());
@@ -78,7 +78,8 @@ inline return_type_t<T> falling_factorial(const T& x, int n) {
  * @param b Second input
  * @return Falling factorial function applied to the two inputs.
  */
-template <typename T1, typename T2, require_any_container_t<T1, T2>* = nullptr>
+template <typename T1, typename T2, require_any_container_t<T1, T2>* = nullptr,
+          require_all_not_var_matrix_t<T1, T2>* = nullptr>
 inline auto falling_factorial(const T1& a, const T2& b) {
   return apply_scalar_binary(a, b, [&](const auto& c, const auto& d) {
     return falling_factorial(c, d);

stan/math/prim/fun/floor.hpp

@@ -36,7 +36,8 @@ struct floor_fun {
 template <typename Container,
           require_not_container_st<std::is_arithmetic, Container>* = nullptr,
           require_all_not_nonscalar_prim_or_rev_kernel_expression_t<
-              Container>* = nullptr>
+              Container>* = nullptr,
+          require_not_var_matrix_t<Container>* = nullptr>
 inline auto floor(const Container& x) {
   return apply_scalar_unary<floor_fun, Container>::apply(x);
 }
@@ -50,7 +51,8 @@ inline auto floor(const Container& x) {
  * @return Greatest integer <= each value in x.
  */
 template <typename Container,
-          require_container_st<std::is_arithmetic, Container>* = nullptr>
+          require_container_st<std::is_arithmetic, Container>* = nullptr,
+          require_not_var_matrix_t<Container>* = nullptr>
 inline auto floor(const Container& x) {
   return apply_vector_unary<Container>::apply(
       x, [](const auto& v) { return v.array().floor(); });