get_base1.hpp

Go to the documentation of this file.

#ifndef STAN_MATH_PRIM_FUN_GET_BASE1_HPP
#define STAN_MATH_PRIM_FUN_GET_BASE1_HPP
 
#include <stan/math/prim/meta.hpp>
#include <stan/math/prim/err.hpp>
#include <stan/math/prim/fun/Eigen.hpp>
#include <vector>
 
namespace stan {
namespace math {
 
template <typename T>
inline const T& get_base1(const std::vector<T>& x, size_t i,
                          const char* error_msg, size_t idx) {
  check_range("[]", "x", x.size(), i, idx, error_msg);
  return x[i - 1];
}
 
template <typename T>
inline const T& get_base1(const std::vector<std::vector<T> >& x, size_t i1,
                          size_t i2, const char* error_msg, size_t idx) {
  check_range("[]", "x", x.size(), i1, idx, error_msg);
  return get_base1(x[i1 - 1], i2, error_msg, idx + 1);
}
 
template <typename T>
inline const T& get_base1(const std::vector<std::vector<std::vector<T> > >& x,
                          size_t i1, size_t i2, size_t i3,
                          const char* error_msg, size_t idx) {
  check_range("[]", "x", x.size(), i1, idx, error_msg);
  return get_base1(x[i1 - 1], i2, i3, error_msg, idx + 1);
}
 
template <typename T>
inline const T& get_base1(
    const std::vector<std::vector<std::vector<std::vector<T> > > >& x,
    size_t i1, size_t i2, size_t i3, size_t i4, const char* error_msg,
    size_t idx) {
  check_range("[]", "x", x.size(), i1, idx, error_msg);
  return get_base1(x[i1 - 1], i2, i3, i4, error_msg, idx + 1);
}
 
template <typename T>
inline const T& get_base1(
    const std::vector<
        std::vector<std::vector<std::vector<std::vector<T> > > > >& x,
    size_t i1, size_t i2, size_t i3, size_t i4, size_t i5,
    const char* error_msg, size_t idx) {
  check_range("[]", "x", x.size(), i1, idx, error_msg);
  return get_base1(x[i1 - 1], i2, i3, i4, i5, error_msg, idx + 1);
}
 
template <typename T>
inline const T& get_base1(
    const std::vector<std::vector<
        std::vector<std::vector<std::vector<std::vector<T> > > > > >& x,
    size_t i1, size_t i2, size_t i3, size_t i4, size_t i5, size_t i6,
    const char* error_msg, size_t idx) {
  check_range("[]", "x", x.size(), i1, idx, error_msg);
  return get_base1(x[i1 - 1], i2, i3, i4, i5, i6, error_msg, idx + 1);
}
 
template <typename T>
inline const T& get_base1(
    const std::vector<std::vector<std::vector<
        std::vector<std::vector<std::vector<std::vector<T> > > > > > >& x,
    size_t i1, size_t i2, size_t i3, size_t i4, size_t i5, size_t i6, size_t i7,
    const char* error_msg, size_t idx) {
  check_range("[]", "x", x.size(), i1, idx, error_msg);
  return get_base1(x[i1 - 1], i2, i3, i4, i5, i6, i7, error_msg, idx + 1);
}
 
template <typename T>
inline const T& get_base1(
    const std::vector<std::vector<std::vector<std::vector<
        std::vector<std::vector<std::vector<std::vector<T> > > > > > > >& x,
    size_t i1, size_t i2, size_t i3, size_t i4, size_t i5, size_t i6, size_t i7,
    size_t i8, const char* error_msg, size_t idx) {
  check_range("[]", "x", x.size(), i1, idx, error_msg);
  return get_base1(x[i1 - 1], i2, i3, i4, i5, i6, i7, i8, error_msg, idx + 1);
}
 
template <typename EigMat, require_eigen_t<EigMat>* = nullptr,
          require_not_eigen_vector_t<EigMat>* = nullptr>
inline Eigen::Matrix<value_type_t<EigMat>, 1, Eigen::Dynamic> get_base1(
    const EigMat& x, size_t m, const char* error_msg, size_t idx) {
  check_range("[]", "rows of x", x.rows(), m, idx, error_msg);
  return x.row(m - 1);
}
 
template <typename EigMat, require_eigen_t<EigMat>* = nullptr>
inline const value_type_t<EigMat>& get_base1(const EigMat& x, size_t m,
                                             size_t n, const char* error_msg,
                                             size_t idx) {
  check_range("[]", "rows of x", x.rows(), m, idx, error_msg);
  check_range("[]", "cols of x", x.cols(), n, idx + 1, error_msg);
  return x.coeff(m - 1, n - 1);
}
 
template <typename EigVec, require_eigen_vector_t<EigVec>* = nullptr>
inline const value_type_t<EigVec>& get_base1(const EigVec& x, size_t m,
                                             const char* error_msg,
                                             size_t idx) {
  check_range("[]", "x", x.size(), m, idx, error_msg);
  return x.coeff(m - 1);
}
 
}  // namespace math
}  // namespace stan
 
#endif