vector_seq_view.hpp

Go to the documentation of this file.

#ifndef STAN_MATH_PRIM_FUN_VECTOR_SEQ_VIEW_HPP
#define STAN_MATH_PRIM_FUN_VECTOR_SEQ_VIEW_HPP
 
#include <stan/math/prim/fun/Eigen.hpp>
#include <stan/math/prim/meta.hpp>
#include <vector>
 
namespace stan {
 
template <typename T, typename = void>
class vector_seq_view;
 
template <typename T>
class vector_seq_view<T, require_matrix_t<T>> {
 public:
  explicit vector_seq_view(const T& m) : m_(m) {}
  static constexpr auto size() { return 1; }
  inline const auto& operator[](size_t /* i */) const noexcept { return m_; }
 
  template <typename C = T, require_st_arithmetic<C>* = nullptr>
  inline const auto& val(size_t /* i */) const noexcept {
    return m_;
  }
 
  template <typename C = T, require_st_autodiff<C>* = nullptr>
  inline auto val(size_t /* i */) const noexcept {
    return m_.val();
  }
 
 private:
  const ref_type_t<T> m_;
};
 
namespace internal {
template <typename T>
using is_matrix_or_std_vector
    = math::disjunction<is_matrix<T>, is_std_vector<T>>;
}
 
template <typename T>
class vector_seq_view<
    T, require_std_vector_vt<internal::is_matrix_or_std_vector, T>> {
 public:
  explicit vector_seq_view(const T& v) noexcept : v_(v) {}
  inline auto size() const noexcept { return v_.size(); }
 
  inline decltype(auto) operator[](size_t i) const { return v_[i]; }
 
  template <typename C = T, require_st_arithmetic<C>* = nullptr>
  inline decltype(auto) val(size_t i) const {
    return v_[i];
  }
 
  template <typename C = T, require_st_autodiff<C>* = nullptr>
  inline auto val(size_t i) const {
    return value_of(v_[i]);
  }
 
 private:
  const T& v_;
};
 
}  // namespace stan
 
#endif