lvalue.hpp

Go to the documentation of this file.

#ifndef STAN_MODEL_INDEXING_LVALUE_HPP
#define STAN_MODEL_INDEXING_LVALUE_HPP

#include <boost/utility/enable_if.hpp>
#include <boost/type_traits/is_same.hpp>
#include <Eigen/Dense>
#include <stan/math/prim/mat.hpp>
#include <stan/model/indexing/index.hpp>
#include <stan/model/indexing/index_list.hpp>
#include <stan/model/indexing/rvalue_at.hpp>
#include <stan/model/indexing/rvalue_index_size.hpp>
#include <vector>

namespace stan {

  namespace model {

    template <typename T, typename U>
    inline void assign(T& x, const nil_index_list& /* idxs */, const U& y,
                       const char* name = "ANON", int depth = 0) {
      x = y;
    }

    template <typename T, typename U, int R, int C>
    inline void assign(Eigen::Matrix<T, R, C>& x,
                       const nil_index_list& /* idxs */,
                       const Eigen::Matrix<U, R, C>& y,
                       const char* name = "ANON",
                       int depth = 0) {
      x.resize(y.rows(), y.cols());
      for (size_t i = 0; i < y.size(); ++i)
        assign(x(i), nil_index_list(), y(i), name, depth + 1);
    }


    template <typename T, typename U>
    inline void assign(std::vector<T>& x, const nil_index_list& /* idxs */,
                       const std::vector<U>& y, const char* name = "ANON",
                       int depth = 0) {
      x.resize(y.size());
      for (size_t i = 0; i < y.size(); ++i)
        assign(x[i], nil_index_list(), y[i], name, depth + 1);
    }


    template <typename T, typename U>
    inline void assign(Eigen::Matrix<T, Eigen::Dynamic, 1>& x,
                       const cons_index_list<index_uni, nil_index_list>& idxs,
                       const U& y,
                       const char* name = "ANON", int depth = 0) {
      int i = idxs.head_.n_;
      math::check_range("vector[uni] assign range", name, x.size(), i);
      x(i - 1) = y;
    }

    template <typename T, typename U>
    inline void assign(Eigen::Matrix<T, 1, Eigen::Dynamic>& x,
                       const cons_index_list<index_uni, nil_index_list>& idxs,
                       const U& y,
                       const char* name = "ANON", int depth = 0) {
      int i = idxs.head_.n_;
      math::check_range("row_vector[uni] assign range", name, x.size(), i);
      x(i - 1) = y;
    }

    template <typename T, typename I, typename U>
    inline typename boost::disable_if<boost::is_same<I, index_uni>, void>::type
    assign(Eigen::Matrix<T, Eigen::Dynamic, 1>& x,
           const cons_index_list<I, nil_index_list>& idxs,
           const Eigen::Matrix<U, Eigen::Dynamic, 1>& y,
           const char* name = "ANON", int depth = 0) {
      math::check_equal("vector[multi] assign sizes", name, y.size(),
                        rvalue_index_size(idxs.head_, x.size()));
      for (int n = 0; n < y.size(); ++n) {
        int i = rvalue_at(n, idxs.head_);
        math::check_range("vector[multi] assign range", name, x.size(), i);
        x(i - 1) = y(n);
      }
    }

    template <typename T, typename I, typename U>
    inline typename boost::disable_if<boost::is_same<I, index_uni>, void>::type
    assign(Eigen::Matrix<T, 1, Eigen::Dynamic>& x,
           const cons_index_list<I, nil_index_list>& idxs,
           const Eigen::Matrix<U, 1, Eigen::Dynamic>& y,
           const char* name = "ANON", int depth = 0) {
      using stan::math::check_equal;
      check_equal("row_vector[multi] assign sizes",
                  name, y.size(), rvalue_index_size(idxs.head_, x.size()));
      for (int n = 0; n < y.size(); ++n) {
        int i = rvalue_at(n, idxs.head_);
        math::check_range("row_vector[multi] assign range", name, x.size(), i);
        x(i - 1) = y(n);
      }
    }

    template <typename T, typename U>
    void assign(Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic>& x,
                const cons_index_list<index_uni, nil_index_list>& idxs,
                const Eigen::Matrix<U, 1, Eigen::Dynamic>& y,
                const char* name = "ANON", int depth = 0) {
      math::check_equal("matrix[uni] assign sizes", name, y.cols(), x.cols());
      int i = idxs.head_.n_;
      math::check_range("matrix[uni] assign range", name, x.rows(), i);
      for (int j = 0; j < x.cols(); ++j)  // loop allows double to var assgn
        x(i - 1, j) = y(j);
    }

    template <typename T, typename I, typename U>
    inline typename boost::disable_if<boost::is_same<I, index_uni>, void>::type
    assign(Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic>& x,
           const cons_index_list<I, nil_index_list>& idxs,
           const Eigen::Matrix<U, Eigen::Dynamic, Eigen::Dynamic>& y,
           const char* name = "ANON", int depth = 0) {
      int x_idx_rows = rvalue_index_size(idxs.head_, x.rows());
      math::check_equal("matrix[multi] assign row sizes", name, y.rows(),
                        x_idx_rows);
      math::check_equal("matrix[multi] assign col sizes", name, y.cols(),
                        x.cols());
      for (int i = 0; i < y.rows(); ++i) {
        int m = rvalue_at(i, idxs.head_);
        math::check_range("matrix[multi] assign range", name, x.rows(), m);
        // recurse to allow double to var assign
        for (int j = 0; j < x.cols(); ++j)
          x(m - 1, j) = y(i, j);
      }
    }

    template <typename T, typename U>
    void assign(Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic>& x,
                const cons_index_list<index_uni,
                                      cons_index_list<index_uni,
                                                      nil_index_list> >& idxs,
                const U& y,
                const char* name = "ANON", int depth = 0) {
      int m = idxs.head_.n_;
      int n = idxs.tail_.head_.n_;
      math::check_range("matrix[uni,uni] assign range", name, x.rows(), m);
      math::check_range("matrix[uni,uni] assign range", name, x.cols(), n);
      x(m - 1, n - 1) = y;
    }

    template <typename T, typename I, typename U>
    inline typename boost::disable_if<boost::is_same<I, index_uni>, void>::type
    assign(Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic>& x,
           const cons_index_list<index_uni,
                                 cons_index_list<I, nil_index_list> >& idxs,
           const Eigen::Matrix<U, 1, Eigen::Dynamic>& y,
           const char* name = "ANON", int depth = 0) {
      int x_idxs_cols = rvalue_index_size(idxs.tail_.head_, x.cols());
      math::check_equal("matrix[uni,multi] assign sizes", name, y.cols(),
                        x_idxs_cols);
      int m = idxs.head_.n_;
      math::check_range("matrix[uni,multi] assign range", name, x.rows(), m);
      for (int i = 0; i < y.size(); ++i) {
        int n = rvalue_at(i, idxs.tail_.head_);
        math::check_range("matrix[uni,multi] assign range", name, x.cols(), n);
        x(m - 1, n - 1) = y(i);
      }
    }

    template <typename T, typename I, typename U>
    inline typename boost::disable_if<boost::is_same<I, index_uni>, void>::type
    assign(Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic>& x,
           const cons_index_list<I,
                                 cons_index_list<index_uni,
                                                 nil_index_list> >& idxs,
           const Eigen::Matrix<U, Eigen::Dynamic, 1>& y,
           const char* name = "ANON", int depth = 0) {
      int x_idxs_rows = rvalue_index_size(idxs.head_, x.rows());
      math::check_equal("matrix[multi,uni] assign sizes", name, y.rows(),
                        x_idxs_rows);
      int n = idxs.tail_.head_.n_;
      math::check_range("matrix[multi,uni] assign range", name, x.cols(), n);
      for (int i = 0; i < y.size(); ++i) {
        int m = rvalue_at(i, idxs.head_);
        math::check_range("matrix[multi,uni] assign range", name, x.rows(), m);
        x(m - 1, n - 1) = y(i);
      }
    }

    template <typename T, typename I1, typename I2, typename U>
    inline typename
    boost::disable_if_c<boost::is_same<I1, index_uni>::value
                        || boost::is_same<I2, index_uni>::value, void>::type
    assign(Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic>& x,
           const cons_index_list<I1,
                                 cons_index_list<I2, nil_index_list> >& idxs,
           const Eigen::Matrix<U, Eigen::Dynamic, Eigen::Dynamic>& y,
           const char* name = "ANON", int depth = 0) {
      int x_idxs_rows = rvalue_index_size(idxs.head_, x.rows());
      int x_idxs_cols = rvalue_index_size(idxs.tail_.head_, x.cols());
      math::check_equal("matrix[multi,multi] assign sizes", name, y.rows(),
                        x_idxs_rows);
      math::check_equal("matrix[multi,multi] assign sizes", name, y.cols(),
                        x_idxs_cols);
      for (int j = 0; j < y.cols(); ++j) {
        int n = rvalue_at(j, idxs.tail_.head_);
        math::check_range("matrix[multi,multi] assign range", name,
                          x.cols(), n);
        for (int i = 0; i < y.rows(); ++i) {
          int m = rvalue_at(i, idxs.head_);
          math::check_range("matrix[multi,multi] assign range", name,
                            x.rows(), m);
          x(m - 1, n - 1) = y(i, j);
        }
      }
    }

    template <typename T, typename L, typename U>
    inline void assign(std::vector<T>& x,
                       const cons_index_list<index_uni, L>& idxs, const U& y,
                       const char* name = "ANON", int depth = 0) {
      int i = idxs.head_.n_;
      math::check_range("vector[uni,...] assign range", name, x.size(), i);
      assign(x[i - 1], idxs.tail_, y, name, depth + 1);
    }

    template <typename T, typename I, typename L, typename U>
    typename boost::disable_if<boost::is_same<I, index_uni>, void>::type
    inline assign(std::vector<T>& x, const cons_index_list<I, L>& idxs,
                  const std::vector<U>& y,
                  const char* name = "ANON", int depth = 0) {
      int x_idx_size = rvalue_index_size(idxs.head_, x.size());
      math::check_equal("vector[multi,...] assign sizes", name, y.size(),
                        x_idx_size);
      for (size_t n = 0; n < y.size(); ++n) {
        int i = rvalue_at(n, idxs.head_);
        math::check_range("vector[multi,...] assign range", name, x.size(), i);
        assign(x[i - 1], idxs.tail_, y[n], name, depth + 1);
      }
    }

  }
}
#endif