to_matrix.hpp

Go to the documentation of this file.

#ifndef STAN_MATH_PRIM_FUN_TO_MATRIX_HPP
#define STAN_MATH_PRIM_FUN_TO_MATRIX_HPP
 
#include <stan/math/prim/meta.hpp>
#include <stan/math/prim/err.hpp>
#include <stan/math/prim/fun/Eigen.hpp>
#include <vector>
 
namespace stan {
namespace math {
 
template <typename EigMat, require_eigen_dense_dynamic_t<EigMat>* = nullptr>
inline EigMat to_matrix(EigMat&& x) {
  return std::forward<EigMat>(x);
}
 
template <typename EigVec, require_eigen_vector_t<EigVec>* = nullptr>
inline auto to_matrix(EigVec&& matrix) {
  return Eigen::Matrix<value_type_t<EigVec>, Eigen::Dynamic, Eigen::Dynamic>(
      std::forward<EigVec>(matrix));
}
 
template <typename T>
inline Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic> to_matrix(
    const std::vector<Eigen::Matrix<T, Eigen::Dynamic, 1>>& x) {
  int cols = x.size();
  if (cols == 0) {
    return {};
  }
  int rows = x[0].size();
  Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic> result(rows, cols);
  for (int j = 0; j < cols; ++j) {
    result.col(j) = x[j];
  }
  return result;
}
 
template <typename T>
inline Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic> to_matrix(
    const std::vector<Eigen::Matrix<T, 1, Eigen::Dynamic>>& x) {
  int rows = x.size();
  if (rows == 0) {
    return {};
  }
  int cols = x[0].size();
  Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic> result(rows, cols);
  for (int i = 0, ij = 0; i < cols; i++) {
    for (int j = 0; j < rows; j++, ij++) {
      result.coeffRef(ij) = x[j][i];
    }
  }
  return result;
}
 
template <typename T>
inline Eigen::Matrix<return_type_t<T, double>, Eigen::Dynamic, Eigen::Dynamic>
to_matrix(const std::vector<std::vector<T>>& x) {
  size_t rows = x.size();
  if (rows == 0) {
    return {};
  }
  size_t cols = x[0].size();
  Eigen::Matrix<return_type_t<T, double>, Eigen::Dynamic, Eigen::Dynamic>
      result(rows, cols);
  for (size_t i = 0, ij = 0; i < cols; i++) {
    for (size_t j = 0; j < rows; j++, ij++) {
      result.coeffRef(ij) = x[j][i];
    }
  }
  return result;
}
 
template <typename EigMat, require_eigen_t<EigMat>* = nullptr>
inline Eigen::Matrix<value_type_t<EigMat>, Eigen::Dynamic, Eigen::Dynamic>
to_matrix(EigMat&& x, int m, int n) {
  static constexpr const char* function = "to_matrix(matrix)";
  check_size_match(function, "rows * columns", m * n, "vector size", x.size());
  Eigen::Matrix<value_type_t<EigMat>, Eigen::Dynamic, Eigen::Dynamic> y
      = std::forward<EigMat>(x);
  y.resize(m, n);
  return y;
}
 
template <typename T, require_std_vector_vt<is_stan_scalar, T>* = nullptr>
inline auto to_matrix(T&& x, int m, int n) {
  static constexpr const char* function = "to_matrix(array)";
  check_size_match(function, "rows * columns", m * n, "vector size", x.size());
  return make_holder(
      [m, n](auto&& x_) {
        if constexpr (std::is_integral_v<value_type_t<decltype(x_)>>) {
          return Eigen::Map<const Eigen::Matrix<
              value_type_t<decltype(x_)>, Eigen::Dynamic, Eigen::Dynamic>>(
                     &x_[0], m, n)
              .template cast<double>();
        } else {
          return Eigen::Map<const Eigen::Matrix<
              value_type_t<decltype(x_)>, Eigen::Dynamic, Eigen::Dynamic>>(
              &x_[0], m, n);
        }
      },
      std::forward<T>(x));
}
 
template <typename EigMat, require_eigen_t<EigMat>* = nullptr>
inline Eigen::Matrix<value_type_t<EigMat>, Eigen::Dynamic, Eigen::Dynamic>
to_matrix(EigMat&& x, int m, int n, bool col_major) {
  if (col_major) {
    return to_matrix(std::forward<EigMat>(x), m, n);
  } else {
    Eigen::Matrix<value_type_t<EigMat>, Eigen::Dynamic, Eigen::Dynamic> res
        = to_matrix(std::forward<EigMat>(x), n, m);
    res.transposeInPlace();
    return res;
  }
}
 
template <typename T>
inline Eigen::Matrix<return_type_t<T, double>, Eigen::Dynamic, Eigen::Dynamic>
to_matrix(const std::vector<T>& x, int m, int n, bool col_major) {
  if (col_major) {
    return to_matrix(x, m, n);
  }
  check_size_match("to_matrix", "rows * columns", m * n, "matrix size",
                   x.size());
  Eigen::Matrix<return_type_t<T, double>, Eigen::Dynamic, Eigen::Dynamic>
      result(m, n);
  for (int i = 0, ij = 0; i < m; i++) {
    for (int j = 0; j < n; j++, ij++) {
      result.coeffRef(i, j) = x[ij];
    }
  }
  return result;
}
 
}  // namespace math
}  // namespace stan
 
#endif