check_consistent_sizes.hpp

Go to the documentation of this file.

#ifndef STAN_MATH_PRIM_ERR_CHECK_CONSISTENT_SIZES_HPP
#define STAN_MATH_PRIM_ERR_CHECK_CONSISTENT_SIZES_HPP
 
#include <stan/math/prim/err/check_matching_sizes.hpp>
#include <stan/math/prim/err/invalid_argument.hpp>
#include <stan/math/prim/fun/size.hpp>
#include <stan/math/prim/meta/is_container.hpp>
#include <stan/math/prim/meta/require_generics.hpp>
#include <algorithm>
#include <sstream>
#include <string>
 
namespace stan {
namespace math {
 
inline void check_consistent_sizes(const char*) { return; }
 
template <typename T1>
inline void check_consistent_sizes(const char*, const char*, const T1&) {
  return;
}
 
template <typename T1, typename T2, typename... Ts>
inline void check_consistent_sizes(const char* function, const char* name1,
                                   const T1& x1, const char* name2,
                                   const T2& x2, const Ts&... names_and_xs) {
  if constexpr (!is_vector<T1>::value && is_vector<T2>::value) {
    check_consistent_sizes(function, name2, x2, name1, x1, names_and_xs...);
  } else if constexpr (!is_vector<T2>::value) {
    check_consistent_sizes(function, name1, x1, names_and_xs...);
  } else if (stan::math::size(x1) == stan::math::size(x2)) {
    check_consistent_sizes(function, name1, x1, names_and_xs...);
  } else {
    [&]() STAN_COLD_PATH {
      size_t size_x1 = stan::math::size(x1);
      size_t size_x2 = stan::math::size(x2);
      std::stringstream msg;
      msg << ", but " << name2 << " has size " << size_x2
          << "; and they must be the same size.";
      std::string msg_str(msg.str());
      invalid_argument(function, name1, size_x1,
                       "has size = ", msg_str.c_str());
    }();
  }
}
 
template <typename T, typename... Types,
          require_all_container_t<T, Types...>* = nullptr>
inline void check_consistent_sizes(const char* function, T&& x, Types&&... xs) {
  std::size_t arg_idx = 2;
  (
      [&](const auto& y) {
        if (x.size() != y.size()) {
          [&]() STAN_COLD_PATH {
            const std::string name = "arg" + std::to_string(arg_idx);
            check_matching_sizes(function, "arg1", x, name.c_str(), y);
          }();
        }
        ++arg_idx;
      }(xs),
      ...);
}
 
}  // namespace math
}  // namespace stan
#endif