Vectorize checks called by compiler

stan/math/prim/err.hpp

@@ -73,9 +73,9 @@
 #include <stan/math/prim/err/out_of_range.hpp>
 #include <stan/math/prim/err/system_error.hpp>
 #include <stan/math/prim/err/throw_domain_error.hpp>
+#include <stan/math/prim/err/throw_domain_error_mat.hpp>
 #include <stan/math/prim/err/throw_domain_error_vec.hpp>
 #include <stan/math/prim/err/validate_non_negative_index.hpp>
 #include <stan/math/prim/err/validate_positive_index.hpp>
 #include <stan/math/prim/err/validate_unit_vector_index.hpp>
-
 #endif

stan/math/prim/err/check_cholesky_factor.hpp

@@ -1,41 +1,71 @@
 #ifndef STAN_MATH_PRIM_ERR_CHECK_CHOLESKY_FACTOR_HPP
 #define STAN_MATH_PRIM_ERR_CHECK_CHOLESKY_FACTOR_HPP
 
-#include <stan/math/prim/meta.hpp>
 #include <stan/math/prim/fun/Eigen.hpp>
+#include <stan/math/prim/meta.hpp>
+#include <stan/math/prim/fun/to_ref.hpp>
+#include <stan/math/prim/fun/value_of_rec.hpp>
 #include <stan/math/prim/err/check_positive.hpp>
 #include <stan/math/prim/err/check_less_or_equal.hpp>
 #include <stan/math/prim/err/check_lower_triangular.hpp>
+#include <stan/math/prim/err/make_iter_name.hpp>
 
 namespace stan {
 namespace math {
 
 /**
- * Check if the specified matrix is a valid Cholesky factor.
- * A Cholesky factor is a lower triangular matrix whose diagonal
- * elements are all positive.  Note that Cholesky factors need not
- * be square, but require at least as many rows M as columns N
- * (i.e., M &gt;= N).
- * @tparam EigMat Type of the Cholesky factor (must be derived from \c
- * Eigen::MatrixBase)
+ * Throw an exception if the specified matrix is not a valid Cholesky factor. A
+ * Cholesky factor is a lower triangular matrix whose diagonal elements are all
+ * positive.  Note that Cholesky factors need not be square, but require at
+ * least as many rows M as columns N (i.e., `M >= N`).
+ * @tparam Mat Type inheriting from `MatrixBase` with neither rows or columns
+ * defined at compile time to be equal to 1 or a `var_value` with the var's
+ * inner type inheriting from `Eigen::MatrixBase` with neither rows or columns
+ * defined at compile time to be equal to 1
  * @param function Function name (for error messages)
  * @param name Variable name (for error messages)
  * @param y Matrix to test
- * @throw <code>std::domain_error</code> if y is not a valid Cholesky
- *   factor, if number of rows is less than the number of columns,
- *   if there are 0 columns, or if any element in matrix is NaN
+ * @throw `std::domain_error` if y is not a valid Cholesky factor, if number of
+ * rows is less than the number of columns, if there are 0 columns, or if any
+ * element in matrix is `NaN`
  */
-template <typename EigMat, require_eigen_t<EigMat>* = nullptr>
+template <typename Mat, require_matrix_t<Mat>* = nullptr>
 inline void check_cholesky_factor(const char* function, const char* name,
-                                  const EigMat& y) {
+                                  const Mat& y) {
   check_less_or_equal(function, "columns and rows of Cholesky factor", y.cols(),
                       y.rows());
   check_positive(function, "columns of Cholesky factor", y.cols());
-  const Eigen::Ref<const plain_type_t<EigMat>>& y_ref = y;
+  auto&& y_ref = to_ref(value_of_rec(y));
   check_lower_triangular(function, name, y_ref);
   check_positive(function, name, y_ref.diagonal());
 }
 
+/**
+ * Throw an exception if the specified matrix is not a valid Cholesky factor. A
+ * Cholesky factor is a lower triangular matrix whose diagonal elements are all
+ * positive.  Note that Cholesky factors need not be square, but require at
+ * least as many rows M as columns N (i.e., `M >= N`).
+ * @tparam StdVec A standard vector with inner type either inheriting from
+ * `MatrixBase` with neither rows or columns defined at compile time to be equal
+ * to 1 or a `var_value` with the var's inner type inheriting from
+ * `Eigen::MatrixBase` with neither rows or columns defined at compile time to
+ * be equal to 1
+ * @param function Function name (for error messages)
+ * @param name Variable name (for error messages)
+ * @param y Standard vector of matrices to test
+ * @throw `std::domain_error` if y is not a valid Cholesky factor, if number of
+ * rows is less than the number of columns, if there are 0 columns, or if any
+ * element in matrix is `NaN`
+ */
+template <typename StdVec, require_std_vector_t<StdVec>* = nullptr>
+void check_cholesky_factor(const char* function, const char* name,
+                           const StdVec& y) {
+  for (size_t i = 0; i < y.size(); ++i) {
+    check_cholesky_factor(function, internal::make_iter_name(name, i).c_str(),
+                          y[i]);
+  }
+}
+
 }  // namespace math
 }  // namespace stan
 #endif

stan/math/prim/err/check_cholesky_factor_corr.hpp

@@ -4,35 +4,39 @@
 #include <stan/math/prim/fun/Eigen.hpp>
 #include <stan/math/prim/meta.hpp>
 #include <stan/math/prim/fun/to_ref.hpp>
+#include <stan/math/prim/fun/value_of_rec.hpp>
 #include <stan/math/prim/err/check_positive.hpp>
 #include <stan/math/prim/err/check_lower_triangular.hpp>
 #include <stan/math/prim/err/check_square.hpp>
 #include <stan/math/prim/err/check_unit_vector.hpp>
+#include <stan/math/prim/err/make_iter_name.hpp>
 
 namespace stan {
 namespace math {
 
 /**
- * Check if the specified matrix is a valid Cholesky factor of a
- * correlation matrix.
- * A Cholesky factor is a lower triangular matrix whose diagonal
- * elements are all positive.  Note that Cholesky factors need not
- * be square, but require at least as many rows M as columns N
- * (i.e., M &gt;= N).
- * Tolerance is specified by <code>math::CONSTRAINT_TOLERANCE</code>.
- * @tparam EigMat Type inheriting from `MatrixBase` with dynamic rows and
- * columns.
+ * Throw an exception if the specified matrix is not a valid Cholesky factor of
+ * a correlation matrix. A Cholesky factor is a lower triangular matrix whose
+ * diagonal elements are all positive and each row has unit Euclidean length.
+ * Note that Cholesky factors need not be square, but require at least as many
+ * rows M as columns N (i.e., `M >= N`). Tolerance is specified by
+ * `math::CONSTRAINT_TOLERANCE`. Tolerance is specified by
+ * `math::CONSTRAINT_TOLERANCE`.
+ * @tparam Mat Type inheriting from `MatrixBase` with neither rows or columns
+ * defined at compile time to be equal to 1 or a `var_value` with the var's
+ * inner type inheriting from `Eigen::MatrixBase` with neither rows or columns
+ * defined at compile time to be equal to 1
  * @param function Function name (for error messages)
  * @param name Variable name (for error messages)
  * @param y Matrix to test
- * @throw <code>std::domain_error</code> if y is not a valid Cholesky
- *   factor, if number of rows is less than the number of columns,
- *   if there are 0 columns, or if any element in matrix is NaN
+ * @throw `std::domain_error` if y is not a valid Cholesky factor, if number of
+ * rows is less than the number of columns, if there are 0 columns, or if any
+ * element in matrix is NaN
  */
-template <typename EigMat, require_eigen_matrix_dynamic_t<EigMat>* = nullptr>
+template <typename Mat, require_matrix_t<Mat>* = nullptr>
 void check_cholesky_factor_corr(const char* function, const char* name,
-                                const EigMat& y) {
-  const auto& y_ref = to_ref(y);
+                                const Mat& y) {
+  const auto& y_ref = to_ref(value_of_rec(y));
   check_square(function, name, y_ref);
   check_lower_triangular(function, name, y_ref);
   check_positive(function, name, y_ref.diagonal());
@@ -41,6 +45,34 @@ void check_cholesky_factor_corr(const char* function, const char* name,
   }
 }
 
+/**
+ * Throw an exception if the specified matrix is not a valid Cholesky factor of
+ * a correlation matrix. A Cholesky factor is a lower triangular matrix whose
+ * diagonal elements are all positive and each row has unit Euclidean length.
+ * Note that Cholesky factors need not be square, but require at least as many
+ * rows M as columns N (i.e., `M >= N`). Tolerance is specified by
+ * `math::CONSTRAINT_TOLERANCE`. Tolerance is specified by
+ * `math::CONSTRAINT_TOLERANCE`.
+ * @tparam StdVec A standard vector with inner type either inheriting from
+ * `MatrixBase` with neither rows or columns defined at compile time to be equal
+ * to 1 or a `var_value` with the var's inner type inheriting from
+ * `Eigen::MatrixBase` with neither rows or columns defined at compile time to
+ * be equal to 1
+ * @param function Function name (for error messages)
+ * @param name Variable name (for error messages)
+ * @param y Standard vector of matrics to test
+ * @throw `std::domain_error` if y[i] is not a valid Cholesky factor, if number
+ * of rows is less than the number of columns, if there are 0 columns, or if any
+ * element in matrix is NaN
+ */
+template <typename StdVec, require_std_vector_t<StdVec>* = nullptr>
+void check_cholesky_factor_corr(const char* function, const char* name,
+                                const StdVec& y) {
+  for (size_t i = 0; i < y.size(); ++i) {
+    check_cholesky_factor_corr(function,
+                               internal::make_iter_name(name, i).c_str(), y[i]);
+  }
+}
 }  // namespace math
 }  // namespace stan
 #endif

stan/math/prim/err/check_corr_matrix.hpp

@@ -3,10 +3,11 @@
 
 #include <stan/math/prim/fun/Eigen.hpp>
 #include <stan/math/prim/meta.hpp>
+#include <stan/math/prim/fun/to_ref.hpp>
+#include <stan/math/prim/fun/value_of_rec.hpp>
 #include <stan/math/prim/err/throw_domain_error.hpp>
 #include <stan/math/prim/err/check_pos_definite.hpp>
 #include <stan/math/prim/err/check_square.hpp>
-#include <stan/math/prim/fun/to_ref.hpp>
 #include <sstream>
 #include <string>
 #include <cmath>
@@ -15,44 +16,68 @@ namespace stan {
 namespace math {
 
 /**
- * Check if the specified matrix is a valid correlation matrix.
- * A valid correlation matrix is symmetric, has a unit diagonal
- * (all 1 values), and has all values between -1 and 1
- * (inclusive).
- * This function throws exceptions if the variable is not a valid
- * correlation matrix.
- * @tparam EigMat Type inheriting from `MatrixBase` with dynamic rows and
- * columns.
+ * Throw an exception if the specified matrix is not a valid correlation matrix.
+ * A valid correlation matrix is symmetric positive definite, has a unit
+ * diagonal (all 1 values), and has all values between -1 and 1 (inclusive).
+ * @tparam Mat Type inheriting from `MatrixBase` with neither rows or columns
+ * defined at compile time to be equal to 1 or a `var_value` with the var's
+ * inner type inheriting from `Eigen::MatrixBase` with neither rows or columns
+ * defined at compile time to be equal to 1
  * @param function Name of the function this was called from
  * @param name Name of the variable
  * @param y Matrix to test
- * @throw <code>std::invalid_argument</code> if the matrix is not square
- * @throw <code>std::domain_error</code> if the matrix is non-symmetric,
- *   diagonals not near 1, not positive definite, or any of the
- *   elements nan
+ * @throw `std::invalid_argument` if the matrix is not square
+ * @throw `std::domain_error` if the matrix is non-symmetric, diagonals not near
+ * 1, not positive definite, or any of the elements are `NaN`
  */
-template <typename EigMat, require_eigen_matrix_dynamic_t<EigMat>* = nullptr>
+template <typename Mat, require_matrix_t<Mat>* = nullptr>
 inline void check_corr_matrix(const char* function, const char* name,
-                              const EigMat& y) {
-  const auto& y_ref = to_ref(y);
+                              const Mat& y) {
+  auto&& y_ref = to_ref(value_of_rec(y));
   check_square(function, name, y_ref);
   using std::fabs;
   if (y_ref.size() == 0) {
     return;
   }
 
   for (Eigen::Index k = 0; k < y.rows(); ++k) {
-    if (!(fabs(y_ref(k, k) - 1.0) <= CONSTRAINT_TOLERANCE)) {
-      std::ostringstream msg;
-      msg << "is not a valid correlation matrix. " << name << "("
-          << stan::error_index::value + k << "," << stan::error_index::value + k
-          << ") is ";
-      std::string msg_str(msg.str());
-      throw_domain_error(function, name, y_ref(k, k), msg_str.c_str(),
-                         ", but should be near 1.0");
+    if (!(fabs(y_ref.coeff(k, k) - 1.0) <= CONSTRAINT_TOLERANCE)) {
+      [&y_ref, name, k, function]() STAN_COLD_PATH {
+        std::ostringstream msg;
+        msg << "is not a valid correlation matrix. " << name << "("
+            << stan::error_index::value + k << ","
+            << stan::error_index::value + k << ") is ";
+        std::string msg_str(msg.str());
+        throw_domain_error(function, name, y_ref(k, k), msg_str.c_str(),
+                           ", but should be near 1.0");
+      }();
     }
   }
-  check_pos_definite(function, "y", y_ref);
+  check_pos_definite(function, name, y_ref);
+}
+
+/**
+ * Throw an exception if the specified matrix is not a valid correlation matrix.
+ * A valid correlation matrix is symmetric positive definite, has a unit
+ * diagonal (all 1 values), and has all values between -1 and 1 (inclusive).
+ * @tparam StdVec A standard vector with inner type either inheriting from
+ * `Eigen::MatrixBase` with neither rows or columns defined at compile time to
+ * be equal to 1 or a `var_value` with the var's inner type inheriting from
+ * `Eigen::MatrixBase` with neither rows or columns defined at compile time to
+ * be equal to 1.
+ * @param function Name of the function this was called from
+ * @param name Name of the variable
+ * @param y Matrix to test
+ * @throw `std::invalid_argument` if the matrix is not square
+ * @throw `std::domain_error` if the matrix is non-symmetric, diagonals not near
+ * 1, not positive definite, or any of the elements are `NaN`
+ */
+template <typename StdVec, require_std_vector_t<StdVec>* = nullptr>
+void check_corr_matrix(const char* function, const char* name,
+                       const StdVec& y) {
+  for (auto&& y_i : y) {
+    check_corr_matrix(function, name, y_i);
+  }
 }
 
 }  // namespace math

stan/math/prim/err/check_cov_matrix.hpp

@@ -3,31 +3,58 @@
 
 #include <stan/math/prim/fun/Eigen.hpp>
 #include <stan/math/prim/meta.hpp>
+#include <stan/math/prim/fun/to_ref.hpp>
+#include <stan/math/prim/fun/value_of_rec.hpp>
 #include <stan/math/prim/err/check_pos_definite.hpp>
 
 namespace stan {
 namespace math {
 /**
- * Check if the specified matrix is a valid covariance matrix.
- * A valid covariance matrix is a square, symmetric matrix that is
- * positive definite.
- * @tparam EigMat Type inheriting from `MatrixBase` with dynamic rows and
- * columns.
+ * Throw an exception if the specified matrix is not a valid covariance matrix.
+ * A valid covariance matrix is a square, symmetric matrix that is positive
+ * definite.
+ * @tparam Mat Type inheriting from `MatrixBase` with neither rows or columns
+ * defined at compile time to be equal to 1 or a `var_value` with the var's
+ * inner type inheriting from `Eigen::MatrixBase` with neither rows or columns
+ * defined at compile time to be equal to 1
  * @param function Function name (for error messages)
  * @param name Variable name (for error messages)
  * @param y Matrix to test
- * @throw <code>std::invalid_argument</code> if the matrix is not square
- *   or if the matrix is 0x0
- * @throw <code>std::domain_error</code> if the matrix is not symmetric,
- *   if the matrix is not positive definite,
- *   or if any element of the matrix is nan
+ * @throw `std::invalid_argument` if the matrix is not square or if the matrix
+ * is 0x0
+ * @throw `std::domain_error` if the matrix is not symmetric, if the matrix is
+ * not positive definite, or if any element of the matrix is `NaN`
  */
-template <typename EigMat, require_eigen_matrix_dynamic_t<EigMat>* = nullptr>
+template <typename Mat, require_matrix_t<Mat>* = nullptr>
 inline void check_cov_matrix(const char* function, const char* name,
-                             const EigMat& y) {
+                             const Mat& y) {
   check_pos_definite(function, name, y);
 }
 
+/**
+ * Throw an exception if the specified matrix is not a valid covariance matrix.
+ * A valid covariance matrix is a square, symmetric matrix that is positive
+ * definite.
+ * @tparam StdVec A standard vector with inner type either inheriting from
+ * `MatrixBase` with neither rows or columns defined at compile time to be equal
+ * to 1 or a `var_value` with the var's inner type inheriting from
+ * `Eigen::MatrixBase` with neither rows or columns defined at compile time to
+ * be equal to 1
+ * @param function Function name (for error messages)
+ * @param name Variable name (for error messages)
+ * @param y standard vector of matrices to test.
+ * @throw `std::invalid_argument` if the matrix is not square
+ *   or if the matrix is 0x0
+ * @throw `std::domain_error` if the matrix is not symmetric, if the matrix is
+ * not positive definite, or if any element of the matrix is `NaN`
+ */
+template <typename StdVec, require_std_vector_t<StdVec>* = nullptr>
+void check_cov_matrix(const char* function, const char* name, const StdVec& y) {
+  for (auto&& y_i : y) {
+    check_cov_matrix(function, name, y_i);
+  }
+}
+
 }  // namespace math
 }  // namespace stan
 #endif