as_column_vector_or_scalar.hpp

Go to the documentation of this file.

#ifndef STAN_MATH_PRIM_FUN_AS_COLUMN_VECTOR_OR_SCALAR_HPP
#define STAN_MATH_PRIM_FUN_AS_COLUMN_VECTOR_OR_SCALAR_HPP
 
#include <stan/math/prim/fun/Eigen.hpp>
#include <stan/math/prim/meta.hpp>
#include <vector>
 
namespace stan {
namespace math {
namespace internal {
template <typename T, typename S, typename Enable>
class empty_broadcast_array;
}
template <typename T, require_stan_scalar_t<T>* = nullptr>
inline T as_column_vector_or_scalar(const T& a) {
  return a;
}
 
template <typename T, typename S>
internal::empty_broadcast_array<T, S, void>& as_column_vector_or_scalar(
    internal::empty_broadcast_array<T, S, void>& a);
 
template <typename T, require_eigen_col_vector_t<T>* = nullptr>
inline T&& as_column_vector_or_scalar(T&& a) {
  return std::forward<T>(a);
}
 
template <typename T, require_eigen_row_vector_t<T>* = nullptr,
          require_not_eigen_col_vector_t<T>* = nullptr>
inline auto as_column_vector_or_scalar(T&& a) {
  return make_holder([](auto&& x) { return x.transpose(); },
                     std::forward<T>(a));
}
 
template <typename T, require_std_vector_t<T>* = nullptr>
inline auto as_column_vector_or_scalar(T&& a) {
  using plain_vector = Eigen::Matrix<value_type_t<T>, Eigen::Dynamic, 1>;
  using optionally_const_vector
      = std::conditional_t<std::is_const<std::remove_reference_t<T>>::value,
                           const plain_vector, plain_vector>;
  using T_map = Eigen::Map<optionally_const_vector>;
  return make_holder([](auto&& x) { return T_map(x.data(), x.size()); },
                     std::forward<T>(a));
}
 
}  // namespace math
}  // namespace stan
 
#endif