elementwise_check.hpp

Go to the documentation of this file.

#ifndef STAN_MATH_PRIM_ERR_ELEMENTWISE_ERROR_CHECKER_HPP
#define STAN_MATH_PRIM_ERR_ELEMENTWISE_ERROR_CHECKER_HPP
 
#include <stan/math/prim/err/throw_domain_error.hpp>
#include <stan/math/prim/fun/get.hpp>
#include <stan/math/prim/fun/size.hpp>
#include <stan/math/prim/fun/value_of_rec.hpp>
#include <stan/math/prim/meta/is_eigen.hpp>
#include <stan/math/prim/meta/is_var_matrix.hpp>
#include <stan/math/prim/meta/is_vector.hpp>
#include <stan/math/prim/meta/is_stan_scalar.hpp>
#include <string>
#include <sstream>
#include <vector>
 
namespace stan {
namespace math {
namespace internal {
 
template <typename F>
class Iser {
  const F& is_good;
 
 public:
  explicit Iser(const F& is_good) : is_good(is_good) {}
 
  template <typename T, typename = require_stan_scalar_t<T>>
  bool is(const T& x) {
    return is_good(value_of_rec(x));
  }
 
  template <typename T, typename = require_not_stan_scalar_t<T>,
            typename = void>
  bool is(const T& x) {
    for (size_t i = 0; i < stan::math::size(x); ++i)
      if (!is(stan::get(x, i)))
        return false;
    return true;
  }
};
 
inline void pipe_in(std::stringstream& ss) {}
template <typename Arg0, typename... Args>
inline void pipe_in(std::stringstream& ss, Arg0 arg0, const Args... args) {
  ss << arg0;
  pipe_in(ss, args...);
}
 
template <typename... Args>
void elementwise_throw_domain_error(const Args... args) {
  std::stringstream ss;
  pipe_in(ss, args...);
  throw std::domain_error(ss.str());
}
 
}  // namespace internal
 
template <typename F, typename T, typename... Indexings,
          require_stan_scalar_t<T>* = nullptr>
inline void elementwise_check(const F& is_good, const char* function,
                              const char* name, const T& x, const char* must_be,
                              const Indexings&... indexings) {
  if (unlikely(!is_good(value_of_rec(x)))) {
    [&]() STAN_COLD_PATH {
      internal::elementwise_throw_domain_error(function, ": ", name,
                                               indexings..., " is ", x,
                                               ", but must be ", must_be, "!");
    }();
  }
}
template <typename F, typename T, typename... Indexings,
          require_eigen_t<T>* = nullptr,
          std::enable_if_t<(Eigen::internal::traits<T>::Flags
                            & Eigen::LinearAccessBit)
                           || T::IsVectorAtCompileTime>* = nullptr>
inline void elementwise_check(const F& is_good, const char* function,
                              const char* name, const T& x, const char* must_be,
                              const Indexings&... indexings) {
  for (size_t i = 0; i < x.size(); i++) {
    auto scal = value_of_rec(x.coeff(i));
    if (unlikely(!is_good(scal))) {
      [&]() STAN_COLD_PATH {
        if (is_eigen_vector<T>::value) {
          internal::elementwise_throw_domain_error(
              function, ": ", name, indexings..., "[", i + error_index::value,
              "] is ", scal, ", but must be ", must_be, "!");
        } else if (Eigen::internal::traits<T>::Flags & Eigen::RowMajorBit) {
          internal::elementwise_throw_domain_error(
              function, ": ", name, indexings..., "[",
              i / x.cols() + error_index::value, ", ",
              i % x.cols() + error_index::value, "] is ", scal,
              ", but must be ", must_be, "!");
        } else {
          internal::elementwise_throw_domain_error(
              function, ": ", name, indexings..., "[",
              i % x.rows() + error_index::value, ", ",
              i / x.rows() + error_index::value, "] is ", scal,
              ", but must be ", must_be, "!");
        }
      }();
    }
  }
}
 
template <typename F, typename T, typename... Indexings,
          require_eigen_t<T>* = nullptr,
          std::enable_if_t<!(Eigen::internal::traits<T>::Flags
                             & Eigen::LinearAccessBit)
                           && !T::IsVectorAtCompileTime
                           && !(Eigen::internal::traits<T>::Flags
                                & Eigen::RowMajorBit)>* = nullptr>
inline void elementwise_check(const F& is_good, const char* function,
                              const char* name, const T& x, const char* must_be,
                              const Indexings&... indexings) {
  for (size_t i = 0; i < x.rows(); i++) {
    for (size_t j = 0; j < x.cols(); j++) {
      auto scal = value_of_rec(x.coeff(i, j));
      if (unlikely(!is_good(scal))) {
        [&]() STAN_COLD_PATH {
          internal::elementwise_throw_domain_error(
              function, ": ", name, indexings..., "[", i + error_index::value,
              ", ", j + error_index::value, "] is ", scal, ", but must be ",
              must_be, "!");
        }();
      }
    }
  }
}
 
template <typename F, typename T, typename... Indexings,
          require_eigen_t<T>* = nullptr,
          std::enable_if_t<
              !(Eigen::internal::traits<T>::Flags & Eigen::LinearAccessBit)
              && !T::IsVectorAtCompileTime
              && static_cast<bool>(Eigen::internal::traits<T>::Flags
                                   & Eigen::RowMajorBit)>* = nullptr>
inline void elementwise_check(const F& is_good, const char* function,
                              const char* name, const T& x, const char* must_be,
                              const Indexings&... indexings) {
  for (size_t j = 0; j < x.cols(); j++) {
    for (size_t i = 0; i < x.rows(); i++) {
      auto scal = value_of_rec(x.coeff(i, j));
      if (unlikely(!is_good(scal))) {
        [&]() STAN_COLD_PATH {
          internal::elementwise_throw_domain_error(
              function, ": ", name, indexings..., "[", i + error_index::value,
              ", ", j + error_index::value, "] is ", scal, ", but must be ",
              must_be, "!");
        }();
      }
    }
  }
}
 
template <typename F, typename T, typename... Indexings,
          require_std_vector_t<T>* = nullptr>
inline void elementwise_check(const F& is_good, const char* function,
                              const char* name, const T& x, const char* must_be,
                              const Indexings&... indexings) {
  for (size_t j = 0; j < x.size(); j++) {
    elementwise_check(is_good, function, name, x[j], must_be, indexings..., "[",
                      j + error_index::value, "]");
  }
}
 
template <typename F, typename T, typename... Indexings,
          require_var_matrix_t<T>* = nullptr>
inline void elementwise_check(const F& is_good, const char* function,
                              const char* name, const T& x, const char* must_be,
                              const Indexings&... indexings) {
  elementwise_check(is_good, function, name, x.val(), must_be, indexings...);
}
 
template <typename F, typename T>
inline bool elementwise_is(const F& is_good, const T& x) {
  return internal::Iser<F>{is_good}.is(x);
}
 
}  // namespace math
}  // namespace stan
#endif