Allow vector overloads to be called without lp argument

Author: WardBrian

stan/math/prim/constraint/cholesky_corr_constrain.hpp

@@ -77,32 +77,26 @@ cholesky_corr_constrain(const EigVec& y, int K, Lp& lp) {
 }
 
 /**
- * Return The cholesky of a `KxK` correlation matrix. If the `Jacobian`
- * parameter is `true`, the log density accumulator is incremented with the log
- * absolute Jacobian determinant of the transform.  All of the transforms are
- * specified with their Jacobians in the *Stan Reference Manual* chapter
- * Constraint Transforms.
- * @tparam Jacobian if `true`, increment log density accumulator with log
- * absolute Jacobian determinant of constraining transform
- * @tparam T A type inheriting from `Eigen::DenseBase` or a `var_value` with
- *  inner type inheriting from `Eigen::DenseBase` with compile time dynamic rows
- *  and 1 column
- * @tparam Lp A scalar type for the lp argument. The scalar type of T should be
- * convertable to this.
+ * Return The cholesky of a `KxK` correlation matrix.
+ * This overload handles looping over the elements of a standard vector.
+ * @tparam T A standard vector with inner type inheriting from
+ * `Eigen::DenseBase` or a `var_value` with inner type inheriting from
+ * `Eigen::DenseBase` with compile time dynamic rows and 1 column
+ * @tparam Lp A pack that is either empty, or exactly one scalar type for the lp
+ * argument. The scalar type of T should be convertable to this.
  * @param y Linearly Serialized vector of size `(K * (K - 1))/2` holding the
  *  column major order elements of the lower triangurlar
  * @param K The size of the matrix to return
- * @param[in,out] lp log density accumulator
+ * @param[in,out] lp log density accumulator or empty
  */
-template <bool Jacobian, typename T, typename Lp,
-          require_not_std_vector_t<T>* = nullptr,
-          require_convertible_t<return_type_t<T>, Lp>* = nullptr>
-inline auto cholesky_corr_constrain(const T& y, int K, Lp& lp) {
-  if (Jacobian) {
-    return cholesky_corr_constrain(y, K, lp);
-  } else {
-    return cholesky_corr_constrain(y, K);
-  }
+template <typename T, typename... Lp, require_std_vector_t<T>* = nullptr>
+inline auto cholesky_corr_constrain(const T& y, int K, Lp&... lp) {
+  static_assert(sizeof...(lp) == 0 || sizeof...(lp) == 1,
+                "cholesky_corr_constrain should be called with either "
+                "two or three arguments");
+  return apply_vector_unary<T>::apply(y, [&lp..., K](auto&& v) {
+    return cholesky_corr_constrain(v, K, lp...);
+  });
 }
 
 /**
@@ -113,9 +107,9 @@ inline auto cholesky_corr_constrain(const T& y, int K, Lp& lp) {
  * Constraint Transforms.
  * @tparam Jacobian if `true`, increment log density accumulator with log
  * absolute Jacobian determinant of constraining transform
- * @tparam T A standard vector with inner type inheriting from
- * `Eigen::DenseBase` or a `var_value` with inner type inheriting from
- * `Eigen::DenseBase` with compile time dynamic rows and 1 column
+ * @tparam T A type inheriting from `Eigen::DenseBase` or a `var_value` with
+ *  inner type inheriting from `Eigen::DenseBase` with compile time dynamic rows
+ *  and 1 column, or a standard vector thereof
  * @tparam Lp A scalar type for the lp argument. The scalar type of T should be
  * convertable to this.
  * @param y Linearly Serialized vector of size `(K * (K - 1))/2` holding the
@@ -124,12 +118,13 @@ inline auto cholesky_corr_constrain(const T& y, int K, Lp& lp) {
  * @param[in,out] lp log density accumulator
  */
 template <bool Jacobian, typename T, typename Lp,
-          require_std_vector_t<T>* = nullptr,
           require_convertible_t<return_type_t<T>, Lp>* = nullptr>
 inline auto cholesky_corr_constrain(const T& y, int K, Lp& lp) {
-  return apply_vector_unary<T>::apply(y, [&lp, K](auto&& v) {
-    return cholesky_corr_constrain<Jacobian>(v, K, lp);
-  });
+  if constexpr (Jacobian) {
+    return cholesky_corr_constrain(y, K, lp);
+  } else {
+    return cholesky_corr_constrain(y, K);
+  }
 }
 
 }  // namespace math

stan/math/prim/constraint/cholesky_factor_constrain.hpp

@@ -89,34 +89,28 @@ cholesky_factor_constrain(const T& x, int M, int N, Lp& lp) {
 /**
  * Return the Cholesky factor of the specified size read from the specified
  * vector. A total of (N choose 2) + N + N * (M - N) free parameters are
- * required to read an M by N Cholesky factor. If the `Jacobian` parameter is
- * `true`, the log density accumulator is incremented with the log absolute
- * Jacobian determinant of the transform.  All of the transforms are specified
- * with their Jacobians in the *Stan Reference Manual* chapter Constraint
- * Transforms.
+ * required to read an M by N Cholesky factor.
+ * This overload handles looping over the elements of a standard vector.
  *
- * @tparam Jacobian if `true`, increment log density accumulator with log
- * absolute Jacobian determinant of constraining transform
- * @tparam T A type inheriting from `Eigen::DenseBase` or a `var_value` with
- *  inner type inheriting from `Eigen::DenseBase` with compile time dynamic rows
- *  and 1 column
- * @tparam Lp A scalar type for the lp argument. The scalar type of T should be
- * convertable to this.
+ * @tparam T A standard vector with inner type inheriting from
+ * `Eigen::DenseBase` or a `var_value` with inner type inheriting from
+ * `Eigen::DenseBase` with compile time dynamic rows and 1 column
+ * @tparam Lp A pack that is either empty, or exactly one scalar type for the lp
+ * argument. The scalar type of T should be convertable to this.
  * @param x Vector of unconstrained values
  * @param M number of rows
  * @param N number of columns
- * @param[in,out] lp log density accumulator
+ * @param[in,out] lp log density accumulator or empty
  * @return Cholesky factor
  */
-template <bool Jacobian, typename T, typename Lp,
-          require_not_std_vector_t<T>* = nullptr,
-          require_convertible_t<return_type_t<T>, Lp>* = nullptr>
-inline auto cholesky_factor_constrain(const T& x, int M, int N, Lp& lp) {
-  if (Jacobian) {
-    return cholesky_factor_constrain(x, M, N, lp);
-  } else {
-    return cholesky_factor_constrain(x, M, N);
-  }
+template <typename T, typename... Lp, require_std_vector_t<T>* = nullptr>
+inline auto cholesky_factor_constrain(const T& x, int M, int N, Lp&... lp) {
+  static_assert(sizeof...(lp) == 0 || sizeof...(lp) == 1,
+                "cholesky_factor_constrain should be called with either "
+                "three or four arguments");
+  return apply_vector_unary<T>::apply(x, [&lp..., M, N](auto&& v) {
+    return cholesky_factor_constrain(v, M, N, lp...);
+  });
 }
 
 /**
@@ -130,9 +124,9 @@ inline auto cholesky_factor_constrain(const T& x, int M, int N, Lp& lp) {
  *
  * @tparam Jacobian if `true`, increment log density accumulator with log
  * absolute Jacobian determinant of constraining transform
- * @tparam T A standard vector with inner type inheriting from
- * `Eigen::DenseBase` or a `var_value` with inner type inheriting from
- * `Eigen::DenseBase` with compile time dynamic rows and 1 column
+ * @tparam T A type inheriting from `Eigen::DenseBase` or a `var_value` with
+ *  inner type inheriting from `Eigen::DenseBase` with compile time dynamic rows
+ *  and 1 column
  * @tparam Lp A scalar type for the lp argument. The scalar type of T should be
  * convertable to this.
  * @param x Vector of unconstrained values
@@ -142,12 +136,13 @@ inline auto cholesky_factor_constrain(const T& x, int M, int N, Lp& lp) {
  * @return Cholesky factor
  */
 template <bool Jacobian, typename T, typename Lp,
-          require_std_vector_t<T>* = nullptr,
           require_convertible_t<return_type_t<T>, Lp>* = nullptr>
 inline auto cholesky_factor_constrain(const T& x, int M, int N, Lp& lp) {
-  return apply_vector_unary<T>::apply(x, [&lp, M, N](auto&& v) {
-    return cholesky_factor_constrain<Jacobian>(v, M, N, lp);
-  });
+  if constexpr (Jacobian) {
+    return cholesky_factor_constrain(x, M, N, lp);
+  } else {
+    return cholesky_factor_constrain(x, M, N);
+  }
 }
 
 }  // namespace math

stan/math/prim/constraint/corr_matrix_constrain.hpp

@@ -82,31 +82,24 @@ corr_matrix_constrain(const T& x, Eigen::Index k, Lp& lp) {
  * the specified vector of unconstrained values. The input vector must be of
  * length \f${k \choose 2} = \frac{k(k-1)}{2}\f$.  The values in the input
  * vector represent unconstrained (partial) correlations among the dimensions.
- * If the `Jacobian` parameter is `true`, the log density accumulator is
- * incremented with the log absolute Jacobian determinant of the transform.  All
- * of the transforms are specified with their Jacobians in the *Stan Reference
- * Manual* chapter Constraint Transforms.
+ * This overload handles looping over the elements of a standard vector.
  *
- * @tparam Jacobian if `true`, increment log density accumulator with log
- * absolute Jacobian determinant of constraining transform
- * @tparam T A type inheriting from `Eigen::DenseBase` or a `var_value` with
- *  inner type inheriting from `Eigen::DenseBase` with compile time dynamic rows
- *  and 1 column
- * @tparam Lp A scalar type for the lp argument. The scalar type of T should be
- * convertable to this.
- * @param x Vector of unconstrained partial correlations
- * @param k Dimensionality of returned correlation matrix
- * @param[in,out] lp log density accumulator
+ * @tparam T A standard vector with inner type inheriting from
+ * `Eigen::DenseBase` or a `var_value` with inner type inheriting from
+ * `Eigen::DenseBase` with compile time dynamic rows and 1 column
+ * @tparam Lp A pack that is either empty, or exactly one scalar type for the lp
+ * argument. The scalar type of T should be convertable to this.
+ * @param y Vector of unconstrained partial correlations
+ * @param K Dimensionality of returned correlation matrix
+ * @param[in, out] lp log density accumulator or empty
  */
-template <bool Jacobian, typename T, typename Lp,
-          require_not_std_vector_t<T>* = nullptr,
-          require_convertible_t<return_type_t<T>, Lp>* = nullptr>
-inline auto corr_matrix_constrain(const T& x, Eigen::Index k, Lp& lp) {
-  if (Jacobian) {
-    return corr_matrix_constrain(x, k, lp);
-  } else {
-    return corr_matrix_constrain(x, k);
-  }
+template <typename T, typename... Lp, require_std_vector_t<T>* = nullptr>
+inline auto corr_matrix_constrain(const T& y, int K, Lp&... lp) {
+  static_assert(sizeof...(lp) == 0 || sizeof...(lp) == 1,
+                "corr_matrix_constrain should be called with either "
+                "two or three arguments");
+  return apply_vector_unary<T>::apply(
+      y, [&lp..., K](auto&& v) { return corr_matrix_constrain(v, K, lp...); });
 }
 
 /**
@@ -121,22 +114,23 @@ inline auto corr_matrix_constrain(const T& x, Eigen::Index k, Lp& lp) {
  *
  * @tparam Jacobian if `true`, increment log density accumulator with log
  * absolute Jacobian determinant of constraining transform
- * @tparam T A standard vector with inner type inheriting from
- * `Eigen::DenseBase` or a `var_value` with inner type inheriting from
- * `Eigen::DenseBase` with compile time dynamic rows and 1 column
+ * @tparam T A type inheriting from `Eigen::DenseBase` or a `var_value` with
+ *  inner type inheriting from `Eigen::DenseBase` with compile time dynamic rows
+ *  and 1 column or standard vector thereof
  * @tparam Lp A scalar type for the lp argument. The scalar type of T should be
  * convertable to this.
- * @param y Vector of unconstrained partial correlations
- * @param K Dimensionality of returned correlation matrix
+ * @param x Vector of unconstrained partial correlations
+ * @param k Dimensionality of returned correlation matrix
  * @param[in,out] lp log density accumulator
  */
 template <bool Jacobian, typename T, typename Lp,
-          require_std_vector_t<T>* = nullptr,
           require_convertible_t<return_type_t<T>, Lp>* = nullptr>
-inline auto corr_matrix_constrain(const T& y, int K, Lp& lp) {
-  return apply_vector_unary<T>::apply(y, [&lp, K](auto&& v) {
-    return corr_matrix_constrain<Jacobian>(v, K, lp);
-  });
+inline auto corr_matrix_constrain(const T& x, Eigen::Index k, Lp& lp) {
+  if constexpr (Jacobian) {
+    return corr_matrix_constrain(x, k, lp);
+  } else {
+    return corr_matrix_constrain(x, k);
+  }
 }
 
 }  // namespace math

stan/math/prim/constraint/cov_matrix_constrain.hpp

@@ -91,33 +91,26 @@ cov_matrix_constrain(const T& x, Eigen::Index K, Lp& lp) {
 
 /**
  * Return the symmetric, positive-definite matrix of dimensions K by K resulting
- * from transforming the specified finite vector of size K plus (K choose 2). If
- * the `Jacobian` parameter is `true`, the log density accumulator is
- * incremented with the log absolute Jacobian determinant of the transform.  All
- * of the transforms are specified with their Jacobians in the *Stan Reference
- * Manual* chapter Constraint Transforms.
+ * from transforming the specified finite vector of size K plus (K choose 2).
+ * This overload handles looping over the elements of a standard vector.
  *
- * @tparam Jacobian if `true`, increment log density accumulator with log
- * absolute Jacobian determinant of constraining transform
- * @tparam T A type inheriting from `Eigen::DenseBase` or a `var_value` with
- *  inner type inheriting from `Eigen::DenseBase` with compile time dynamic rows
- *  and 1 column
- * @tparam Lp A scalar type for the lp argument. The scalar type of T should be
- * convertable to this.
+ * @tparam T A standard vector with inner type inheriting from
+ * `Eigen::DenseBase` or a `var_value` with inner type inheriting from
+ * `Eigen::DenseBase` with compile time dynamic rows and 1 column
+ * @tparam Lp A pack that is either empty, or exactly one scalar type for the lp
+ * argument. The scalar type of T should be convertable to this.
  * @param x The vector to convert to a covariance matrix
  * @param K The dimensions of the resulting covariance matrix
- * @param[in, out] lp log density accumulator
+ * @param[in, out] lp log density accumulator or empty
  * @throws std::domain_error if (x.size() != K + (K choose 2)).
  */
-template <bool Jacobian, typename T, typename Lp,
-          require_not_std_vector_t<T>* = nullptr,
-          require_convertible_t<return_type_t<T>, Lp>* = nullptr>
-inline auto cov_matrix_constrain(const T& x, Eigen::Index K, Lp& lp) {
-  if (Jacobian) {
-    return cov_matrix_constrain(x, K, lp);
-  } else {
-    return cov_matrix_constrain(x, K);
-  }
+template <typename T, typename... Lp, require_std_vector_t<T>* = nullptr>
+inline auto cov_matrix_constrain(const T& x, Eigen::Index K, Lp&... lp) {
+  static_assert(sizeof...(lp) == 0 || sizeof...(lp) == 1,
+                "cov_matrix_constrain should be called with either "
+                "two or three arguments");
+  return apply_vector_unary<T>::apply(
+      x, [&lp..., K](auto&& v) { return cov_matrix_constrain(v, K, lp...); });
 }
 
 /**
@@ -130,9 +123,9 @@ inline auto cov_matrix_constrain(const T& x, Eigen::Index K, Lp& lp) {
  *
  * @tparam Jacobian if `true`, increment log density accumulator with log
  * absolute Jacobian determinant of constraining transform
- * @tparam T A standard vector with inner type inheriting from
- * `Eigen::DenseBase` or a `var_value` with inner type inheriting from
- * `Eigen::DenseBase` with compile time dynamic rows and 1 column
+ * @tparam T A type inheriting from `Eigen::DenseBase` or a `var_value` with
+ *  inner type inheriting from `Eigen::DenseBase` with compile time dynamic rows
+ *  and 1 column, or standard vector thereof
  * @tparam Lp A scalar type for the lp argument. The scalar type of T should be
  * convertable to this.
  * @param x The vector to convert to a covariance matrix
@@ -141,12 +134,13 @@ inline auto cov_matrix_constrain(const T& x, Eigen::Index K, Lp& lp) {
  * @throws std::domain_error if (x.size() != K + (K choose 2)).
  */
 template <bool Jacobian, typename T, typename Lp,
-          require_std_vector_t<T>* = nullptr,
           require_convertible_t<return_type_t<T>, Lp>* = nullptr>
 inline auto cov_matrix_constrain(const T& x, Eigen::Index K, Lp& lp) {
-  return apply_vector_unary<T>::apply(x, [&lp, K](auto&& v) {
-    return cov_matrix_constrain<Jacobian>(v, K, lp);
-  });
+  if constexpr (Jacobian) {
+    return cov_matrix_constrain(x, K, lp);
+  } else {
+    return cov_matrix_constrain(x, K);
+  }
 }
 
 }  // namespace math