is_vector.hpp

Go to the documentation of this file.

#ifndef STAN_MATH_PRIM_META_IS_VECTOR_HPP
#define STAN_MATH_PRIM_META_IS_VECTOR_HPP
 
#include <stan/math/prim/meta/bool_constant.hpp>
#include <stan/math/prim/meta/is_eigen.hpp>
#include <stan/math/prim/meta/is_var.hpp>
#include <stan/math/prim/meta/scalar_type.hpp>
#include <stan/math/prim/meta/value_type.hpp>
#include <stan/math/prim/meta/require_helpers.hpp>
#include <type_traits>
#include <vector>
 
namespace stan {
 
template <typename T, typename = void>
struct is_std_vector : std::false_type {};
 
namespace internal {
template <typename T, bool = is_eigen<T>::value>
struct is_eigen_col_vector_impl
    : bool_constant<std::decay_t<T>::ColsAtCompileTime == 1> {};
 
template <typename T>
struct is_eigen_col_vector_impl<T, false> : std::false_type {};
 
template <typename T, bool = is_eigen<T>::value>
struct is_eigen_row_vector_impl
    : std::integral_constant<bool, std::decay_t<T>::RowsAtCompileTime == 1> {};
 
template <typename T>
struct is_eigen_row_vector_impl<T, false> : std::false_type {};
 
template <typename T, bool = bool_constant<is_eigen<T>::value
                                           || (is_eigen<value_type_t<T>>::value
                                               && is_var<T>::value)>::value>
struct is_col_vector_impl
    : bool_constant<std::decay_t<T>::ColsAtCompileTime == 1> {};
 
template <typename T>
struct is_col_vector_impl<T, false> : std::false_type {};
 
template <typename T, bool = bool_constant<is_eigen<T>::value
                                           || (is_eigen<value_type_t<T>>::value
                                               && is_var<T>::value)>::value>
struct is_row_vector_impl
    : std::integral_constant<bool, std::decay_t<T>::RowsAtCompileTime == 1> {};
 
template <typename T>
struct is_row_vector_impl<T, false> : std::false_type {};
 
}  // namespace internal
 
template <typename T>
struct is_eigen_col_vector : internal::is_eigen_col_vector_impl<T> {};
 
template <typename T>
using require_eigen_col_vector_t
    = require_t<is_eigen_col_vector<std::decay_t<T>>>;
 
template <typename T>
using require_not_eigen_col_vector_t
    = require_not_t<is_eigen_col_vector<std::decay_t<T>>>;
 
template <typename... Types>
using require_all_eigen_col_vector_t
    = require_all_t<is_eigen_col_vector<std::decay_t<Types>>...>;
template <template <class...> class TypeCheck, class... Check>
using require_eigen_col_vector_vt
    = require_t<container_type_check_base<is_eigen_col_vector, value_type_t,
                                          TypeCheck, Check...>>;
template <typename T>
struct is_col_vector : internal::is_col_vector_impl<T> {};
 
template <typename T>
using require_col_vector_t = require_t<is_col_vector<std::decay_t<T>>>;
 
template <typename T>
using require_not_col_vector_t = require_not_t<is_col_vector<std::decay_t<T>>>;
 
template <typename... Types>
using require_all_col_vector_t
    = require_all_t<is_col_vector<std::decay_t<Types>>...>;
template <typename T>
struct is_eigen_row_vector : internal::is_eigen_row_vector_impl<T> {};
 
template <typename T>
using require_eigen_row_vector_t
    = require_t<is_eigen_row_vector<std::decay_t<T>>>;
template <typename T>
struct is_row_vector : internal::is_row_vector_impl<std::decay_t<T>> {};
 
template <typename T>
inline constexpr bool is_row_vector_v = is_row_vector<T>::value;
 
template <typename T>
using require_row_vector_t = require_t<is_row_vector<std::decay_t<T>>>;
template <typename T>
struct is_eigen_vector : bool_constant<is_eigen_col_vector<T>::value
                                       || is_eigen_row_vector<T>::value> {};
 
template <typename T>
using require_eigen_vector_t = require_t<is_eigen_vector<std::decay_t<T>>>;
 
template <typename T>
using require_not_eigen_vector_t
    = require_not_t<is_eigen_vector<std::decay_t<T>>>;
 
template <typename... Types>
using require_all_eigen_vector_t
    = require_all_t<is_eigen_vector<std::decay_t<Types>>...>;
 
template <typename... Types>
using require_any_eigen_vector_t
    = require_any_t<is_eigen_vector<std::decay_t<Types>>...>;
 
template <typename... Types>
using require_all_not_eigen_vector_t
    = require_all_not_t<is_eigen_vector<std::decay_t<Types>>...>;
 
template <typename... Types>
using require_any_not_eigen_vector_t
    = require_any_not_t<is_eigen_vector<std::decay_t<Types>>...>;
template <template <class...> class TypeCheck, class... Check>
using require_eigen_vector_vt
    = require_t<container_type_check_base<is_eigen_vector, value_type_t,
                                          TypeCheck, Check...>>;
 
template <template <class...> class TypeCheck, class... Check>
using require_not_eigen_vector_vt
    = require_not_t<container_type_check_base<is_eigen_vector, value_type_t,
                                              TypeCheck, Check...>>;
 
template <template <class...> class TypeCheck, class... Check>
using require_any_eigen_vector_vt
    = require_any_t<container_type_check_base<is_eigen_vector, value_type_t,
                                              TypeCheck, Check>...>;
 
template <template <class...> class TypeCheck, class... Check>
using require_any_not_eigen_vector_vt
    = require_any_not_t<container_type_check_base<is_eigen_vector, value_type_t,
                                                  TypeCheck, Check>...>;
 
template <template <class...> class TypeCheck, class... Check>
using require_all_eigen_vector_vt
    = require_all_t<container_type_check_base<is_eigen_vector, value_type_t,
                                              TypeCheck, Check>...>;
 
template <template <class...> class TypeCheck, class... Check>
using require_all_not_eigen_vector_vt
    = require_all_not_t<container_type_check_base<is_eigen_vector, value_type_t,
                                                  TypeCheck, Check>...>;
 
template <template <class...> class TypeCheck, class... Check>
using require_eigen_vector_st
    = require_t<container_type_check_base<is_eigen_vector, scalar_type_t,
                                          TypeCheck, Check...>>;
 
template <template <class...> class TypeCheck, class... Check>
using require_not_eigen_vector_st
    = require_not_t<container_type_check_base<is_eigen_vector, scalar_type_t,
                                              TypeCheck, Check...>>;
 
template <template <class...> class TypeCheck, class... Check>
using require_any_eigen_vector_st
    = require_any_t<container_type_check_base<is_eigen_vector, scalar_type_t,
                                              TypeCheck, Check>...>;
 
template <template <class...> class TypeCheck, class... Check>
using require_any_not_eigen_vector_st
    = require_any_not_t<container_type_check_base<
        is_eigen_vector, scalar_type_t, TypeCheck, Check>...>;
 
template <template <class...> class TypeCheck, class... Check>
using require_all_eigen_vector_st
    = require_all_t<container_type_check_base<is_eigen_vector, scalar_type_t,
                                              TypeCheck, Check>...>;
 
template <template <class...> class TypeCheck, class... Check>
using require_all_not_eigen_vector_st
    = require_all_not_t<container_type_check_base<
        is_eigen_vector, scalar_type_t, TypeCheck, Check>...>;
template <typename Row, typename Col>
using require_eigen_row_and_col_t = require_t<
    math::conjunction<is_eigen_row_vector<Row>, is_eigen_col_vector<Col>>>;
 
template <typename Row, typename Col>
using require_not_eigen_row_and_col_t = require_not_t<
    math::conjunction<is_eigen_row_vector<Row>, is_eigen_col_vector<Col>>>;
 
template <typename Row, typename Col>
using require_row_and_col_vector_t
    = require_t<math::conjunction<is_row_vector<Row>, is_col_vector<Col>>>;
 
template <typename Row, typename Col>
using require_not_row_and_col_vector_t
    = require_not_t<math::conjunction<is_row_vector<Row>, is_col_vector<Col>>>;
 
template <typename T>
struct is_vector
    : bool_constant<is_eigen_vector<T>::value || is_std_vector<T>::value
                    || (is_var<T>::value
                        && is_eigen_vector<value_type_t<T>>::value)> {};
 
template <typename T>
using require_vector_t = require_t<is_vector<std::decay_t<T>>>;
 
template <typename T>
using require_not_vector_t = require_not_t<is_vector<std::decay_t<T>>>;
 
template <typename... Types>
using require_all_vector_t = require_all_t<is_vector<std::decay_t<Types>>...>;
 
template <typename... Types>
using require_any_vector_t = require_any_t<is_vector<std::decay_t<Types>>...>;
 
template <typename... Types>
using require_all_not_vector_t
    = require_all_not_t<is_vector<std::decay_t<Types>>...>;
 
template <typename... Types>
using require_any_not_vector_t
    = require_any_not_t<is_vector<std::decay_t<Types>>...>;
template <template <class...> class TypeCheck, class... Check>
using require_vector_vt = require_t<
    container_type_check_base<is_vector, value_type_t, TypeCheck, Check...>>;
 
template <template <class...> class TypeCheck, class... Check>
using require_not_vector_vt = require_not_t<
    container_type_check_base<is_vector, value_type_t, TypeCheck, Check...>>;
 
template <template <class...> class TypeCheck, class... Check>
using require_any_vector_vt = require_any_t<
    container_type_check_base<is_vector, value_type_t, TypeCheck, Check>...>;
 
template <template <class...> class TypeCheck, class... Check>
using require_any_not_vector_vt = require_any_not_t<
    container_type_check_base<is_vector, value_type_t, TypeCheck, Check>...>;
 
template <template <class...> class TypeCheck, class... Check>
using require_all_vector_vt = require_all_t<
    container_type_check_base<is_vector, value_type_t, TypeCheck, Check>...>;
 
template <template <class...> class TypeCheck, class... Check>
using require_all_not_vector_vt = require_all_not_t<
    container_type_check_base<is_vector, value_type_t, TypeCheck, Check>...>;
 
template <template <class...> class TypeCheck, class... Check>
using require_vector_st = require_t<
    container_type_check_base<is_vector, scalar_type_t, TypeCheck, Check...>>;
 
template <template <class...> class TypeCheck, class... Check>
using require_not_vector_st = require_not_t<
    container_type_check_base<is_vector, scalar_type_t, TypeCheck, Check...>>;
 
template <template <class...> class TypeCheck, class... Check>
using require_any_vector_st = require_any_t<
    container_type_check_base<is_vector, scalar_type_t, TypeCheck, Check>...>;
 
template <template <class...> class TypeCheck, class... Check>
using require_any_not_vector_st = require_any_not_t<
    container_type_check_base<is_vector, scalar_type_t, TypeCheck, Check>...>;
 
template <template <class...> class TypeCheck, class... Check>
using require_all_vector_st = require_all_t<
    container_type_check_base<is_vector, scalar_type_t, TypeCheck, Check>...>;
 
template <template <class...> class TypeCheck, class... Check>
using require_all_not_vector_st = require_all_not_t<
    container_type_check_base<is_vector, scalar_type_t, TypeCheck, Check>...>;
namespace internal {
 
template <typename T>
struct is_std_vector_impl : std::false_type {};
 
template <typename... Args>
struct is_std_vector_impl<std::vector<Args...>> : std::true_type {};
 
}  // namespace internal
 
template <typename T>
struct is_std_vector<
    T, std::enable_if_t<internal::is_std_vector_impl<std::decay_t<T>>::value>>
    : std::true_type {};
 
template <typename T>
inline constexpr bool is_std_vector_v = is_std_vector<T>::value;
 
template <typename T>
struct scalar_type<T, std::enable_if_t<is_std_vector<T>::value>> {
  using type = scalar_type_t<typename std::decay_t<T>::value_type>;
};
 
template <typename T>
struct value_type<T, std::enable_if_t<is_std_vector<T>::value>> {
  using type = typename std::decay_t<T>::value_type;
};
 
template <typename T>
using require_std_vector_t = require_t<is_std_vector<std::decay_t<T>>>;
 
template <typename T>
using require_not_std_vector_t = require_not_t<is_std_vector<std::decay_t<T>>>;
 
template <typename... Types>
using require_all_std_vector_t
    = require_all_t<is_std_vector<std::decay_t<Types>>...>;
 
template <typename... Types>
using require_any_std_vector_t
    = require_any_t<is_std_vector<std::decay_t<Types>>...>;
 
template <typename... Types>
using require_all_not_std_vector_t
    = require_all_not_t<is_std_vector<std::decay_t<Types>>...>;
 
template <typename... Types>
using require_any_not_std_vector_t
    = require_any_not_t<is_std_vector<std::decay_t<Types>>...>;
template <template <class...> class TypeCheck, class... Check>
using require_std_vector_vt
    = require_t<container_type_check_base<is_std_vector, value_type_t,
                                          TypeCheck, Check...>>;
 
template <template <class...> class TypeCheck, class... Check>
using require_not_std_vector_vt
    = require_not_t<container_type_check_base<is_std_vector, value_type_t,
                                              TypeCheck, Check...>>;
 
template <template <class...> class TypeCheck, class... Check>
using require_any_std_vector_vt
    = require_any_t<container_type_check_base<is_std_vector, value_type_t,
                                              TypeCheck, Check>...>;
 
template <template <class...> class TypeCheck, class... Check>
using require_any_not_std_vector_vt
    = require_any_not_t<container_type_check_base<is_std_vector, value_type_t,
                                                  TypeCheck, Check>...>;
 
template <template <class...> class TypeCheck, class... Check>
using require_all_std_vector_vt
    = require_all_t<container_type_check_base<is_std_vector, value_type_t,
                                              TypeCheck, Check>...>;
 
template <template <class...> class TypeCheck, class... Check>
using require_all_not_std_vector_vt
    = require_all_not_t<container_type_check_base<is_std_vector, value_type_t,
                                                  TypeCheck, Check>...>;
 
template <template <class...> class TypeCheck, class... Check>
using require_std_vector_st
    = require_t<container_type_check_base<is_std_vector, scalar_type_t,
                                          TypeCheck, Check...>>;
 
template <template <class...> class TypeCheck, class... Check>
using require_not_std_vector_st
    = require_not_t<container_type_check_base<is_std_vector, scalar_type_t,
                                              TypeCheck, Check...>>;
 
template <template <class...> class TypeCheck, class... Check>
using require_any_std_vector_st
    = require_any_t<container_type_check_base<is_std_vector, scalar_type_t,
                                              TypeCheck, Check>...>;
 
template <template <class...> class TypeCheck, class... Check>
using require_any_not_std_vector_st
    = require_any_not_t<container_type_check_base<is_std_vector, scalar_type_t,
                                                  TypeCheck, Check>...>;
 
template <template <class...> class TypeCheck, class... Check>
using require_all_std_vector_st
    = require_all_t<container_type_check_base<is_std_vector, scalar_type_t,
                                              TypeCheck, Check>...>;
 
template <template <class...> class TypeCheck, class... Check>
using require_all_not_std_vector_st
    = require_all_not_t<container_type_check_base<is_std_vector, scalar_type_t,
                                                  TypeCheck, Check>...>;
}  // namespace stan
#endif