adds unary functions for var<Matrix>

stan/math/prim/core/complex_base.hpp

@@ -204,7 +204,8 @@ class complex_base {
   template <typename U>
   complex_type& operator/=(const std::complex<U>& other) {
     using stan::math::square;
-    value_type sum_sq_im = square(other.real()) + square(other.imag());
+    value_type sum_sq_im
+        = (other.real() * other.real()) + (other.imag() * other.imag());
     value_type re_temp = (re_ * other.real() + im_ * other.imag()) / sum_sq_im;
     im_ = (im_ * other.real() - re_ * other.imag()) / sum_sq_im;
     re_ = re_temp;

stan/math/prim/fun/as_array_or_scalar.hpp

@@ -20,6 +20,18 @@ inline T as_array_or_scalar(T&& v) {
   return std::forward<T>(v);
 }
 
+/**
+ * Returns a reference to rvalue specified input value.
+ *
+ * @tparam T Type of element.
+ * @param v Specified value.
+ * @return Same value.
+ */
+template <typename T, require_stan_scalar_t<T>* = nullptr>
+inline T& as_array_or_scalar(T& v) {
+  return v;
+}
+
 /**
  * Returns specified input value.
  *

stan/math/prim/fun/cos.hpp

@@ -13,6 +13,16 @@
 namespace stan {
 namespace math {
 
+/**
+ * Arithmetic version of `cos()`
+ * @tparam T An `Arithmetic` type.
+ * @param x Arithmetic scalar.
+ */
+template <typename T, require_arithmetic_t<T>* = nullptr>
+inline auto cos(T x) {
+  return std::cos(x);
+}
+
 /**
  * Structure to wrap `cos()` so it can be vectorized.
  *
@@ -23,7 +33,6 @@ namespace math {
 struct cos_fun {
   template <typename T>
   static inline T fun(const T& x) {
-    using std::cos;
     return cos(x);
   }
 };
@@ -38,6 +47,7 @@ struct cos_fun {
  */
 template <typename Container,
           require_not_container_st<std::is_arithmetic, Container>* = nullptr,
+          require_not_stan_scalar_t<Container>* = nullptr,
           require_not_var_matrix_t<Container>* = nullptr,
           require_all_not_nonscalar_prim_or_rev_kernel_expression_t<
               Container>* = nullptr>

stan/math/prim/fun/divide.hpp

@@ -1,9 +1,10 @@
 #ifndef STAN_MATH_PRIM_FUN_DIVIDE_HPP
 #define STAN_MATH_PRIM_FUN_DIVIDE_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/as_array_or_scalar.hpp>
 #include <cstddef>
 #include <cstdlib>
 #include <type_traits>
@@ -40,26 +41,10 @@ inline int divide(int x, int y) {
  * @param[in] c specified scalar
  * @return matrix divided by the scalar
  */
-template <typename Mat, typename Scal, typename = require_eigen_t<Mat>,
-          require_stan_scalar_t<Scal>* = nullptr,
-          require_all_not_var_t<scalar_type_t<Mat>, Scal>* = nullptr>
-inline auto divide(const Mat& m, Scal c) {
-  return m / c;
-}
-
-/**
- * Return matrix divided by matrix.
- *
- * @tparam Mat1 type of the matrix or expression
- * @tparam Mat2 type of the matrix or expression
- * @param[in] m specified matrix or expression
- * @param[in] c specified matrix or expression
- * @return matrix divided elementwise by `c`
- */
-template <typename Mat1, typename Mat2,
-          require_all_eigen_t<Mat1, Mat2>* = nullptr>
-inline auto divide(const Mat1& m, const Mat2& c) {
-  return (m.array() / c.array()).matrix();
+template <typename T1, typename T2, require_any_eigen_t<T1, T2>* = nullptr,
+          require_all_not_st_var<T1, T2>* = nullptr>
+inline auto divide(const T1& m, const T2& c) {
+  return (as_array_or_scalar(m) / as_array_or_scalar(c)).matrix();
 }
 
 }  // namespace math

stan/math/prim/fun/inv_cloglog.hpp

@@ -73,6 +73,7 @@ struct inv_cloglog_fun {
  */
 template <typename Container,
           require_not_container_st<std::is_arithmetic, Container>* = nullptr,
+          require_not_var_matrix_t<Container>* = nullptr,
           require_all_not_nonscalar_prim_or_rev_kernel_expression_t<
               Container>* = nullptr>
 inline auto inv_cloglog(const Container& x) {

stan/math/prim/fun/inv_sqrt.hpp

@@ -12,6 +12,11 @@
 namespace stan {
 namespace math {
 
+template <typename T, require_stan_scalar_t<T>* = nullptr>
+inline auto inv_sqrt(T x) {
+  using std::sqrt;
+  return inv(sqrt(x));
+}
 /**
  * Structure to wrap `1 / sqrt(x)` so that it can be vectorized.
  *
@@ -22,8 +27,7 @@ namespace math {
 struct inv_sqrt_fun {
   template <typename T>
   static inline T fun(const T& x) {
-    using std::sqrt;
-    return inv(sqrt(x));
+    return inv_sqrt(x);
   }
 };
 
@@ -37,6 +41,8 @@ struct inv_sqrt_fun {
  */
 template <typename Container,
           require_not_container_st<std::is_arithmetic, Container>* = nullptr,
+          require_not_var_matrix_t<Container>* = nullptr,
+          require_not_stan_scalar_t<Container>* = nullptr,
           require_all_not_nonscalar_prim_or_rev_kernel_expression_t<
               Container>* = nullptr>
 inline auto inv_sqrt(const Container& x) {
@@ -51,7 +57,7 @@ inline auto inv_sqrt(const Container& x) {
  * @param x Container
  * @return inverse square root each variable in the container.
  */
-template <typename Container,
+template <typename Container, require_not_var_matrix_t<Container>* = nullptr,
           require_container_st<std::is_arithmetic, Container>* = nullptr>
 inline auto inv_sqrt(const Container& x) {
   return apply_vector_unary<Container>::apply(

stan/math/prim/fun/lambert_w.hpp

@@ -78,7 +78,8 @@ struct lambert_wm1_fun {
  * @return value of the W0 branch of the Lambert W function for each value in x
  * @throw std::domain_error if x is less than or equal to `-e^(-1)`
  */
-template <typename T, require_not_stan_scalar_t<T>* = nullptr>
+template <typename T, require_not_stan_scalar_t<T>* = nullptr,
+          require_not_var_matrix_t<T>* = nullptr>
 inline auto lambert_w0(const T& x) {
   return apply_scalar_unary<internal::lambert_w0_fun, T>::apply(x);
 }
@@ -92,7 +93,8 @@ inline auto lambert_w0(const T& x) {
  * @throw std::domain_error if x is less than or equal to `-e^(-1)` or greater
  * than or equal to 0
  */
-template <typename T, require_not_stan_scalar_t<T>* = nullptr>
+template <typename T, require_not_stan_scalar_t<T>* = nullptr,
+          require_not_var_matrix_t<T>* = nullptr>
 inline auto lambert_wm1(const T& x) {
   return apply_scalar_unary<internal::lambert_wm1_fun, T>::apply(x);
 }

stan/math/prim/fun/lgamma.hpp

@@ -114,7 +114,7 @@ struct lgamma_fun {
  *         applied to each value in x.
  * @throw std::domain_error if any value is a negative integer or 0.
  */
-template <typename T,
+template <typename T, require_not_var_matrix_t<T>* = nullptr,
           require_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr>
 inline auto lgamma(const T& x) {
   return apply_scalar_unary<lgamma_fun, T>::apply(x);

stan/math/prim/fun/log10.hpp

@@ -35,7 +35,7 @@ struct log10_fun {
  * @return Log base-10 applied to each value in x.
  */
 template <
-    typename Container,
+    typename Container, require_not_var_matrix_t<Container>* = nullptr,
     require_not_container_st<std::is_arithmetic, Container>* = nullptr,
     require_not_nonscalar_prim_or_rev_kernel_expression_t<Container>* = nullptr>
 inline auto log10(const Container& x) {

stan/math/prim/fun/log1m_exp.hpp

@@ -77,8 +77,9 @@ struct log1m_exp_fun {
  * @param x container
  * @return Natural log of (1 - exp()) 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_not_var_matrix_t<T>* = nullptr,
+    require_all_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr>
 inline auto log1m_exp(const T& x) {
   return apply_scalar_unary<log1m_exp_fun, T>::apply(x);
 }

stan/math/prim/fun/log1m_inv_logit.hpp

@@ -80,7 +80,7 @@ struct log1m_inv_logit_fun {
  * @param x container
  * @return Elementwise log1m_inv_logit of members of container.
  */
-template <typename T,
+template <typename T, require_not_var_matrix_t<T>* = nullptr,
           require_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr>
 inline typename apply_scalar_unary<log1m_inv_logit_fun, T>::return_t
 log1m_inv_logit(const T& x) {

stan/math/prim/fun/log2.hpp

@@ -44,7 +44,7 @@ struct log2_fun {
  * @param x container
  * @return elementwise log2 of container elements
  */
-template <typename T,
+template <typename T, require_not_var_matrix_t<T>* = nullptr,
           require_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr>
 inline auto log2(const T& x) {
   return apply_scalar_unary<log2_fun, T>::apply(x);

stan/math/prim/fun/logit.hpp

@@ -86,6 +86,7 @@ struct logit_fun {
 template <
     typename Container,
     require_not_container_st<std::is_arithmetic, Container>* = nullptr,
+    require_not_var_matrix_t<Container>* = nullptr,
     require_not_nonscalar_prim_or_rev_kernel_expression_t<Container>* = nullptr>
 inline auto logit(const Container& x) {
   return apply_scalar_unary<logit_fun, Container>::apply(x);

stan/math/prim/fun/square.hpp

@@ -1,9 +1,8 @@
 #ifndef STAN_MATH_PRIM_FUN_SQUARE_HPP
 #define STAN_MATH_PRIM_FUN_SQUARE_HPP
 
-#include <stan/math/prim/meta.hpp>
 #include <stan/math/prim/fun/Eigen.hpp>
-#include <stan/math/prim/fun/square.hpp>
+#include <stan/math/prim/meta.hpp>
 #include <stan/math/prim/functor/apply_scalar_unary.hpp>
 #include <stan/math/prim/functor/apply_vector_unary.hpp>
 #include <cmath>
@@ -48,7 +47,7 @@ struct square_fun {
  * @return Each value in x squared.
  */
 template <
-    typename Container,
+    typename Container, require_not_stan_scalar_t<Container>* = nullptr,
     require_not_container_st<std::is_arithmetic, Container>* = nullptr,
     require_not_var_matrix_t<Container>* = nullptr,
     require_not_nonscalar_prim_or_rev_kernel_expression_t<Container>* = nullptr>

stan/math/prim/meta.hpp

@@ -215,6 +215,7 @@
 #include <stan/math/prim/meta/is_vector.hpp>
 #include <stan/math/prim/meta/is_vector_like.hpp>
 #include <stan/math/prim/meta/is_stan_scalar.hpp>
+#include <stan/math/prim/meta/is_stan_scalar_or_eigen.hpp>
 #include <stan/math/prim/meta/partials_return_type.hpp>
 #include <stan/math/prim/meta/partials_type.hpp>
 #include <stan/math/prim/meta/plain_type.hpp>

stan/math/prim/meta/is_stan_scalar_or_eigen.hpp

@@ -0,0 +1,30 @@
+#ifndef STAN_MATH_PRIM_META_IS_STAN_SCALAR_OR_EIGEN_HPP
+#define STAN_MATH_PRIM_META_IS_STAN_SCALAR_OR_EIGEN_HPP
+
+#include <stan/math/prim/meta/bool_constant.hpp>
+#include <stan/math/prim/meta/is_stan_scalar.hpp>
+#include <stan/math/prim/meta/is_eigen.hpp>
+#include <stan/math/prim/meta/scalar_type.hpp>
+#include <stan/math/prim/meta/conjunction.hpp>
+#include <stan/math/prim/meta/require_helpers.hpp>
+
+#include <type_traits>
+
+namespace stan {
+
+/** \ingroup type_trait
+ * Extends std::true_type if all the provided types are either a Stan Scalar
+ * type or a type inheriting from `EigenBase`.
+ */
+template <typename T>
+using is_stan_scalar_or_eigen
+    = bool_constant<is_stan_scalar<std::decay_t<T>>::value
+                    || is_eigen<std::decay_t<T>>::value>;
+
+STAN_ADD_REQUIRE_UNARY(stan_scalar_or_eigen, is_stan_scalar_or_eigen,
+                       require_stan_scalar_real);
+STAN_ADD_REQUIRE_UNARY_INNER(stan_scalar_or_eigen, is_stan_scalar_or_eigen,
+                             require_stan_scalar_real);
+
+}  // namespace stan
+#endif

stan/math/rev/core/operator_divide_equal.hpp

@@ -10,7 +10,7 @@ namespace math {
 template <typename T>
 inline var_value<T>& var_value<T, require_floating_point_t<T>>::operator/=(
     const var_value<T>& b) {
-  vi_ = new internal::divide_vv_vari(vi_, b.vi_);
+  vi_ = divide(*this, b).vi_;
   return *this;
 }
 
@@ -20,7 +20,24 @@ inline var_value<T>& var_value<T, require_floating_point_t<T>>::operator/=(
   if (b == 1.0) {
     return *this;
   }
-  vi_ = new internal::divide_vd_vari(vi_, b);
+  vi_ = divide(*this, b).vi_;
+  return *this;
+}
+
+template <typename T>
+inline var_value<T>& var_value<T, internal::require_matrix_var_value<T>>::
+operator/=(const var_value<T>& b) {
+  vi_ = divide(*this, b).vi_;
+  return *this;
+}
+
+template <typename T>
+inline var_value<T>& var_value<T, internal::require_matrix_var_value<T>>::
+operator/=(T b) {
+  if (b == 1.0) {
+    return *this;
+  }
+  vi_ = divide(*this, b).vi_;
   return *this;
 }