Merge pull request #1727 from andrjohns/feature/issue-1723-elem-vec

Eigen::Map and elementwise functions

Author: t4c1

stan/math/prim/fun/acos.hpp

@@ -27,25 +27,30 @@ struct acos_fun {
  * Returns the elementwise `acos()` of the input,
  * which may be a scalar or any Stan container of numeric scalars.
  *
- * @tparam T type of container
+ * @tparam Container type of container
  * @param x container
  * @return Arc cosine of each variable in the container, in radians.
  */
-template <typename T, typename = require_not_eigen_vt<std::is_arithmetic, T>>
-inline auto acos(const T& x) {
-  return apply_scalar_unary<acos_fun, T>::apply(x);
+template <
+    typename Container,
+    require_not_container_st<is_container, std::is_arithmetic, Container>...>
+inline auto acos(const Container& x) {
+  return apply_scalar_unary<acos_fun, Container>::apply(x);
 }
 
 /**
- * Version of `acos()` that accepts Eigen Matrix or matrix expressions.
- * @tparam Derived derived type of x
- * @param x Matrix or matrix expression
+ * Version of `acos()` that accepts std::vectors, Eigen Matrix/Array objects
+ *  or expressions, and containers of these.
+ *
+ * @tparam Container Type of x
+ * @param x Container
  * @return Arc cosine of each variable in the container, in radians.
  */
-template <typename Derived,
-          typename = require_eigen_vt<std::is_arithmetic, Derived>>
-inline auto acos(const Eigen::MatrixBase<Derived>& x) {
-  return x.derived().array().acos().matrix().eval();
+template <typename Container,
+          require_container_st<is_container, std::is_arithmetic, Container>...>
+inline auto acos(const Container& x) {
+  return apply_vector_unary<Container>::apply(
+      x, [](const auto& v) { return v.array().acos(); });
 }
 
 }  // namespace math

stan/math/prim/fun/asin.hpp

@@ -27,26 +27,30 @@ struct asin_fun {
  * Returns the elementwise `asin()` of the input,
  * which may be a scalar or any Stan container of numeric scalars.
  *
- * @tparam T type of container
+ * @tparam Container type of container
  * @param x container
  * @return Arcsine of each variable in the container, in radians.
  */
-template <typename T, typename = require_not_eigen_vt<std::is_arithmetic, T>>
-inline auto asin(const T& x) {
-  return apply_scalar_unary<asin_fun, T>::apply(x);
+template <
+    typename Container,
+    require_not_container_st<is_container, std::is_arithmetic, Container>...>
+inline auto asin(const Container& x) {
+  return apply_scalar_unary<asin_fun, Container>::apply(x);
 }
 
 /**
- * Version of `asin()` that accepts Eigen Matrix or matrix expressions.
+ * Version of `asin()` that accepts std::vectors, Eigen Matrix/Array objects,
+ *  or expressions, and containers of these.
  *
- * @tparam Derived derived type of x
- * @param x Matrix or matrix expression
+ * @tparam Container Type of x
+ * @param x Container
  * @return Arcsine of each variable in the container, in radians.
  */
-template <typename Derived,
-          typename = require_eigen_vt<std::is_arithmetic, Derived>>
-inline auto asin(const Eigen::MatrixBase<Derived>& x) {
-  return x.derived().array().asin().matrix().eval();
+template <typename Container,
+          require_container_st<is_container, std::is_arithmetic, Container>...>
+inline auto asin(const Container& x) {
+  return apply_vector_unary<Container>::apply(
+      x, [](const auto& v) { return v.array().asin(); });
 }
 
 }  // namespace math

stan/math/prim/fun/atan.hpp

@@ -27,26 +27,30 @@ struct atan_fun {
  * Returns the elementwise \c atan() of the input,
  * which may be a scalar or any Stan container of numeric scalars.
  *
- * @tparam T type of container
+ * @tparam Container type of container
  * @param x container
  * @return Arctan of each value in x, in radians.
  */
-template <typename T, typename = require_not_eigen_vt<std::is_arithmetic, T>>
-inline typename apply_scalar_unary<atan_fun, T>::return_t atan(const T& x) {
-  return apply_scalar_unary<atan_fun, T>::apply(x);
+template <
+    typename Container,
+    require_not_container_st<is_container, std::is_arithmetic, Container>...>
+inline auto atan(const Container& x) {
+  return apply_scalar_unary<atan_fun, Container>::apply(x);
 }
 
 /**
- * Version of atan() that accepts Eigen Matrix or matrix expressions.
+ * Version of atan() that accepts std::vectors, Eigen Matrix/Array objects,
+ *  or expressions, and containers of these.
  *
- * @tparam Derived derived type of x
- * @param x Matrix or matrix expression
+ * @tparam Container Type of x
+ * @param x Container
  * @return Elementwise atan of members of container.
  */
-template <typename Derived,
-          typename = require_eigen_vt<std::is_arithmetic, Derived>>
-inline auto atan(const Eigen::MatrixBase<Derived>& x) {
-  return x.derived().array().atan().matrix().eval();
+template <typename Container,
+          require_container_st<is_container, std::is_arithmetic, Container>...>
+inline auto atan(const Container& x) {
+  return apply_vector_unary<Container>::apply(
+      x, [](const auto& v) { return v.array().atan(); });
 }
 
 }  // namespace math

stan/math/prim/fun/ceil.hpp

@@ -27,26 +27,30 @@ struct ceil_fun {
  * Returns the elementwise `ceil()` of the input,
  * which may be a scalar or any Stan container of numeric scalars.
  *
- * @tparam T type of container
+ * @tparam Container type of container
  * @param x container
  * @return Least integer >= each value in x.
  */
-template <typename T, typename = require_not_eigen_vt<std::is_arithmetic, T>>
-inline auto ceil(const T& x) {
-  return apply_scalar_unary<ceil_fun, T>::apply(x);
+template <
+    typename Container,
+    require_not_container_st<is_container, std::is_arithmetic, Container>...>
+inline auto ceil(const Container& x) {
+  return apply_scalar_unary<ceil_fun, Container>::apply(x);
 }
 
 /**
- * Version of `ceil()` that accepts Eigen Matrix or matrix expressions.
+ * Version of `ceil()` that accepts std::vectors, Eigen Matrix/Array objects
+ *  or expressions, and containers of these.
  *
- * @tparam Derived derived type of x
- * @param x Matrix or matrix expression
+ * @tparam Container Type of x
+ * @param x Container
  * @return Least integer >= each value in x.
  */
-template <typename Derived,
-          typename = require_eigen_vt<std::is_arithmetic, Derived>>
-inline auto ceil(const Eigen::MatrixBase<Derived>& x) {
-  return x.derived().array().ceil().matrix().eval();
+template <typename Container,
+          require_container_st<is_container, std::is_arithmetic, Container>...>
+inline auto ceil(const Container& x) {
+  return apply_vector_unary<Container>::apply(
+      x, [](const auto& v) { return v.array().ceil(); });
 }
 
 }  // namespace math

stan/math/prim/fun/cos.hpp

@@ -27,26 +27,30 @@ struct cos_fun {
  * Returns the elementwise `cos()` of the input,
  * which may be a scalar or any Stan container of numeric scalars.
  *
- * @tparam T type of container
+ * @tparam Container type of container
  * @param x angles in radians
  * @return Cosine of each value in x.
  */
-template <typename T, typename = require_not_eigen_vt<std::is_arithmetic, T>>
-inline auto cos(const T& x) {
-  return apply_scalar_unary<cos_fun, T>::apply(x);
+template <
+    typename Container,
+    require_not_container_st<is_container, std::is_arithmetic, Container>...>
+inline auto cos(const Container& x) {
+  return apply_scalar_unary<cos_fun, Container>::apply(x);
 }
 
 /**
- * Version of `cos()` that accepts Eigen Matrix or matrix expressions.
+ * Version of `cos()` that accepts std::vectors, Eigen Matrix/Array objects
+ *  or expressions, and containers of these.
  *
- * @tparam Derived derived type of x
- * @param x Matrix or matrix expression
+ * @tparam Container Type of x
+ * @param x Container
  * @return Cosine of each value in x.
  */
-template <typename Derived,
-          typename = require_eigen_vt<std::is_arithmetic, Derived>>
-inline auto cos(const Eigen::MatrixBase<Derived>& x) {
-  return x.derived().array().cos().matrix().eval();
+template <typename Container,
+          require_container_st<is_container, std::is_arithmetic, Container>...>
+inline auto cos(const Container& x) {
+  return apply_vector_unary<Container>::apply(
+      x, [](const auto& v) { return v.array().cos(); });
 }
 
 }  // namespace math

stan/math/prim/fun/cosh.hpp

@@ -27,28 +27,31 @@ struct cosh_fun {
  * Returns the elementwise `cosh()` of the input,
  * which may be a scalar or any Stan container of numeric scalars.
  *
- * @tparam T type of container
+ * @tparam Container type of container
  * @param x angles in radians
  * @return Hyberbolic cosine of x.
  */
-template <typename T, typename = require_not_eigen_vt<std::is_arithmetic, T>>
-inline typename apply_scalar_unary<cosh_fun, T>::return_t cosh(const T& x) {
-  return apply_scalar_unary<cosh_fun, T>::apply(x);
+template <
+    typename Container,
+    require_not_container_st<is_container, std::is_arithmetic, Container>...>
+inline auto cosh(const Container& x) {
+  return apply_scalar_unary<cosh_fun, Container>::apply(x);
 }
 
 /**
- * Version of `cosh()` that accepts Eigen Matrix or matrix expressions.
+ * Version of `cosh()` that accepts std::vectors, Eigen Matrix/Array objects
+ *  or expressions, and containers of these.
  *
- * @tparam Derived derived type of x
- * @param x Matrix or matrix expression
+ * @tparam Container Type of x
+ * @param x Container
  * @return Hyberbolic cosine of x.
  */
-template <typename Derived,
-          typename = require_eigen_vt<std::is_arithmetic, Derived>>
-inline auto cosh(const Eigen::MatrixBase<Derived>& x) {
-  return x.derived().array().cosh().matrix().eval();
+template <typename Container,
+          require_container_st<is_container, std::is_arithmetic, Container>...>
+inline auto cosh(const Container& x) {
+  return apply_vector_unary<Container>::apply(
+      x, [](const auto& v) { return v.array().cosh(); });
 }
-
 }  // namespace math
 }  // namespace stan
 

stan/math/prim/fun/exp.hpp

@@ -7,7 +7,6 @@
 
 namespace stan {
 namespace math {
-
 /**
  * Structure to wrap `exp()` so that it can be
  * vectorized.
@@ -32,25 +31,30 @@ struct exp_fun {
  * which may be a scalar or any Stan container of numeric scalars.
  * The return type is the same as the argument type.
  *
- * @tparam T type of container
+ * @tparam Container type of container
  * @param[in] x container
  * @return Elementwise application of exponentiation to the argument.
  */
-template <typename T, typename = require_not_eigen_vt<std::is_arithmetic, T>>
-inline auto exp(const T& x) {
-  return apply_scalar_unary<exp_fun, T>::apply(x);
+template <
+    typename Container,
+    require_not_container_st<is_container, std::is_arithmetic, Container>...>
+inline auto exp(const Container& x) {
+  return apply_scalar_unary<exp_fun, Container>::apply(x);
 }
 
 /**
- * Version of `exp()` that accepts Eigen Matrix or matrix expressions.
- * @tparam Derived derived type of x
- * @param x Matrix or matrix expression
+ * Version of `exp()` that accepts std::vectors, Eigen Matrix/Array objects
+ *  or expressions, and containers of these.
+ *
+ * @tparam Container Type of x
+ * @param x Container
  * @return Elementwise application of exponentiation to the argument.
  */
-template <typename Derived,
-          typename = require_eigen_vt<std::is_arithmetic, Derived>>
-inline auto exp(const Eigen::MatrixBase<Derived>& x) {
-  return x.derived().array().exp().matrix().eval();
+template <typename Container,
+          require_container_st<is_container, std::is_arithmetic, Container>...>
+inline auto exp(const Container& x) {
+  return apply_vector_unary<Container>::apply(
+      x, [](const auto& v) { return v.array().exp(); });
 }
 
 }  // namespace math

stan/math/prim/fun/fabs.hpp

@@ -27,39 +27,30 @@ struct fabs_fun {
  * Returns the elementwise `fabs()` of the input,
  * which may be a scalar or any Stan container of numeric scalars.
  *
- * @tparam T type of container
+ * @tparam Container type of container
  * @param x container
  * @return Absolute value of each value in x.
  */
-template <typename T, typename = require_not_eigen_vt<std::is_arithmetic, T>>
-inline typename apply_scalar_unary<fabs_fun, T>::return_t fabs(const T& x) {
-  return apply_scalar_unary<fabs_fun, T>::apply(x);
+template <
+    typename Container,
+    require_not_container_st<is_container, std::is_arithmetic, Container>...>
+inline auto fabs(const Container& x) {
+  return apply_scalar_unary<fabs_fun, Container>::apply(x);
 }
 
 /**
- * Version of `fabs()` that accepts Eigen Matrix or matrix expressions.
+ * Version of `fabs()` that accepts std::vectors, Eigen Matrix/Array objects
+ *  or expressions, and containers of these.
  *
- * @tparam Derived derived type of x
- * @param x Matrix or matrix expression
+ * @tparam Container Type of x
+ * @param x Container
  * @return Absolute value of each value in x.
  */
-template <typename Derived,
-          typename = require_eigen_vt<std::is_arithmetic, Derived>>
-inline auto fabs(const Eigen::MatrixBase<Derived>& x) {
-  return x.derived().array().abs().matrix().eval();
-}
-
-/**
- * Version of \c fabs() that accepts Eigen Array or array expressions.
- *
- * @tparam Derived derived type of x
- * @param x Matrix or matrix expression
- * @return Absolute value of each value in x.
- */
-template <typename Derived,
-          typename = require_eigen_vt<std::is_arithmetic, Derived>>
-inline auto fabs(const Eigen::ArrayBase<Derived>& x) {
-  return x.derived().abs().eval();
+template <typename Container,
+          require_container_st<is_container, std::is_arithmetic, Container>...>
+inline auto fabs(const Container& x) {
+  return apply_vector_unary<Container>::apply(
+      x, [](const auto& v) { return v.array().abs(); });
 }
 
 }  // namespace math