math/is__vector_8hpp_source.html

#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<T> {};


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>

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

bool_constant.hpp

bool_constant

stan::require_col_vector_t
require_t< is_col_vector< std::decay_t< T > > > require_col_vector_t
Require type satisfies is_col_vector.
Definition is_vector.hpp:146

stan::require_not_col_vector_t
require_not_t< is_col_vector< std::decay_t< T > > > require_not_col_vector_t
Require type does not satisfy is_col_vector.
Definition is_vector.hpp:151

stan::require_all_col_vector_t
require_all_t< is_col_vector< std::decay_t< Types > >... > require_all_col_vector_t
Require all of the types satisfy is_col_vector.
Definition is_vector.hpp:157

stan::require_eigen_col_vector_vt
require_t< container_type_check_base< is_eigen_col_vector, value_type_t, TypeCheck, Check... > > require_eigen_col_vector_vt
Require type satisfies is_eigen_col_vector.
Definition is_vector.hpp:126

stan::require_eigen_col_vector_t
require_t< is_eigen_col_vector< std::decay_t< T > > > require_eigen_col_vector_t
Require type satisfies is_eigen_col_vector.
Definition is_vector.hpp:98

stan::require_not_eigen_col_vector_t
require_not_t< is_eigen_col_vector< std::decay_t< T > > > require_not_eigen_col_vector_t
Require type does not satisfy is_eigen_col_vector.
Definition is_vector.hpp:104

stan::require_all_eigen_col_vector_t
require_all_t< is_eigen_col_vector< std::decay_t< Types > >... > require_all_eigen_col_vector_t
Require all of the types satisfy is_eigen_col_vector.
Definition is_vector.hpp:110

stan::require_eigen_row_vector_t
require_t< is_eigen_row_vector< std::decay_t< T > > > require_eigen_row_vector_t
Require type satisfies is_eigen_row_vector.
Definition is_vector.hpp:177

stan::require_any_not_eigen_vector_vt
require_any_not_t< container_type_check_base< is_eigen_vector, value_type_t, TypeCheck, Check >... > require_any_not_eigen_vector_vt
Require at least one of the types does not satisfy is_eigen_vector.
Definition is_vector.hpp:295

stan::require_all_not_eigen_vector_t
require_all_not_t< is_eigen_vector< std::decay_t< Types > >... > require_all_not_eigen_vector_t
Require none of the types satisfy is_eigen_vector.
Definition is_vector.hpp:241

stan::require_all_not_eigen_vector_vt
require_all_not_t< container_type_check_base< is_eigen_vector, value_type_t, TypeCheck, Check >... > require_all_not_eigen_vector_vt
Require none of the types satisfy is_eigen_vector.
Definition is_vector.hpp:315

stan::require_not_eigen_vector_vt
require_not_t< container_type_check_base< is_eigen_vector, value_type_t, TypeCheck, Check... > > require_not_eigen_vector_vt
Require type does not satisfy is_eigen_vector or.
Definition is_vector.hpp:274

stan::require_not_eigen_vector_st
require_not_t< container_type_check_base< is_eigen_vector, scalar_type_t, TypeCheck, Check... > > require_not_eigen_vector_st
Require type does not satisfy is_eigen_vector.
Definition is_vector.hpp:335

stan::require_any_eigen_vector_vt
require_any_t< container_type_check_base< is_eigen_vector, value_type_t, TypeCheck, Check >... > require_any_eigen_vector_vt
Require any of the types satisfy is_eigen_vector.
Definition is_vector.hpp:284

stan::require_all_eigen_vector_vt
require_all_t< container_type_check_base< is_eigen_vector, value_type_t, TypeCheck, Check >... > require_all_eigen_vector_vt
Require all of the types satisfy is_eigen_vector.
Definition is_vector.hpp:305

stan::require_eigen_vector_t
require_t< is_eigen_vector< std::decay_t< T > > > require_eigen_vector_t
Require type satisfies is_eigen_vector.
Definition is_vector.hpp:217

stan::require_eigen_vector_vt
require_t< container_type_check_base< is_eigen_vector, value_type_t, TypeCheck, Check... > > require_eigen_vector_vt
Require type satisfies is_eigen_vector.
Definition is_vector.hpp:264

stan::require_any_eigen_vector_st
require_any_t< container_type_check_base< is_eigen_vector, scalar_type_t, TypeCheck, Check >... > require_any_eigen_vector_st
Require any of the types satisfy is_eigen_vector.
Definition is_vector.hpp:345

stan::require_not_eigen_vector_t
require_not_t< is_eigen_vector< std::decay_t< T > > > require_not_eigen_vector_t
Require type does not satisfy is_eigen_vector.
Definition is_vector.hpp:223

stan::require_all_not_eigen_vector_st
require_all_not_t< container_type_check_base< is_eigen_vector, scalar_type_t, TypeCheck, Check >... > require_all_not_eigen_vector_st
Require none of the types satisfy is_eigen_vector.
Definition is_vector.hpp:376

stan::require_any_not_eigen_vector_st
require_any_not_t< container_type_check_base< is_eigen_vector, scalar_type_t, TypeCheck, Check >... > require_any_not_eigen_vector_st
Require at least one of the types does not satisfy is_eigen_vector.
Definition is_vector.hpp:356

stan::require_any_eigen_vector_t
require_any_t< is_eigen_vector< std::decay_t< Types > >... > require_any_eigen_vector_t
Require any of the types satisfy is_eigen_vector.
Definition is_vector.hpp:235

stan::require_any_not_eigen_vector_t
require_any_not_t< is_eigen_vector< std::decay_t< Types > >... > require_any_not_eigen_vector_t
Require at least one of the types do not satisfy is_eigen_vector.
Definition is_vector.hpp:248

stan::require_all_eigen_vector_t
require_all_t< is_eigen_vector< std::decay_t< Types > >... > require_all_eigen_vector_t
Require all of the types satisfy is_eigen_vector.
Definition is_vector.hpp:229

stan::require_eigen_vector_st
require_t< container_type_check_base< is_eigen_vector, scalar_type_t, TypeCheck, Check... > > require_eigen_vector_st
Require type satisfies is_eigen_vector.
Definition is_vector.hpp:325

stan::require_all_eigen_vector_st
require_all_t< container_type_check_base< is_eigen_vector, scalar_type_t, TypeCheck, Check >... > require_all_eigen_vector_st
Require all of the types does not satisfy is_eigen_vector.
Definition is_vector.hpp:366

stan::require_row_vector_t
require_t< is_row_vector< std::decay_t< T > > > require_row_vector_t
Require type satisfies is_row_vector.
Definition is_vector.hpp:197

stan::require_any_not_std_vector_vt
require_any_not_t< container_type_check_base< is_std_vector, value_type_t, TypeCheck, Check >... > require_any_not_std_vector_vt
Require at least one of the types does not satisfy is_std_vector.
Definition is_vector.hpp:707

stan::require_not_std_vector_t
require_not_t< is_std_vector< std::decay_t< T > > > require_not_std_vector_t
Require type does not satisfy is_std_vector.
Definition is_vector.hpp:635

stan::require_std_vector_vt
require_t< container_type_check_base< is_std_vector, value_type_t, TypeCheck, Check... > > require_std_vector_vt
Require type satisfies is_std_vector.
Definition is_vector.hpp:676

stan::require_all_not_std_vector_st
require_all_not_t< container_type_check_base< is_std_vector, scalar_type_t, TypeCheck, Check >... > require_all_not_std_vector_st
Require none of the types satisfy is_std_vector.
Definition is_vector.hpp:788

stan::require_any_std_vector_vt
require_any_t< container_type_check_base< is_std_vector, value_type_t, TypeCheck, Check >... > require_any_std_vector_vt
Require any of the types satisfy is_std_vector.
Definition is_vector.hpp:696

stan::require_not_std_vector_vt
require_not_t< container_type_check_base< is_std_vector, value_type_t, TypeCheck, Check... > > require_not_std_vector_vt
Require type does not satisfy is_std_vector or.
Definition is_vector.hpp:686

stan::require_std_vector_st
require_t< container_type_check_base< is_std_vector, scalar_type_t, TypeCheck, Check... > > require_std_vector_st
Require type satisfies is_std_vector.
Definition is_vector.hpp:737

stan::require_any_std_vector_t
require_any_t< is_std_vector< std::decay_t< Types > >... > require_any_std_vector_t
Require any of the types satisfy is_std_vector.
Definition is_vector.hpp:647

stan::require_all_not_std_vector_t
require_all_not_t< is_std_vector< std::decay_t< Types > >... > require_all_not_std_vector_t
Require none of the types satisfy is_std_vector.
Definition is_vector.hpp:653

stan::require_std_vector_t
require_t< is_std_vector< std::decay_t< T > > > require_std_vector_t
Require type satisfies is_std_vector.
Definition is_vector.hpp:630

stan::require_any_not_std_vector_st
require_any_not_t< container_type_check_base< is_std_vector, scalar_type_t, TypeCheck, Check >... > require_any_not_std_vector_st
Require at least one of the types does not satisfy is_std_vector.
Definition is_vector.hpp:768

stan::require_not_std_vector_st
require_not_t< container_type_check_base< is_std_vector, scalar_type_t, TypeCheck, Check... > > require_not_std_vector_st
Require type does not satisfy is_std_vector.
Definition is_vector.hpp:747

stan::require_all_std_vector_vt
require_all_t< container_type_check_base< is_std_vector, value_type_t, TypeCheck, Check >... > require_all_std_vector_vt
Require all of the types satisfy is_std_vector.
Definition is_vector.hpp:717

stan::require_all_std_vector_t
require_all_t< is_std_vector< std::decay_t< Types > >... > require_all_std_vector_t
Require all of the types satisfy is_std_vector.
Definition is_vector.hpp:641

stan::require_all_std_vector_st
require_all_t< container_type_check_base< is_std_vector, scalar_type_t, TypeCheck, Check >... > require_all_std_vector_st
Require all of the types does not satisfy is_std_vector.
Definition is_vector.hpp:778

stan::require_any_std_vector_st
require_any_t< container_type_check_base< is_std_vector, scalar_type_t, TypeCheck, Check >... > require_any_std_vector_st
Require any of the types satisfy is_std_vector.
Definition is_vector.hpp:757

stan::require_all_not_std_vector_vt
require_all_not_t< container_type_check_base< is_std_vector, value_type_t, TypeCheck, Check >... > require_all_not_std_vector_vt
Require none of the types satisfy is_std_vector.
Definition is_vector.hpp:727

stan::require_any_not_std_vector_t
require_any_not_t< is_std_vector< std::decay_t< Types > >... > require_any_not_std_vector_t
Require at least one of the types do not satisfy is_std_vector.
Definition is_vector.hpp:660

stan::value_type_t
typename value_type< T >::type value_type_t
Helper function for accessing underlying type.
Definition value_type.hpp:35

stan::require_vector_vt
require_t< container_type_check_base< is_vector, value_type_t, TypeCheck, Check... > > require_vector_vt
Require type satisfies is_vector.
Definition is_vector.hpp:473

stan::require_not_vector_st
require_not_t< container_type_check_base< is_vector, scalar_type_t, TypeCheck, Check... > > require_not_vector_st
Require type does not satisfy is_vector.
Definition is_vector.hpp:536

stan::require_all_vector_t
require_all_t< is_vector< std::decay_t< Types > >... > require_all_vector_t
Require all of the types satisfy is_vector.
Definition is_vector.hpp:441

stan::require_vector_st
require_t< container_type_check_base< is_vector, scalar_type_t, TypeCheck, Check... > > require_vector_st
Require type satisfies is_vector.
Definition is_vector.hpp:527

stan::require_vector_t
require_t< is_vector< std::decay_t< T > > > require_vector_t
Require type satisfies is_vector.
Definition is_vector.hpp:431

stan::require_all_not_vector_st
require_all_not_t< container_type_check_base< is_vector, scalar_type_t, TypeCheck, Check >... > require_all_not_vector_st
Require none of the types satisfy is_vector.
Definition is_vector.hpp:572

stan::require_any_not_vector_t
require_any_not_t< is_vector< std::decay_t< Types > >... > require_any_not_vector_t
Require at least one of the types do not satisfy is_vector.
Definition is_vector.hpp:458

stan::require_all_vector_vt
require_all_t< container_type_check_base< is_vector, value_type_t, TypeCheck, Check >... > require_all_vector_vt
Require all of the types satisfy is_vector.
Definition is_vector.hpp:509

stan::require_any_not_vector_vt
require_any_not_t< container_type_check_base< is_vector, value_type_t, TypeCheck, Check >... > require_any_not_vector_vt
Require at least one of the types does not satisfy is_vector.
Definition is_vector.hpp:500

stan::require_not_vector_vt
require_not_t< container_type_check_base< is_vector, value_type_t, TypeCheck, Check... > > require_not_vector_vt
Require type does not satisfy is_vector or.
Definition is_vector.hpp:482

stan::require_all_vector_st
require_all_t< container_type_check_base< is_vector, scalar_type_t, TypeCheck, Check >... > require_all_vector_st
Require all of the types does not satisfy is_vector.
Definition is_vector.hpp:563

stan::require_any_vector_st
require_any_t< container_type_check_base< is_vector, scalar_type_t, TypeCheck, Check >... > require_any_vector_st
Require any of the types satisfy is_vector.
Definition is_vector.hpp:545

stan::require_any_vector_vt
require_any_t< container_type_check_base< is_vector, value_type_t, TypeCheck, Check >... > require_any_vector_vt
Require any of the types satisfy is_vector.
Definition is_vector.hpp:491

stan::require_all_not_vector_t
require_all_not_t< is_vector< std::decay_t< Types > >... > require_all_not_vector_t
Require none of the types satisfy is_vector.
Definition is_vector.hpp:452

stan::require_not_vector_t
require_not_t< is_vector< std::decay_t< T > > > require_not_vector_t
Require type does not satisfy is_vector.
Definition is_vector.hpp:436

stan::require_any_not_vector_st
require_any_not_t< container_type_check_base< is_vector, scalar_type_t, TypeCheck, Check >... > require_any_not_vector_st
Require at least one of the types does not satisfy is_vector.
Definition is_vector.hpp:554

stan::require_any_vector_t
require_any_t< is_vector< std::decay_t< Types > >... > require_any_vector_t
Require any of the types satisfy is_vector.
Definition is_vector.hpp:446

stan::require_all_not_vector_vt
require_all_not_t< container_type_check_base< is_vector, value_type_t, TypeCheck, Check >... > require_all_not_vector_vt
Require none of the types satisfy is_vector.
Definition is_vector.hpp:518

is_eigen.hpp

stan::require_not_t
std::enable_if_t<!Check::value > require_not_t
If condition is false, template is disabled.
Definition require_helpers.hpp:26

stan::require_any_t
std::enable_if_t< math::disjunction< Checks... >::value > require_any_t
If any condition is true, template is enabled.
Definition require_helpers.hpp:43

stan::require_not_eigen_row_and_col_t
require_not_t< math::conjunction< is_eigen_row_vector< Row >, is_eigen_col_vector< Col > > > require_not_eigen_row_and_col_t
Require Row is not a row vector and Col is not a column vector.
Definition is_vector.hpp:393

stan::require_not_row_and_col_vector_t
require_not_t< math::conjunction< is_row_vector< Row >, is_col_vector< Col > > > require_not_row_and_col_vector_t
Require Row is not a row vector and Col is not a column vector.
Definition is_vector.hpp:409

stan::require_eigen_row_and_col_t
require_t< math::conjunction< is_eigen_row_vector< Row >, is_eigen_col_vector< Col > > > require_eigen_row_and_col_t
Require Row is a row vector and Col is a column vector.
Definition is_vector.hpp:385

stan::require_all_not_t
std::enable_if_t<!math::disjunction< Checks... >::value > require_all_not_t
If all conditions are false, template is enabled.
Definition require_helpers.hpp:53

stan::container_type_check_base
bool_constant< math::conjunction< ContainerCheck< std::decay_t< Check > >..., TypeCheck< ValueCheck< Check > >... >::value > container_type_check_base
Used as the base for checking whether a type is a container with an underlying scalar type.
Definition require_helpers.hpp:84

stan::scalar_type_t
typename scalar_type< T >::type scalar_type_t
Definition scalar_type.hpp:25

stan::require_any_not_t
std::enable_if_t<!math::conjunction< Checks... >::value > require_any_not_t
If any condition is false, template is enabled.
Definition require_helpers.hpp:63

stan::require_t
std::enable_if_t< Check::value > require_t
If condition is true, template is enabled.
Definition require_helpers.hpp:19

stan::require_all_t
std::enable_if_t< math::conjunction< Checks... >::value > require_all_t
If all conditions are true, template is enabled Returns a type void if all conditions are true and ot...
Definition require_helpers.hpp:34

stan::require_row_and_col_vector_t
require_t< math::conjunction< is_row_vector< Row >, is_col_vector< Col > > > require_row_and_col_vector_t
Require Row is a row vector and Col is a column vector.
Definition is_vector.hpp:401

stan
The lgamma implementation in stan-math is based on either the reentrant safe lgamma_r implementation ...
Definition unit_vector_constrain.hpp:15

std
STL namespace.

is_var.hpp

scalar_type.hpp

value_type.hpp

require_helpers.hpp

stan::internal::is_col_vector_impl
Underlying implementation for detecting if a Matrix is a column vector.
Definition is_vector.hpp:56

stan::internal::is_eigen_col_vector_impl
Underlying implementation for detecting if an Eigen Matrix is a column vector.
Definition is_vector.hpp:28

stan::internal::is_eigen_row_vector_impl
Underlying implementation for detecting if an Eigen Matrix is a row vector.
Definition is_vector.hpp:41

stan::internal::is_row_vector_impl
Underlying implementation for detecting if a Matrix is a row vector.
Definition is_vector.hpp:71

stan::internal::is_std_vector_impl
This underlying implementation is used when the type is not an std vector.
Definition is_vector.hpp:581

stan::is_col_vector
If the input type T has a static comple time constant type ColsAtCompileTime equal to 1 this has a st...
Definition is_vector.hpp:136

stan::is_eigen_col_vector
If the input type T is an eigen matrix with 1 row at compile time this has a static member with a val...
Definition is_vector.hpp:87

stan::is_eigen_row_vector
If the input type T is an eigen matrix with 1 column at compile time this has a static member with a ...
Definition is_vector.hpp:166

stan::is_eigen_vector
If the input type T is an eigen matrix with 1 column or 1 row at compile time this has a static membe...
Definition is_vector.hpp:207

stan::is_eigen
Check if type derives from EigenBase
Definition is_eigen.hpp:21

stan::is_row_vector
If the input type T has a static comple time constant type RowsAtCompileTime equal to 1 this has a st...
Definition is_vector.hpp:187

stan::is_std_vector
Base implementation for checking if type is std vector.
Definition is_vector.hpp:19

stan::is_var
Defines a static member named value which is defined to be false as the primitive scalar types cannot...
Definition is_var.hpp:14

stan::is_vector
If the input type T is either an eigen matrix with 1 column or 1 row at compile time or a standard ve...
Definition is_vector.hpp:421

stan::math::conjunction
Extends std::true_type when instantiated with zero or more template parameters, all of which extend t...
Definition conjunction.hpp:14

stan::scalar_type< T, std::enable_if_t< is_std_vector< T >::value > >::type
scalar_type_t< typename std::decay_t< T >::value_type > type
Definition is_vector.hpp:608

stan::scalar_type
Metaprogram structure to determine the base scalar type of a template argument.
Definition scalar_type.hpp:20

stan::value_type< T, std::enable_if_t< is_std_vector< T >::value > >::type
typename std::decay_t< T >::value_type type
Definition is_vector.hpp:619

stan::value_type
Primary template class for metaprogram to compute the type of values stored in a container.
Definition value_type.hpp:18