Stan  2.10.0
probability, sampling & optimization
rvalue.hpp
Go to the documentation of this file.
1 #ifndef STAN_MODEL_INDEXING_RVALUE_HPP
2 #define STAN_MODEL_INDEXING_RVALUE_HPP
3 
4 #include <boost/utility/enable_if.hpp>
5 #include <boost/type_traits/is_same.hpp>
6 #include <Eigen/Dense>
7 #include <stan/math/prim/mat/err/check_range.hpp>
13 #include <vector>
14 
15 namespace stan {
16 
17  namespace model {
18 
19  // all indexing from 1
20 
31  template <typename T>
32  inline T rvalue(const T& c, const nil_index_list& /*idx*/,
33  const char* /*name*/ = "", int /*depth*/ = 0) {
34  return c;
35  }
36 
50  template <typename T>
51  inline T rvalue(const Eigen::Matrix<T, Eigen::Dynamic, 1>& v,
53  const char* name = "ANON", int depth = 0) {
54  int ones_idx = idx.head_.n_;
55  math::check_range("vector[single] indexing", name, v.size(), ones_idx);
56  return v(ones_idx - 1);
57  }
58 
73  template <typename T>
74  inline T rvalue(const Eigen::Matrix<T, 1, Eigen::Dynamic>& rv,
76  const char* name = "ANON", int depth = 0) {
77  int n = idx.head_.n_;
78  math::check_range("row_vector[single] indexing", name,
79  rv.size(), n);
80  return rv(n - 1);
81  }
82 
97  template <typename T, typename I>
98  inline
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) {
104  int size = rvalue_index_size(idx.head_, v.size());
105  Eigen::Matrix<T, Eigen::Dynamic, 1> a(size);
106  for (int i = 0; i < size; ++i) {
107  int n = rvalue_at(i, idx.head_);
108  math::check_range("vector[multi] indexing", name, v.size(), n);
109  a(i) = v(n - 1);
110  }
111  return a;
112  }
113 
129  template <typename T, typename I>
130  inline
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) {
136  int size = rvalue_index_size(idx.head_, rv.size());
137  Eigen::Matrix<T, 1, Eigen::Dynamic> a(size);
138  for (int i = 0; i < size; ++i) {
139  int n = rvalue_at(i, idx.head_);
140  math::check_range("row_vector[multi] indexing", name, rv.size(), n);
141  a(i) = rv(n - 1);
142  }
143  return a;
144  }
145 
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) {
164  int n = idx.head_.n_;
165  math::check_range("matrix[uni] indexing", name, a.rows(), n);
166  return a.row(n - 1);
167  }
168 
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) {
190  int n_rows = rvalue_index_size(idx.head_, a.rows());
191  Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic> b(n_rows, a.cols());
192  for (int i = 0; i < n_rows; ++i) {
193  int n = rvalue_at(i, idx.head_);
194  math::check_range("matrix[multi] indexing", name, a.rows(), n);
195  b.row(i) = a.row(n - 1);
196  }
197  return b;
198  }
199 
213  template <typename T>
214  inline T
215  rvalue(const Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic>& a,
218  nil_index_list> >& idx,
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);
225  }
226 
242  template <typename T, typename I>
243  inline typename boost::disable_if<boost::is_same<I, index_uni>,
244  Eigen::Matrix<T,
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_);
254  }
255 
271  template <typename T, typename I>
272  inline
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,
277  nil_index_list> >& idx,
278  const char* name = "ANON", int depth = 0) {
279  int rows = rvalue_index_size(idx.head_, a.rows());
280  Eigen::Matrix<T, Eigen::Dynamic, 1> c(rows);
281  for (int i = 0; i < rows; ++i) {
282  int m = rvalue_at(i, idx.head_);
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);
287  }
288  return c;
289  }
290 
306  template <typename T, typename I1, typename I2>
307  inline
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,
313  const cons_index_list<I1, cons_index_list<I2,
314  nil_index_list> >& idx,
315  const char* name = "ANON", int depth = 0) {
316  int rows = rvalue_index_size(idx.head_, a.rows());
317  int cols = rvalue_index_size(idx.tail_.head_, a.cols());
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) {
321  int m = rvalue_at(i, idx.head_);
322  int n = rvalue_at(j, idx.tail_.head_);
323  math::check_range("matrix[multi,multi] row index", name,
324  a.rows(), m);
325  math::check_range("matrix[multi,multi] col index", name,
326  a.cols(), n);
327  c(i, j) = a(m - 1, n - 1);
328  }
329  }
330  return c;
331  }
332 
349  template <typename T, typename L>
350  inline typename rvalue_return<std::vector<T>,
351  cons_index_list<index_uni, L> >::type
352  rvalue(const std::vector<T>& c, const cons_index_list<index_uni, L>& idx,
353  const char* name = "ANON", int depth = 0) {
354  int n = idx.head_.n_;
355  math::check_range("array[uni,...] index", name, c.size(), n);
356  return rvalue(c[n - 1], idx.tail_, name, depth + 1);
357  }
358 
375  template <typename T, typename I, typename L>
376  inline typename rvalue_return<std::vector<T>, cons_index_list<I, L> >::type
377  rvalue(const std::vector<T>& c, const cons_index_list<I, L>& idx,
378  const char* name = "ANON", int depth = 0) {
380  cons_index_list<I, L> >::type result;
381  for (int i = 0; i < rvalue_index_size(idx.head_, c.size()); ++i) {
382  int n = rvalue_at(i, idx.head_);
383  math::check_range("array[multi,...] index", name, c.size(), n);
384  result.push_back(rvalue(c[n - 1], idx.tail_, name, depth + 1));
385  }
386  return result;
387  }
388 
389 
390  }
391 }
392 #endif
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...
Definition: rvalue_at.hpp:21
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...
Definition: rvalue.hpp:32
Template structure for an index list consisting of a head and tail index.
Definition: index_list.hpp:23
Structure for an indexing consisting of a single index.
Definition: index.hpp:17
Structure for an empty (size zero) index list.
Definition: index_list.hpp:11

     [ Stan Home Page ] © 2011–2016, Stan Development Team.