1 #ifndef STAN_MODEL_INDEXING_RVALUE_HPP
2 #define STAN_MODEL_INDEXING_RVALUE_HPP
4 #include <boost/utility/enable_if.hpp>
5 #include <boost/type_traits/is_same.hpp>
7 #include <stan/math/prim/mat/err/check_range.hpp>
33 const char* =
"",
int = 0) {
51 inline T
rvalue(
const Eigen::Matrix<T, Eigen::Dynamic, 1>& v,
53 const char* name =
"ANON",
int depth = 0) {
55 math::check_range(
"vector[single] indexing", name, v.size(), ones_idx);
56 return v(ones_idx - 1);
74 inline T
rvalue(
const Eigen::Matrix<T, 1, Eigen::Dynamic>& rv,
76 const char* name =
"ANON",
int depth = 0) {
78 math::check_range(
"row_vector[single] indexing", name,
97 template <
typename T,
typename I>
99 typename boost::disable_if<boost::is_same<I, index_uni>,
100 Eigen::Matrix<T, Eigen::Dynamic, 1> >::type
101 rvalue(
const Eigen::Matrix<T, Eigen::Dynamic, 1>& v,
103 const char* name =
"ANON",
int depth = 0) {
105 Eigen::Matrix<T, Eigen::Dynamic, 1> a(size);
106 for (
int i = 0; i < size; ++i) {
108 math::check_range(
"vector[multi] indexing", name, v.size(), n);
129 template <
typename T,
typename I>
131 typename boost::disable_if<boost::is_same<I, index_uni>,
132 Eigen::Matrix<T, 1, Eigen::Dynamic> >::type
133 rvalue(
const Eigen::Matrix<T, 1, Eigen::Dynamic>& rv,
135 const char* name =
"ANON",
int depth = 0) {
137 Eigen::Matrix<T, 1, Eigen::Dynamic> a(size);
138 for (
int i = 0; i < size; ++i) {
140 math::check_range(
"row_vector[multi] indexing", name, rv.size(), n);
159 template <
typename T>
160 inline Eigen::Matrix<T, 1, Eigen::Dynamic>
161 rvalue(
const Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic>& a,
163 const char* name =
"ANON",
int depth = 0) {
165 math::check_range(
"matrix[uni] indexing", name, a.rows(), n);
183 template <
typename T,
typename I>
184 inline typename boost::disable_if<boost::is_same<I, index_uni>,
185 Eigen::Matrix<T, Eigen::Dynamic,
186 Eigen::Dynamic> >::type
187 rvalue(
const Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic>& a,
189 const char* name =
"ANON",
int depth = 0) {
191 Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic> b(n_rows, a.cols());
192 for (
int i = 0; i < n_rows; ++i) {
194 math::check_range(
"matrix[multi] indexing", name, a.rows(), n);
195 b.row(i) = a.row(n - 1);
213 template <
typename T>
215 rvalue(
const Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic>& a,
219 const char* name =
"ANON",
int depth = 0) {
220 int m = idx.head_.n_;
221 int n = idx.tail_.head_.n_;
222 math::check_range(
"matrix[uni,uni] indexing, row", name, a.rows(), m);
223 math::check_range(
"matrix[uni,uni] indexing, col", name, a.cols(), n);
224 return a(m - 1, n - 1);
242 template <
typename T,
typename I>
243 inline typename boost::disable_if<boost::is_same<I, index_uni>,
245 1, Eigen::Dynamic> >::type
246 rvalue(
const Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic>& a,
249 const char* name =
"ANON",
int depth = 0) {
250 int m = idx.head_.n_;
251 math::check_range(
"matrix[uni,multi] indexing, row", name, a.rows(), m);
252 Eigen::Matrix<T, 1, Eigen::Dynamic> r = a.row(m - 1);
253 return rvalue(r, idx.tail_);
271 template <
typename T,
typename I>
273 typename boost::disable_if<boost::is_same<I, index_uni>,
274 Eigen::Matrix<T, Eigen::Dynamic, 1> >::type
275 rvalue(
const Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic>& a,
278 const char* name =
"ANON",
int depth = 0) {
280 Eigen::Matrix<T, Eigen::Dynamic, 1> c(rows);
281 for (
int i = 0; i < rows; ++i) {
283 int n = idx.tail_.head_.n_;
284 math::check_range(
"matrix[multi,uni] index row", name, a.rows(), m);
285 math::check_range(
"matrix[multi,uni] index col", name, a.cols(), n);
286 c(i) = a(m - 1, n - 1);
306 template <
typename T,
typename I1,
typename I2>
308 typename boost::disable_if_c<boost::is_same<I1, index_uni>::value
309 || boost::is_same<I2, index_uni>::value,
310 Eigen::Matrix<T, Eigen::Dynamic,
311 Eigen::Dynamic> >::type
312 rvalue(
const Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic>& a,
315 const char* name =
"ANON",
int depth = 0) {
318 Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic> c(rows, cols);
319 for (
int j = 0; j < cols; ++j) {
320 for (
int i = 0; i < rows; ++i) {
323 math::check_range(
"matrix[multi,multi] row index", name,
325 math::check_range(
"matrix[multi,multi] col index", name,
327 c(i, j) = a(m - 1, n - 1);
349 template <
typename T,
typename L>
350 inline typename rvalue_return<std::vector<T>,
351 cons_index_list<index_uni, L> >::type
353 const char* name =
"ANON",
int depth = 0) {
355 math::check_range(
"array[uni,...] index", name, c.size(), n);
356 return rvalue(c[n - 1], idx.
tail_, name, depth + 1);
375 template <
typename T,
typename I,
typename L>
376 inline typename rvalue_return<std::vector<T>, cons_index_list<I, L> >::type
378 const char* name =
"ANON",
int depth = 0) {
383 math::check_range(
"array[multi,...] index", name, c.size(), n);
384 result.push_back(
rvalue(c[n - 1], idx.
tail_, name, depth + 1));
Primary template class for metaprogram to calculate return value for model::rvalue() for the containe...
int rvalue_index_size(const index_multi &idx, int size)
Return size of specified multi-index.
Probability, optimization and sampling library.
int rvalue_at(int n, const index_multi &idx)
Return the index in the underlying array corresponding to the specified position in the specified mul...
T rvalue(const T &c, const nil_index_list &, const char *="", int=0)
Return the result of indexing a specified value with a nil index list, which just returns the value...
Template structure for an index list consisting of a head and tail index.
Structure for an indexing consisting of a single index.
Structure for an empty (size zero) index list.