Variadic argument lists for ODEs

stan/math/prim/err.hpp

@@ -28,6 +28,7 @@
 #include <stan/math/prim/err/check_nonzero_size.hpp>
 #include <stan/math/prim/err/check_not_nan.hpp>
 #include <stan/math/prim/err/check_ordered.hpp>
+#include <stan/math/prim/err/check_sorted.hpp>
 #include <stan/math/prim/err/check_pos_definite.hpp>
 #include <stan/math/prim/err/check_pos_semidefinite.hpp>
 #include <stan/math/prim/err/check_positive.hpp>

stan/math/prim/err/check_finite.hpp

@@ -14,28 +14,29 @@
 
 namespace stan {
 namespace math {
-
 namespace internal {
-template <typename T_y, bool is_vec>
-struct finite {
-  static void check(const char* function, const char* name, const T_y& y) {
-    if (!is_scal_finite(y)) {
-      throw_domain_error(function, name, y, "is ", ", but must be finite!");
-    }
+template <typename T_y>
+bool is_finite(const T_y& y) {
+  return is_scal_finite(y);
+}
+
+template <typename T_y, int R, int C>
+bool is_finite(const Eigen::Matrix<T_y, R, C>& y) {
+  bool all = true;
+  for (size_t n = 0; n < y.size(); ++n) {
+    all &= is_finite(y(n));
   }
-};
+  return all;
+}
 
 template <typename T_y>
-struct finite<T_y, true> {
-  static void check(const char* function, const char* name, const T_y& y) {
-    for (size_t n = 0; n < stan::math::size(y); n++) {
-      if (!is_scal_finite(stan::get(y, n))) {
-        throw_domain_error_vec(function, name, y, n, "is ",
-                               ", but must be finite!");
-      }
-    }
+bool is_finite(const std::vector<T_y>& y) {
+  bool all = true;
+  for (size_t n = 0; n < stan::math::size(y); ++n) {
+    all &= is_finite(y[n]);
   }
-};
+  return all;
+}
 }  // namespace internal
 
 /**
@@ -48,40 +49,77 @@ struct finite<T_y, true> {
  * @param y Variable to check
  * @throw <code>domain_error</code> if y is infinity, -infinity, or NaN
  */
-template <typename T_y>
+template <typename T_y, require_stan_scalar_t<T_y>* = nullptr>
 inline void check_finite(const char* function, const char* name, const T_y& y) {
-  internal::finite<T_y, is_vector_like<T_y>::value>::check(function, name, y);
+  if (!internal::is_finite(y)) {
+    throw_domain_error(function, name, y, "is ", ", but must be finite!");
+  }
+}
+
+/**
+ * Return <code>true</code> if all values in the std::vector are finite.
+ *
+ * @tparam T_y type of elements in the std::vector
+ *
+ * @param function name of function (for error messages)
+ * @param name variable name (for error messages)
+ * @param y std::vector to test
+ * @return <code>true</code> if all values are finite
+ **/
+template <typename T_y, require_stan_scalar_t<T_y>* = nullptr>
+inline void check_finite(const char* function, const char* name,
+                         const std::vector<T_y>& y) {
+  for (size_t n = 0; n < stan::math::size(y); n++) {
+    if (!internal::is_finite(stan::get(y, n))) {
+      throw_domain_error_vec(function, name, y, n, "is ",
+                             ", but must be finite!");
+    }
+  }
 }
 
 /**
  * Return <code>true</code> is the specified matrix is finite.
  *
- * @tparam T type of elements in the matrix
- * @tparam R number of rows, can be Eigen::Dynamic
- * @tparam C number of columns, can be Eigen::Dynamic
+ * @tparam Derived Eigen derived type
  *
  * @param function name of function (for error messages)
  * @param name variable name (for error messages)
  * @param y matrix to test
  * @return <code>true</code> if the matrix is finite
  **/
-namespace internal {
-template <typename T, int R, int C>
-struct finite<Eigen::Matrix<T, R, C>, true> {
-  static void check(const char* function, const char* name,
-                    const Eigen::Matrix<T, R, C>& y) {
-    if (!value_of(y).allFinite()) {
-      for (int n = 0; n < y.size(); ++n) {
-        if (!std::isfinite(value_of_rec(y(n)))) {
-          throw_domain_error_vec(function, name, y, n, "is ",
-                                 ", but must be finite!");
-        }
+template <typename EigMat, require_eigen_t<EigMat>* = nullptr>
+inline void check_finite(const char* function, const char* name,
+                         const EigMat& y) {
+  if (!value_of(y).allFinite()) {
+    for (int n = 0; n < y.size(); ++n) {
+      if (!std::isfinite(value_of_rec(y(n)))) {
+        throw_domain_error_vec(function, name, y, n, "is ",
+                               ", but must be finite!");
       }
     }
   }
-};
+}
+
+/**
+ * Return <code>true</code> if all values in the std::vector are finite.
+ *
+ * @tparam T_y type of elements in the std::vector
+ *
+ * @param function name of function (for error messages)
+ * @param name variable name (for error messages)
+ * @param y std::vector to test
+ * @return <code>true</code> if all values are finite
+ **/
+template <typename T_y, require_not_stan_scalar_t<T_y>* = nullptr>
+inline void check_finite(const char* function, const char* name,
+                         const std::vector<T_y>& y) {
+  for (size_t n = 0; n < stan::math::size(y); n++) {
+    if (!internal::is_finite(stan::get(y, n))) {
+      throw_domain_error(function, name, "", "", "is not finite!");
+    }
+  }
+}
 
-}  // namespace internal
 }  // namespace math
 }  // namespace stan
 

stan/math/prim/err/check_sorted.hpp

@@ -0,0 +1,76 @@
+#ifndef STAN_MATH_PRIM_ERR_CHECK_SORTED_HPP
+#define STAN_MATH_PRIM_ERR_CHECK_SORTED_HPP
+
+#include <stan/math/prim/err/throw_domain_error.hpp>
+#include <stan/math/prim/fun/Eigen.hpp>
+#include <sstream>
+#include <string>
+#include <vector>
+
+namespace stan {
+namespace math {
+
+/**
+ * Check if the specified vector is sorted into increasing order (repeated
+ * values are okay).
+ * @tparam T_y Type of scalar
+ * @param function Function name (for error messages)
+ * @param name Variable name (for error messages)
+ * @param y Vector to test
+ * @throw <code>std::domain_error</code> if the vector elements are
+ *   not sorted, or if any element is <code>NaN</code>.
+ */
+template <typename T_y>
+void check_sorted(const char* function, const char* name,
+                  const Eigen::Matrix<T_y, Eigen::Dynamic, 1>& y) {
+  using size_type = index_type_t<Eigen::Matrix<T_y, Eigen::Dynamic, 1>>;
+
+  for (size_type n = 1; n < y.size(); n++) {
+    if (!(y[n] >= y[n - 1])) {
+      std::ostringstream msg1;
+      msg1 << "is not a valid sorted vector."
+           << " The element at " << stan::error_index::value + n << " is ";
+      std::string msg1_str(msg1.str());
+      std::ostringstream msg2;
+      msg2 << ", but should be greater than or equal to the previous element, "
+           << y[n - 1];
+      std::string msg2_str(msg2.str());
+      throw_domain_error(function, name, y[n], msg1_str.c_str(),
+                         msg2_str.c_str());
+    }
+  }
+}
+
+/**
+ * Check if the specified vector is sorted into increasing order (repeated
+ * values are okay).
+ * @tparam T_y Type of scalar
+ * @param function Function name (for error messages)
+ * @param name Variable name (for error messages)
+ * @param y <code>std::vector</code> to test
+ * @throw <code>std::domain_error</code> if the vector elements are
+ *   not sorted, or if any element
+ *   is <code>NaN</code>.
+ */
+template <typename T_y>
+void check_sorted(const char* function, const char* name,
+                  const std::vector<T_y>& y) {
+  for (size_t n = 1; n < y.size(); n++) {
+    if (!(y[n] >= y[n - 1])) {
+      std::ostringstream msg1;
+      msg1 << "is not a valid sorted vector."
+           << " The element at " << stan::error_index::value + n << " is ";
+      std::string msg1_str(msg1.str());
+      std::ostringstream msg2;
+      msg2 << ", but should be greater than or equal to the previous element, "
+           << y[n - 1];
+      std::string msg2_str(msg2.str());
+      throw_domain_error(function, name, y[n], msg1_str.c_str(),
+                         msg2_str.c_str());
+    }
+  }
+}
+
+}  // namespace math
+}  // namespace stan
+#endif

stan/math/prim/fun.hpp

@@ -82,6 +82,7 @@
 #include <stan/math/prim/fun/elt_multiply.hpp>
 #include <stan/math/prim/fun/erf.hpp>
 #include <stan/math/prim/fun/erfc.hpp>
+#include <stan/math/prim/fun/eval.hpp>
 #include <stan/math/prim/fun/exp.hpp>
 #include <stan/math/prim/fun/exp2.hpp>
 #include <stan/math/prim/fun/expm1.hpp>

stan/math/prim/fun/eval.hpp

@@ -0,0 +1,39 @@
+#ifndef STAN_MATH_PRIM_FUN_EVAL_HPP
+#define STAN_MATH_PRIM_FUN_EVAL_HPP
+
+#include <stan/math/prim/meta.hpp>
+#include <stan/math/prim/fun/Eigen.hpp>
+#include <cstddef>
+#include <vector>
+
+namespace stan {
+namespace math {
+
+/**
+ * Inputs that are not Eigen types are forwarded unmodified
+ *
+ * @tparam T Input type
+ * @param[in] arg Input argument
+ * @return Forwarded input argument
+ **/
+template <typename T, require_not_eigen_t<T>* = nullptr>
+inline decltype(auto) eval(T&& arg) {
+  return std::forward<T>(arg);
+}
+
+/**
+ * Inputs that are Eigen types are eval'd and returned
+ *
+ * @tparam T Input type
+ * @param[in] arg Input argument
+ * @return Eval'd argument
+ **/
+template <typename T, require_eigen_t<T>* = nullptr>
+inline decltype(auto) eval(T arg) {
+  return arg.eval();
+}
+
+}  // namespace math
+}  // namespace stan
+
+#endif