Stan  2.10.0
probability, sampling & optimization
lvalue.hpp
Go to the documentation of this file.
1 #ifndef STAN_MODEL_INDEXING_LVALUE_HPP
2 #define STAN_MODEL_INDEXING_LVALUE_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/scal/err/check_equal.hpp>
8 #include <stan/math/prim/mat/err/check_range.hpp>
13 #include <vector>
14 
15 namespace stan {
16 
17  namespace model {
18 
32  template <typename T, typename U>
33  inline void assign(T& x, const nil_index_list& /* idxs */, const U& y,
34  const char* name = "ANON", int depth = 0) {
35  x = y;
36  }
37 
38  template <typename T, typename U, int R, int C>
39  inline void assign(Eigen::Matrix<T, R, C>& x,
40  const nil_index_list& /* idxs */,
41  const Eigen::Matrix<U, R, C>& y,
42  const char* name = "ANON",
43  int depth = 0) {
44  x.resize(y.rows(), y.cols());
45  for (size_t i = 0; i < y.size(); ++i)
46  assign(x(i), nil_index_list(), y(i), name, depth + 1);
47  }
48 
49 
50  template <typename T, typename U>
51  inline void assign(std::vector<T>& x, const nil_index_list& /* idxs */,
52  const std::vector<U>& y, const char* name = "ANON",
53  int depth = 0) {
54  x.resize(y.size());
55  for (size_t i = 0; i < y.size(); ++i)
56  assign(x[i], nil_index_list(), y[i], name, depth + 1);
57  }
58 
59 
75  template <typename T, typename U>
76  inline void assign(Eigen::Matrix<T, Eigen::Dynamic, 1>& x,
78  const U& y,
79  const char* name = "ANON", int depth = 0) {
80  int i = idxs.head_.n_;
81  math::check_range("vector[uni] assign range", name, x.size(), i);
82  x(i - 1) = y;
83  }
84 
100  template <typename T, typename U>
101  inline void assign(Eigen::Matrix<T, 1, Eigen::Dynamic>& x,
103  const U& y,
104  const char* name = "ANON", int depth = 0) {
105  int i = idxs.head_.n_;
106  math::check_range("row_vector[uni] assign range", name, x.size(), i);
107  x(i - 1) = y;
108  }
109 
128  template <typename T, typename I, typename U>
129  inline typename boost::disable_if<boost::is_same<I, index_uni>, void>::type
130  assign(Eigen::Matrix<T, Eigen::Dynamic, 1>& x,
132  const Eigen::Matrix<U, Eigen::Dynamic, 1>& y,
133  const char* name = "ANON", int depth = 0) {
134  math::check_equal("vector[multi] assign sizes", name, y.size(),
135  rvalue_index_size(idxs.head_, x.size()));
136  for (int n = 0; n < y.size(); ++n) {
137  int i = rvalue_at(n, idxs.head_);
138  math::check_range("vector[multi] assign range", name, x.size(), i);
139  x(i - 1) = y(n);
140  }
141  }
142 
162  template <typename T, typename I, typename U>
163  inline typename boost::disable_if<boost::is_same<I, index_uni>, void>::type
164  assign(Eigen::Matrix<T, 1, Eigen::Dynamic>& x,
166  const Eigen::Matrix<U, 1, Eigen::Dynamic>& y,
167  const char* name = "ANON", int depth = 0) {
168  using stan::math::check_equal;
169  check_equal("row_vector[multi] assign sizes",
170  name, y.size(), rvalue_index_size(idxs.head_, x.size()));
171  for (int n = 0; n < y.size(); ++n) {
172  int i = rvalue_at(n, idxs.head_);
173  math::check_range("row_vector[multi] assign range", name, x.size(), i);
174  x(i - 1) = y(n);
175  }
176  }
177 
196  template <typename T, typename U>
197  void assign(Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic>& x,
199  const Eigen::Matrix<U, 1, Eigen::Dynamic>& y,
200  const char* name = "ANON", int depth = 0) {
201  math::check_equal("matrix[uni] assign sizes", name, y.cols(), x.cols());
202  int i = idxs.head_.n_;
203  math::check_range("matrix[uni] assign range", name, x.rows(), i);
204  for (int j = 0; j < x.cols(); ++j) // loop allows double to var assgn
205  x(i - 1, j) = y(j);
206  }
207 
226  template <typename T, typename I, typename U>
227  inline typename boost::disable_if<boost::is_same<I, index_uni>, void>::type
228  assign(Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic>& x,
230  const Eigen::Matrix<U, Eigen::Dynamic, Eigen::Dynamic>& y,
231  const char* name = "ANON", int depth = 0) {
232  int x_idx_rows = rvalue_index_size(idxs.head_, x.rows());
233  math::check_equal("matrix[multi] assign row sizes", name, y.rows(),
234  x_idx_rows);
235  math::check_equal("matrix[multi] assign col sizes", name, y.cols(),
236  x.cols());
237  for (int i = 0; i < y.rows(); ++i) {
238  int m = rvalue_at(i, idxs.head_);
239  math::check_range("matrix[multi] assign range", name, x.rows(), m);
240  // recurse to allow double to var assign
241  for (int j = 0; j < x.cols(); ++j)
242  x(m - 1, j) = y(i, j);
243  }
244  }
245 
261  template <typename T, typename U>
262  void assign(Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic>& x,
265  nil_index_list> >& idxs,
266  const U& y,
267  const char* name = "ANON", int depth = 0) {
268  int m = idxs.head_.n_;
269  int n = idxs.tail_.head_.n_;
270  math::check_range("matrix[uni,uni] assign range", name, x.rows(), m);
271  math::check_range("matrix[uni,uni] assign range", name, x.cols(), n);
272  x(m - 1, n - 1) = y;
273  }
274 
294  template <typename T, typename I, typename U>
295  inline typename boost::disable_if<boost::is_same<I, index_uni>, void>::type
296  assign(Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic>& x,
299  const Eigen::Matrix<U, 1, Eigen::Dynamic>& y,
300  const char* name = "ANON", int depth = 0) {
301  int x_idxs_cols = rvalue_index_size(idxs.tail_.head_, x.cols());
302  math::check_equal("matrix[uni,multi] assign sizes", name, y.cols(),
303  x_idxs_cols);
304  int m = idxs.head_.n_;
305  math::check_range("matrix[uni,multi] assign range", name, x.rows(), m);
306  for (int i = 0; i < y.size(); ++i) {
307  int n = rvalue_at(i, idxs.tail_.head_);
308  math::check_range("matrix[uni,multi] assign range", name, x.cols(), n);
309  x(m - 1, n - 1) = y(i);
310  }
311  }
312 
331  template <typename T, typename I, typename U>
332  inline typename boost::disable_if<boost::is_same<I, index_uni>, void>::type
333  assign(Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic>& x,
334  const cons_index_list<I,
336  nil_index_list> >& idxs,
337  const Eigen::Matrix<U, Eigen::Dynamic, 1>& y,
338  const char* name = "ANON", int depth = 0) {
339  int x_idxs_rows = rvalue_index_size(idxs.head_, x.rows());
340  math::check_equal("matrix[multi,uni] assign sizes", name, y.rows(),
341  x_idxs_rows);
342  int n = idxs.tail_.head_.n_;
343  math::check_range("matrix[multi,uni] assign range", name, x.cols(), n);
344  for (int i = 0; i < y.size(); ++i) {
345  int m = rvalue_at(i, idxs.head_);
346  math::check_range("matrix[multi,uni] assign range", name, x.rows(), m);
347  x(m - 1, n - 1) = y(i);
348  }
349  }
350 
370  template <typename T, typename I1, typename I2, typename U>
371  inline typename
372  boost::disable_if_c<boost::is_same<I1, index_uni>::value
373  || boost::is_same<I2, index_uni>::value, void>::type
374  assign(Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic>& x,
375  const cons_index_list<I1,
377  const Eigen::Matrix<U, Eigen::Dynamic, Eigen::Dynamic>& y,
378  const char* name = "ANON", int depth = 0) {
379  int x_idxs_rows = rvalue_index_size(idxs.head_, x.rows());
380  int x_idxs_cols = rvalue_index_size(idxs.tail_.head_, x.cols());
381  math::check_equal("matrix[multi,multi] assign sizes", name, y.rows(),
382  x_idxs_rows);
383  math::check_equal("matrix[multi,multi] assign sizes", name, y.cols(),
384  x_idxs_cols);
385  for (int j = 0; j < y.cols(); ++j) {
386  int n = rvalue_at(j, idxs.tail_.head_);
387  math::check_range("matrix[multi,multi] assign range", name,
388  x.cols(), n);
389  for (int i = 0; i < y.rows(); ++i) {
390  int m = rvalue_at(i, idxs.head_);
391  math::check_range("matrix[multi,multi] assign range", name,
392  x.rows(), m);
393  x(m - 1, n - 1) = y(i, j);
394  }
395  }
396  }
397 
421  template <typename T, typename L, typename U>
422  inline void assign(std::vector<T>& x,
423  const cons_index_list<index_uni, L>& idxs, const U& y,
424  const char* name = "ANON", int depth = 0) {
425  int i = idxs.head_.n_;
426  math::check_range("vector[uni,...] assign range", name, x.size(), i);
427  assign(x[i - 1], idxs.tail_, y, name, depth + 1);
428  }
429 
455  template <typename T, typename I, typename L, typename U>
456  typename boost::disable_if<boost::is_same<I, index_uni>, void>::type
457  inline assign(std::vector<T>& x, const cons_index_list<I, L>& idxs,
458  const std::vector<U>& y,
459  const char* name = "ANON", int depth = 0) {
460  int x_idx_size = rvalue_index_size(idxs.head_, x.size());
461  math::check_equal("vector[multi,...] assign sizes", name, y.size(),
462  x_idx_size);
463  for (size_t n = 0; n < y.size(); ++n) {
464  int i = rvalue_at(n, idxs.head_);
465  math::check_range("vector[multi,...] assign range", name, x.size(), i);
466  assign(x[i - 1], idxs.tail_, y[n], name, depth + 1);
467  }
468  }
469 
470  }
471 }
472 #endif
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
void assign(T &x, const nil_index_list &, const U &y, const char *name="ANON", int depth=0)
Assign the specified scalar reference under the specified indexing to the specified scalar value...
Definition: lvalue.hpp:33
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.