Stan Math Library  4.9.0 Automatic Differentiation
Searching...
No Matches
stan Namespace Reference

## Detailed Description

The lgamma implementation in stan-math is based on either the reentrant safe lgamma_r implementation from C or the boost::math::lgamma implementation.

Operations in Eigen Expressions hold their arguments either by value or by reference.

The reentrant safe lgamma_r implementation is preferred as it is faster when compared to the boost version. However, the reentrant safe lgamma_r C function is not available with MinGW compilers used on Windows. Therefore, the boost version is used on Windows with MinGW compilers as fall back. For details on the speed evaluations, please refer to https://github.com/stan-dev/math/pull/1255 .

Which one is chosen depends on type of the argument. Other operations are held by value. "Heavy" objects that can hold data themselves, such as Eigen::Matrix or Eigen::Ref are instead held by reference. THis is the only criterion - holding rvalue arguments by value is not supported, so we can not use perfect forwarding.

When returning an expression from function we have to be careful that any arguments in this expression that are held by reference do not go out of scope. For instance, consider the function:

template<typename T>
auto f(const T& x){
const Eigen::Ref<const Eigen::VectorXd>& x_ref = x;
return x_ref.cwiseProduct(x_ref);
}

And the code calling it:

Eigen::MatrixXd test_mat(2,2);
test_mat << 5, 5, 5, 5;
VectorXd X = f(test_mat.diagonal());

This function will return back a CwiseBinaryOp Eigen expression, which is then evaluated out of the function scope when assigned to X. The expression references x_ref, which was created withing function and destroyed when the function returned. The returned expression is evaluated after the function returned, so its evaluation references a matrix that was already deleted. In other words the returned expression contains a dangling reference.

So a function returning an expression referencing local matrices or matrices that were rvalue reference arguments to the function will not work.

A workarount to this issue is allocating and constructing or moving such objects to heap. Holder object is a no-op operation that can also take pointers to such objects and release them when it goes out of scope. It can be created either by directly supplying pointers to such objects to holder function or by forwarding function arguments and moving local variables to make_holder, which will move any rvalues to heap first.

## Namespaces

namespace  internal

namespace  math
Matrices and templated mathematical functions.

## Classes

struct  base_type
Metaprogram structure to determine the base base type of a template argument. More...

struct  base_type< T, std::enable_if_t< is_complex< T >::value > >
Template metaprogram defining the base type for values stored in a complex number. More...

struct  base_type< T, std::enable_if_t< is_eigen< T >::value > >
Template metaprogram defining the base base type of values stored in an Eigen matrix. More...

struct  base_type< T, std::enable_if_t< is_std_vector< T >::value > >
Specialization of base_type for vector to recursively return the inner base type. More...

struct  conditional_var_value
Conditionally construct a var_value container based on a scalar type. More...

struct  conditional_var_value< T_scalar, T_container, require_std_vector_t< T_container > >

struct  error_index

struct  eval_return_type
Determines return type of calling .eval() on Eigen expression. More...

struct  is_any_var_matrix
Check if any types in a parameter pack are a var_value whose value_type is derived from Eigen::EigenBase More...

struct  is_arena_matrix
Defines a static member named value which is defined to be true if the type is arena_matrix<T> More...

struct  is_arena_matrix< T, require_t< internal::is_arena_matrix_impl< std::decay_t< T > > > >
Defines a static member named value which is defined to be true if the type is arena_matrix<T> More...

struct  is_arena_matrix_cl

struct  is_autodiff
Checks if decayed type is a var or fvar. More...

struct  is_base_pointer_convertible
Checks if a type's pointer is convertible to a templated base type's pointer. More...

struct  is_col_vector
If the input type T has a static comple time constant type ColsAtCompileTime equal to 1 this has a static member with a value of true. More...

struct  is_complex
If T is an arithmetic type (that is, an instance of std::complex) or a cv-qualified version thereof, provides the member constant value equal true; for any other type the value is false. More...

struct  is_complex< T, std::enable_if_t< internal::is_complex_impl< std::decay_t< T > >::value > >

struct  is_constant
Metaprogramming struct to detect whether a given type is constant in the mathematical sense (not the C++ const sense). More...

struct  is_constant< T, require_all_kernel_expressions_and_none_scalar_t< T > >
Defines a static member named value and sets it to true if the type of the elements in the provided matrix_cl is constant, false otherwise. More...

struct  is_constant< T, require_eigen_t< T > >
Defines a public enum named value and sets it to true if the type of the elements in the provided Eigen Matrix is constant, false otherwise. More...

struct  is_constant< T, require_std_vector_t< T > >
Defines a static member named value and sets it to true if the type of the elements in the provided std::vector is constant, false otherwise. More...

struct  is_detected

struct  is_detected< T, Op, void_t< Op< T > > >
Checks whether a valid type is detected. More...

struct  is_double_or_int
Checks if decayed type is a double or integer. More...

struct  is_eigen
Check if type derives from EigenBase More...

struct  is_eigen_array
Check if a type is derived from Eigen::ArrayBase More...

struct  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 value of true. More...

struct  is_eigen_contiguous_map
Check if a type is an Eigen::Map with contiguous stride. More...

struct  is_eigen_dense_base
Checks whether type T is derived from Eigen::DenseBase. More...

struct  is_eigen_matrix_base
Checks whether type T is derived from Eigen::MatrixBase. More...

struct  is_eigen_matrix_dynamic
Checks whether type T is derived from Eigen::MatrixBase and has columns and rows not equal to 1. More...

struct  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 value of true. More...

struct  is_eigen_sparse_base
Checks whether type T is derived from Eigen::SparseMatrixBase. More...

struct  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 member with a value of true. More...

struct  is_fvar
Defines a static member function type which is defined to be false as the primitive scalar types cannot be a stan::math::fvar type. More...

struct  is_fvar< T, std::enable_if_t< internal::is_fvar_impl< std::decay_t< T > >::value > >

struct  is_kernel_expression
Determines whether a type is is a valid kernel generator expression. More...

struct  is_kernel_expression_and_not_scalar
Determines whether a type is non-scalar type that is a valid kernel generator expression. More...

struct  is_kernel_expression_and_not_scalar< T, require_matrix_cl_t< T > >

struct  is_kernel_expression_lhs
Determines whether a type is an assignable kernel generator expression. More...

struct  is_kernel_expression_lhs< T, require_matrix_cl_t< T > >

struct  is_matrix
Check if a type is derived from Eigen::EigenBase or is a var_value whose value_type is derived from Eigen::EigenBase More...

struct  is_matrix_cl
Checks if the decayed type of T is a matrix_cl. More...

struct  is_nonscalar_prim_or_rev_kernel_expression
Determines whether a type is either a non-scalar kernel generator expression or a var containing a non-scalar kernel generator expression. More...

struct  is_prim_or_rev_kernel_expression
Determines whether a type is either a kernel generator expression or a var containing a kernel generator expression. More...

struct  is_rev_col_vector
Defines a static member named value which is defined to be true if the type is either derived from Eigen::EigenBase with a Scalar type of var_value<double> or a var_value<T> where T is derived from Eigen::EigenBase. More...

struct  is_rev_col_vector< T, require_all_t< is_var< scalar_type_t< T > >, math::disjunction< is_eigen_col_vector< T >, is_eigen_col_vector< value_type_t< T > > > > >
Defines a static member named value which is defined to be true if the type is either a type derived from Eigen::EigenBase with a Scalar type of var_value<double> or a var_value<T> where T is derived from Eigen::EigenBase. More...

struct  is_rev_kernel_expression
Determines whether a type is a var containing a kernel generator expression. More...

struct  is_rev_matrix
Defines a static member named value which is defined to be true if the type is either a type derived from Eigen::EigenBase with a Scalar type of var_value<double> or a var_value<T> where T is derived from Eigen::EigenBase More...

struct  is_rev_matrix< T, require_all_t< is_var< scalar_type_t< T > >, math::disjunction< math::conjunction< is_var< T >, is_eigen< value_type_t< T > > >, is_eigen< T > > > >
Defines a static member named value which is defined to be true if the type is either a type derived from Eigen::EigenBase with a Scalar type of var_value<double> or a var_value<T> where T is derived from Eigen::EigenBase More...

struct  is_rev_row_vector
Defines a static member named value which is defined to be true if the type is either a type derived from Eigen::EigenBase with a Scalar type of var_value<double> or a var_value<T> where T is derived from Eigen::EigenBase. More...

struct  is_rev_row_vector< T, require_all_t< is_var< scalar_type_t< T > >, math::disjunction< is_eigen_row_vector< T >, is_eigen_row_vector< value_type_t< T > > > > >
Defines a static member named value which is defined to be true if the type is either a type derived from Eigen::EigenBase with a Scalar type of var_value<double> or a var_value<T> where T is derived from Eigen::EigenBase. More...

struct  is_rev_vector
Defines a static member named value which is defined to be true if the type is either a type derived from Eigen::EigenBase with a Scalar type of var_value<double> or a var_value<T> where T is derived from Eigen::EigenBase. More...

struct  is_rev_vector< T, require_any_t< is_rev_col_vector< T >, is_rev_row_vector< T > > >
Defines a static member named value which is defined to be true if the type is either a type derived from Eigen::EigenBase with a Scalar type of var_value<double> or a var_value<T> where T is derived from Eigen::EigenBase. More...

struct  is_row_vector
If the input type T has a static comple time constant type RowsAtCompileTime equal to 1 this has a static member with a value of true. More...

struct  is_stan_scalar
Checks if decayed type is a var, fvar, or arithmetic. More...

struct  is_std_vector
Base implementation for checking if type is std vector. More...

struct  is_std_vector< T, std::enable_if_t< internal::is_std_vector_impl< std::decay_t< T > >::value > >
Checks if the decayed type of T is a standard vector. More...

struct  is_var
Defines a static member named value which is defined to be false as the primitive scalar types cannot be a stan::math::var type. More...

struct  is_var< T, std::enable_if_t< internal::is_var_impl< std::decay_t< T > >::value > >
Specialization for checking if value of T minus cv qualifier is a var_value. More...

struct  is_var_col_vector
Check if a type is a var_value whose value_type is derived from Eigen::EigenBase. More...

struct  is_var_dense_dynamic
Check if a type is a var_value whose value_type is derived from Eigen::EigenBase and has dynamic rows and columns. More...

struct  is_var_eigen
Check if a type is a var_value whose value_type is derived from Eigen::EigenBase More...

struct  is_var_matrix
Check if a type is a var_value whose value_type is derived from Eigen::EigenBase More...

struct  is_var_or_arithmetic_type
Defines a static member value which is defined to be true (1) if the unqualified cv of type T or its underlying type (if a container) is either var or an arithmetic type, and false (0) otherwise. More...

struct  is_var_row_vector
Check if a type is a var_value whose value_type is derived from Eigen::EigenBase. More...

struct  is_var_vector
Check if a type is a var_value whose value_type is derived from Eigen::EigenBase. More...

struct  is_vari
Specialization for checking if value of T minus cv qualifier and pointer is a vari. More...

struct  is_vari< T, require_t< internal::is_vari_impl< std::decay_t< T > > > >
Specialization for checking if value of T minus cv qualifier and pointer is a vari_value. More...

struct  is_vector
If the input type T is either an eigen matrix with 1 column or 1 row at compile time or a standard vector, this has a static member with a value of true. More...

struct  is_vector_like
Template metaprogram indicates whether a type is vector_like. More...

struct  is_vt_complex
If the value_type of the type T is of type std::complex or a cv-qualified version thereof, provides the member constant value equal true; for any other type the value is false. More...

struct  is_vt_not_complex
If the value_type of the type T is not of type std::complex or a cv-qualified version thereof, provides the member constant value equal true; for any other type the value is false. More...

struct  make_void

class  operation_cl_base
Non-templated base of operation_cl is needed for easy checking if something is a subclass of operation_cl. More...

class  operation_cl_lhs_base
Non-templated base of operation_cl_lhs is needed for easy checking if something is a subclass of operation_cl_lhs. More...

struct  partials_return_type
Template metaprogram to calculate the partial derivative type resulting from promoting all the scalar types of the template parameters. More...

struct  partials_return_type< T >

struct  partials_type
This base implementation will contain a static member function named type equal to the type passed into it. More...

struct  partials_type< T, require_fvar_t< T > >

struct  partials_type< T, require_var_t< T > >
Specialization of partials type returns double if input type is a double. More...

struct  plain_type
Determines plain (non expression) type associated with T. More...

struct  plain_type< T, require_all_kernel_expressions_and_none_scalar_t< T > >
Determines plain (non expression) type associated with T. More...

struct  plain_type< T, require_t< bool_constant< internal::has_eval< T >::value &&is_eigen< T >::value > > >
Determines plain (non expression) type associated with T. More...

struct  plain_type< T, require_t< bool_constant<!internal::has_eval< T >::value &&internal::has_plain_object< T >::value &&is_eigen< T >::value > > >

struct  plain_type< T, require_t< stan::math::conjunction< is_var< T >, is_eigen< value_type_t< T > > > > >
Determines plain (non expression) type associated with T. More...

struct  real_return
Provides a member type alias named type, the value of which is the least type under Stan's assignability relation that can be assigned a double and all of the base types of the specified arguments after removing qualifiers (const and volatile) and decaying (lvalue to rvalue by removing references) and array to pointer). More...

struct  real_return< T, Ts... >

struct  ref_type_if
If the condition is true determines appropriate type for assigning expression of given type to, to evaluate expensive expressions, but not make a copy if T involves no calculations. More...

struct  ref_type_if< Condition, T, require_all_kernel_expressions_t< T > >

struct  ref_type_if< Condition, T, require_all_t< is_eigen< T >, bool_constant<!is_arena_matrix< T >::value > > >

struct  ref_type_if< Condition, T, require_arena_matrix_t< T > >

struct  return_type
Template metaprogram to calculate the base scalar return type resulting from promoting all the scalar types of the template parameters to the least type to which all the base types of the arguments are assignable. More...

struct  rev_matrix_type
Determines a return type for a function that accepts given inputs and wants to return a matrix (or vector or row vector) with given compile time number of rows and columns. More...

struct  scalar_lub
Defines a member type named type that is the least scalar type to which both template parameter scalar types are assignable in Stan. More...

struct  scalar_lub< std::complex< T1 >, std::complex< T2 > >

struct  scalar_lub< std::complex< T1 >, T2 >

struct  scalar_lub< T1, std::complex< T2 > >

class  scalar_seq_view
scalar_seq_view provides a uniform sequence-like wrapper around either a scalar or a sequence of scalars. More...

class  scalar_seq_view< C, require_eigen_vector_t< C > >

class  scalar_seq_view< C, require_stan_scalar_t< C > >
This specialization handles wrapping a scalar as if it were a sequence. More...

class  scalar_seq_view< C, require_std_vector_t< C > >

class  scalar_seq_view< C, require_t< std::is_pointer< C > > >

class  scalar_seq_view< C, require_var_matrix_t< C > >

struct  scalar_type
Metaprogram structure to determine the base scalar type of a template argument. More...

struct  scalar_type< T, require_all_kernel_expressions_and_none_scalar_t< T > >
Return the scalar type of an OpenCL matrix. More...

struct  scalar_type< T, std::enable_if_t< is_complex< T >::value > >
Template metaprogram defining the scalar type for values stored in a complex number. More...

struct  scalar_type< T, std::enable_if_t< is_eigen< T >::value > >
Template metaprogram defining the base scalar type of values stored in an Eigen matrix. More...

struct  scalar_type< T, std::enable_if_t< is_std_vector< T >::value > >
Specialization of scalar_type for vector to recursively return the inner scalar type. More...

struct  scalar_type< T, std::enable_if_t< is_var< T >::value > >
Template specialization defining the scalar type of values stored in var_value. More...

class  StdVectorBuilder
StdVectorBuilder allocates type T1 values to be used as intermediate values. More...

struct  value_type
Primary template class for metaprogram to compute the type of values stored in a container. More...

struct  value_type< T, require_all_kernel_expressions_and_none_scalar_t< T > >
Return the value type of an OpenCL matrix. More...

struct  value_type< T, require_t< is_vari< T > > >

struct  value_type< T, std::enable_if_t< is_eigen< T >::value > >
Template metaprogram defining the type of values stored in an Eigen matrix, vector, or row vector. More...

struct  value_type< T, std::enable_if_t< is_std_vector< T >::value > >
Template metaprogram class to compute the type of values stored in a standard vector. More...

struct  value_type< T, std::enable_if_t< is_var< T >::value > >

struct  value_type< T, std::enable_if_t< std::is_pointer< T >::value > >
Specialization for pointers returns the underlying value the pointer is pointing to. More...

class  vector_seq_view
This class provides a low-cost wrapper for situations where you either need an Eigen Vector or RowVector or a std::vector of them and you want to be agnostic between those two options. More...

class  vector_seq_view< T, require_matrix_t< T > >
This class provides a low-cost wrapper for situations where you either need an Eigen Vector or RowVector or a std::vector of them and you want to be agnostic between those two options. More...

class  vector_seq_view< T, require_std_vector_vt< internal::is_matrix_or_std_vector, T > >
This class provides a low-cost wrapper for situations where you either need an Eigen Vector or RowVector or a std::vector of them and you want to be agnostic between those two options. More...

class  VectorBuilder
VectorBuilder allocates type T1 values to be used as intermediate values. More...

class  VectorBuilderHelper
VectorBuilder allocates type T1 values to be used as intermediate values. More...

class  VectorBuilderHelper< T1, true, false >

class  VectorBuilderHelper< T1, true, true >
Template specialization for using a vector. More...

## Typedefs

template<typename T >
using base_type_t = typename base_type< T >::type

template<bool B>
using bool_constant = std::integral_constant< bool, B >
Alias for structs used for wraps a static constant of bool.

template<typename... Ts>
using contains_std_vector = math::disjunction< is_std_vector< Ts >... >
Checks if any types are std vectors.

template<typename T >
using require_arena_matrix_t = require_t< is_arena_matrix< std::decay_t< T > > >
Require type satisfies is_arena_matrix.

template<typename T >
using require_not_arena_matrix_t = require_t< bool_constant<!is_arena_matrix< std::decay_t< T > >::value > >
Require type does not satisfy is_arena_matrix.

template<typename T >
using require_autodiff_t = require_t< is_autodiff< std::decay_t< T > > >
Require type satisfies is_autodiff.

template<typename T >
using require_not_autodiff_t = require_not_t< is_autodiff< std::decay_t< T > > >
Require type does not satisfy is_autodiff.

template<typename... Types>
using require_all_autodiff_t = require_all_t< is_autodiff< std::decay_t< Types > >... >
Require all of the types satisfy is_autodiff.

template<typename... Types>
using require_any_autodiff_t = require_any_t< is_autodiff< std::decay_t< Types > >... >
Require any of the types satisfy is_autodiff.

template<typename... Types>
using require_all_not_autodiff_t = require_all_not_t< is_autodiff< std::decay_t< Types > >... >
Require none of the types satisfy is_autodiff.

template<typename... Types>
using require_any_not_autodiff_t = require_any_not_t< is_autodiff< std::decay_t< Types > >... >
Require at least one of the types do not satisfy is_autodiff.

template<typename T >
using require_not_vt_autodiff = require_not_t< is_autodiff< value_type_t< std::decay_t< T > > > >
Require value type does not satisfy is_autodiff.

template<typename... Types>
using require_all_not_vt_autodiff = require_all_not_t< is_autodiff< value_type_t< std::decay_t< Types > > >... >
Require none of the value types satisfy is_autodiff.

template<typename T >
using require_st_autodiff = require_t< is_autodiff< scalar_type_t< std::decay_t< T > > > >
Require scalar type satisfies is_autodiff.

template<typename T >
using require_not_st_autodiff = require_not_t< is_autodiff< scalar_type_t< std::decay_t< T > > > >
Require scalar type does not satisfy is_autodiff.

template<typename... Types>
using require_any_st_autodiff = require_any_t< is_autodiff< scalar_type_t< std::decay_t< Types > > >... >
Require any of the scalar types satisfy is_autodiff.

template<typename T >
using require_complex_t = require_t< is_complex< std::decay_t< T > > >
Require type satisfies is_complex.

template<typename T >
using require_not_complex_t = require_not_t< is_complex< std::decay_t< T > > >
Require type does not satisfy is_complex.

template<typename... Types>
using require_all_complex_t = require_all_t< is_complex< std::decay_t< Types > >... >
Require all of the types satisfy is_complex.

template<typename... Types>
using require_any_complex_t = require_any_t< is_complex< std::decay_t< Types > >... >
Require any of the types satisfy is_complex.

template<typename... Types>
using require_all_not_complex_t = require_all_not_t< is_complex< std::decay_t< Types > >... >
Require none of the types satisfy is_complex.

template<typename T >
using require_vt_complex = require_t< is_complex< value_type_t< std::decay_t< T > > > >
Require value type satisfies is_complex.

template<typename T >
using require_not_vt_complex = require_not_t< is_complex< value_type_t< std::decay_t< T > > > >
Require value type does not satisfy is_complex.

template<typename T >
using require_not_st_complex = require_not_t< is_complex< scalar_type_t< std::decay_t< T > > > >
Require scalar type does not satisfy is_complex.

template<typename... T>
using is_constant_all = math::conjunction< is_constant< T >... >
Metaprogram defining an enum value which is true if all of the type parameters are constant (i.e., primitive types) and false otherwise.

template<typename Container >
using is_container = bool_constant< math::disjunction< is_eigen< Container >, is_std_vector< Container > >::value >
Deduces whether type is eigen matrix or standard vector.

template<typename T >
using require_container_t = require_t< is_container< std::decay_t< T > > >
Require type satisfies is_container.

template<typename T >
using require_not_container_t = require_not_t< is_container< std::decay_t< T > > >
Require type does not satisfy is_container.

template<typename... Types>
using require_all_container_t = require_all_t< is_container< std::decay_t< Types > >... >
Require all of the types satisfy is_container.

template<typename... Types>
using require_any_container_t = require_any_t< is_container< std::decay_t< Types > >... >
Require any of the types satisfy is_container.

template<typename... Types>
using require_all_not_container_t = require_all_not_t< is_container< std::decay_t< Types > >... >
Require none of the types satisfy is_container.

template<template< class... > class TypeCheck, class... Check>
using require_container_st = require_t< container_type_check_base< is_container, scalar_type_t, TypeCheck, Check... > >
Require type satisfies is_container.

template<template< class... > class TypeCheck, class... Check>
using require_not_container_st = require_not_t< container_type_check_base< is_container, scalar_type_t, TypeCheck, Check... > >
Require type does not satisfy is_container.

template<typename Container >
using is_container_or_var_matrix = bool_constant< math::disjunction< is_container< Container >, is_var_matrix< Container > >::value >
Deduces whether type is eigen matrix, standard vector, or var<Matrix>.

template<typename T >
using is_dense_dynamic = internal::is_dense_dynamic_impl< std::decay_t< T > >
Checks whether type T is derived from Eigen::DenseBase and has dynamic rows and columns or is a var_value<> whose inner type satisfies the conditions above.

template<typename T >
using require_dense_dynamic_t = require_t< is_dense_dynamic< std::decay_t< T > > >
Require type satisfies is_dense_dynamic.

template<typename... Types>
using require_all_dense_dynamic_t = require_all_t< is_dense_dynamic< std::decay_t< Types > >... >
Require all of the types satisfy is_dense_dynamic.

template<typename T >
using require_double_or_int_t = require_t< is_double_or_int< std::decay_t< T > > >
Require type satisfies is_double_or_int.

template<typename T >
using require_not_double_or_int_t = require_not_t< is_double_or_int< std::decay_t< T > > >
Require type does not satisfy is_double_or_int.

template<typename... Types>
using require_all_double_or_int_t = require_all_t< is_double_or_int< std::decay_t< Types > >... >
Require all of the types satisfy is_double_or_int.

template<typename... Types>
using require_any_double_or_int_t = require_any_t< is_double_or_int< std::decay_t< Types > >... >
Require any of the types satisfy is_double_or_int.

template<typename... Types>
using require_all_not_double_or_int_t = require_all_not_t< is_double_or_int< std::decay_t< Types > >... >
Require none of the types satisfy is_double_or_int.

template<typename... Types>
using require_any_not_double_or_int_t = require_any_not_t< is_double_or_int< std::decay_t< Types > >... >
Require at least one of the types do not satisfy is_double_or_int.

template<typename T >
using require_eigen_t = require_t< is_eigen< std::decay_t< T > > >
Require type satisfies is_eigen.

template<typename T >
using require_not_eigen_t = require_not_t< is_eigen< std::decay_t< T > > >
Require type does not satisfy is_eigen.

template<typename... Types>
using require_all_eigen_t = require_all_t< is_eigen< std::decay_t< Types > >... >
Require all of the types satisfy is_eigen.

template<typename... Types>
using require_any_eigen_t = require_any_t< is_eigen< std::decay_t< Types > >... >
Require any of the types satisfy is_eigen.

template<typename... Types>
using require_all_not_eigen_t = require_all_not_t< is_eigen< std::decay_t< Types > >... >
Require none of the types satisfy is_eigen.

template<typename... Types>
using require_any_not_eigen_t = require_any_not_t< is_eigen< std::decay_t< Types > >... >
Require at least one of the types do not satisfy is_eigen.

template<template< class... > class TypeCheck, class... Check>
using require_eigen_vt = require_t< container_type_check_base< is_eigen, value_type_t, TypeCheck, Check... > >
Require type satisfies is_eigen.

template<template< class... > class TypeCheck, class... Check>
using require_not_eigen_vt = require_not_t< container_type_check_base< is_eigen, value_type_t, TypeCheck, Check... > >
Require type does not satisfy is_eigen or.

template<template< class... > class TypeCheck, class... Check>
using require_any_eigen_vt = require_any_t< container_type_check_base< is_eigen, value_type_t, TypeCheck, Check >... >
Require any of the types satisfy is_eigen.

template<template< class... > class TypeCheck, class... Check>
using require_any_not_eigen_vt = require_any_not_t< container_type_check_base< is_eigen, value_type_t, TypeCheck, Check >... >
Require at least one of the types does not satisfy is_eigen.

template<template< class... > class TypeCheck, class... Check>
using require_all_eigen_vt = require_all_t< container_type_check_base< is_eigen, value_type_t, TypeCheck, Check >... >
Require all of the types satisfy is_eigen.

template<template< class... > class TypeCheck, class... Check>
using require_all_not_eigen_vt = require_all_not_t< container_type_check_base< is_eigen, value_type_t, TypeCheck, Check >... >
Require none of the types satisfy is_eigen.

template<template< class... > class TypeCheck, class... Check>
using require_eigen_st = require_t< container_type_check_base< is_eigen, scalar_type_t, TypeCheck, Check... > >
Require type satisfies is_eigen.

template<template< class... > class TypeCheck, class... Check>
using require_not_eigen_st = require_not_t< container_type_check_base< is_eigen, scalar_type_t, TypeCheck, Check... > >
Require type does not satisfy is_eigen.

template<template< class... > class TypeCheck, class... Check>
using require_any_eigen_st = require_any_t< container_type_check_base< is_eigen, scalar_type_t, TypeCheck, Check >... >
Require any of the types satisfy is_eigen.

template<template< class... > class TypeCheck, class... Check>
using require_any_not_eigen_st = require_any_not_t< container_type_check_base< is_eigen, scalar_type_t, TypeCheck, Check >... >
Require at least one of the types does not satisfy is_eigen.

template<template< class... > class TypeCheck, class... Check>
using require_all_eigen_st = require_all_t< container_type_check_base< is_eigen, scalar_type_t, TypeCheck, Check >... >
Require all of the types does not satisfy is_eigen.

template<template< class... > class TypeCheck, class... Check>
using require_all_not_eigen_st = require_all_not_t< container_type_check_base< is_eigen, scalar_type_t, TypeCheck, Check >... >
Require none of the types satisfy is_eigen.

template<typename T >
using require_eigen_array_t = require_t< is_eigen_array< std::decay_t< T > > >
Require type satisfies is_eigen_array.

template<typename T >
using require_not_eigen_array_t = require_not_t< is_eigen_array< std::decay_t< T > > >
Require type does not satisfy is_eigen_array.

template<typename... Types>
using require_any_eigen_array_t = require_any_t< is_eigen_array< std::decay_t< Types > >... >
Require any of the types satisfy is_eigen_array.

template<typename T >
using is_eigen_matrix_or_array = math::disjunction< is_eigen_matrix_base< T >, is_eigen_array< T > >
Check if a type is derived from Eigen::MatrixBase or Eigen::ArrayBase

template<template< class... > class TypeCheck, class... Check>
using require_eigen_array_vt = require_t< container_type_check_base< is_eigen_array, value_type_t, TypeCheck, Check... > >
Require type satisfies is_eigen_array.

template<typename T >
using require_eigen_dense_base_t = require_t< is_eigen_dense_base< std::decay_t< T > > >
Require type satisfies is_eigen_dense_base.

template<template< class... > class TypeCheck, class... Check>
using require_eigen_dense_base_vt = require_t< container_type_check_base< is_eigen_dense_base, value_type_t, TypeCheck, Check... > >
Require type satisfies is_eigen_dense_base.

template<typename T >
using is_eigen_dense_dynamic = stan::internal::is_eigen_matrix_dynamic_impl< std::decay_t< T >, stan::is_eigen_dense_base< std::decay_t< T > >::value >
Checks whether type T is derived from Eigen::DenseBase and has dynamic rows and columns.

template<typename T >
using require_eigen_dense_dynamic_t = require_t< is_eigen_dense_dynamic< std::decay_t< T > > >
Require type satisfies is_eigen_dense_dynamic.

template<typename... Types>
using require_all_eigen_dense_dynamic_t = require_all_t< is_eigen_dense_dynamic< std::decay_t< Types > >... >
Require all of the types satisfy is_eigen_dense_dynamic.

template<template< class... > class TypeCheck, class... Check>
using require_eigen_dense_dynamic_vt = require_t< container_type_check_base< is_eigen_dense_dynamic, value_type_t, TypeCheck, Check... > >
Require type satisfies is_eigen_dense_dynamic.

template<typename T >
using require_eigen_matrix_dynamic_t = require_t< is_eigen_matrix_dynamic< std::decay_t< T > > >
Require type satisfies is_eigen_matrix_dynamic.

template<typename... Types>
using require_all_eigen_matrix_dynamic_t = require_all_t< is_eigen_matrix_dynamic< std::decay_t< Types > >... >
Require all of the types satisfy is_eigen_matrix_dynamic.

template<typename... Types>
using require_any_eigen_matrix_dynamic_t = require_any_t< is_eigen_matrix_dynamic< std::decay_t< Types > >... >
Require any of the types satisfy is_eigen_matrix_dynamic.

template<template< class... > class TypeCheck, class... Check>
using require_eigen_matrix_dynamic_vt = require_t< container_type_check_base< is_eigen_matrix_dynamic, value_type_t, TypeCheck, Check... > >
Require type satisfies is_eigen_matrix_dynamic.

template<typename T >
using require_eigen_matrix_base_t = require_t< is_eigen_matrix_base< std::decay_t< T > > >
Require type satisfies is_eigen_matrix_base.

template<template< class... > class TypeCheck, class... Check>
using require_eigen_matrix_base_vt = require_t< container_type_check_base< is_eigen_matrix_base, value_type_t, TypeCheck, Check... > >
Require type satisfies is_eigen_matrix_base.

template<template< class... > class TypeCheck, class... Check>
using require_all_eigen_matrix_base_vt = require_all_t< container_type_check_base< is_eigen_matrix_base, value_type_t, TypeCheck, Check >... >
Require all of the types satisfy is_eigen_matrix_base.

template<typename T >
using require_eigen_sparse_base_t = require_t< is_eigen_sparse_base< std::decay_t< T > > >
Require type satisfies is_eigen_sparse_base.

template<typename T >
using require_fvar_t = require_t< is_fvar< std::decay_t< T > > >
Require type satisfies is_fvar.

template<typename T >
using require_not_fvar_t = require_not_t< is_fvar< std::decay_t< T > > >
Require type does not satisfy is_fvar.

template<typename... Types>
using require_all_fvar_t = require_all_t< is_fvar< std::decay_t< Types > >... >
Require all of the types satisfy is_fvar.

template<typename... Types>
using require_any_fvar_t = require_any_t< is_fvar< std::decay_t< Types > >... >
Require any of the types satisfy is_fvar.

template<typename... Types>
using require_all_not_fvar_t = require_all_not_t< is_fvar< std::decay_t< Types > >... >
Require none of the types satisfy is_fvar.

template<typename... Types>
using require_any_not_fvar_t = require_any_not_t< is_fvar< std::decay_t< Types > >... >
Require at least one of the types do not satisfy is_fvar.

template<typename... Types>
using require_any_vt_fvar = require_any_t< is_fvar< value_type_t< std::decay_t< Types > > >... >
Require any of the value types satisfy is_fvar.

template<typename... Types>
using require_all_not_vt_fvar = require_all_not_t< is_fvar< value_type_t< std::decay_t< Types > > >... >
Require none of the value types satisfy is_fvar.

template<typename T >
using require_st_fvar = require_t< is_fvar< scalar_type_t< std::decay_t< T > > > >
Require scalar type satisfies is_fvar.

template<typename T >
using require_not_st_fvar = require_not_t< is_fvar< scalar_type_t< std::decay_t< T > > > >
Require scalar type does not satisfy is_fvar.

template<typename... Types>
using require_any_st_fvar = require_any_t< is_fvar< scalar_type_t< std::decay_t< Types > > >... >
Require any of the scalar types satisfy is_fvar.

template<typename... Types>
using require_all_not_st_fvar = require_all_not_t< is_fvar< scalar_type_t< std::decay_t< Types > > >... >
Require none of the scalar types satisfy is_fvar.

template<typename... Types>
using require_all_kernel_expressions_and_none_scalar_t = require_all_t< is_kernel_expression_and_not_scalar< Types >... >
Enables a template if all given types are non-scalar types that are a valid kernel generator expressions.

template<typename... Types>
using require_all_kernel_expressions_t = require_all_t< is_kernel_expression< Types >... >
Enables a template if all given types are are a valid kernel generator expressions.

template<typename T >
using require_kernel_expression_lhs_t = require_t< is_kernel_expression_lhs< std::decay_t< T > > >
Require type satisfies is_kernel_expression_lhs.

template<typename T >
using require_rev_kernel_expression_t = require_t< is_rev_kernel_expression< std::decay_t< T > > >
Require type satisfies is_rev_kernel_expression.

template<typename T >
using require_not_rev_kernel_expression_t = require_not_t< is_rev_kernel_expression< std::decay_t< T > > >
Require type does not satisfy is_rev_kernel_expression.

template<typename... Types>
using require_all_prim_or_rev_kernel_expression_t = require_all_t< is_prim_or_rev_kernel_expression< std::decay_t< Types > >... >
Require type satisfies is_prim_or_rev_kernel_expression.

template<typename T >
using require_nonscalar_prim_or_rev_kernel_expression_t = require_t< is_nonscalar_prim_or_rev_kernel_expression< std::decay_t< T > > >
Require type satisfies is_nonscalar_prim_or_rev_kernel_expression.

template<typename T >
using require_not_nonscalar_prim_or_rev_kernel_expression_t = require_not_t< is_nonscalar_prim_or_rev_kernel_expression< std::decay_t< T > > >
Require type does not satisfy is_nonscalar_prim_or_rev_kernel_expression.

template<typename... Types>
using require_all_nonscalar_prim_or_rev_kernel_expression_t = require_all_t< is_nonscalar_prim_or_rev_kernel_expression< std::decay_t< Types > >... >
Require all of the types satisfy is_nonscalar_prim_or_rev_kernel_expression.

template<typename... Types>
using require_any_nonscalar_prim_or_rev_kernel_expression_t = require_any_t< is_nonscalar_prim_or_rev_kernel_expression< std::decay_t< Types > >... >
Require any of the types satisfy is_nonscalar_prim_or_rev_kernel_expression.

template<typename... Types>
using require_all_not_nonscalar_prim_or_rev_kernel_expression_t = require_all_not_t< is_nonscalar_prim_or_rev_kernel_expression< std::decay_t< Types > >... >
Require none of the types satisfy is_nonscalar_prim_or_rev_kernel_expression.

template<typename T >
using require_matrix_t = require_t< is_matrix< std::decay_t< T > > >
Require type satisfies is_matrix.

template<typename T >
using require_not_matrix_t = require_not_t< is_matrix< std::decay_t< T > > >
Require type does not satisfy is_matrix.

template<typename... Types>
using require_all_matrix_t = require_all_t< is_matrix< std::decay_t< Types > >... >
Require all of the types satisfy is_matrix.

template<typename... Types>
using require_any_matrix_t = require_any_t< is_matrix< std::decay_t< Types > >... >
Require any of the types satisfy is_matrix.

template<typename... Types>
using require_all_not_matrix_t = require_all_not_t< is_matrix< std::decay_t< Types > >... >
Require none of the types satisfy is_matrix.

template<template< class... > class TypeCheck, class... Check>
using require_any_matrix_st = require_any_t< container_type_check_base< is_matrix, scalar_type_t, TypeCheck, Check >... >
Require any of the types satisfy is_matrix.

template<template< class... > class TypeCheck, class... Check>
using require_all_matrix_st = require_all_t< container_type_check_base< is_matrix, scalar_type_t, TypeCheck, Check >... >
Require all of the types does not satisfy is_matrix.

template<template< class... > class TypeCheck, class... Check>
using require_all_not_matrix_st = require_all_not_t< container_type_check_base< is_matrix, scalar_type_t, TypeCheck, Check >... >
Require none of the types satisfy is_matrix.

template<typename T >
using require_matrix_cl_t = require_t< is_matrix_cl< std::decay_t< T > > >
Require type satisfies is_matrix_cl.

template<typename T >
using require_not_matrix_cl_t = require_not_t< is_matrix_cl< std::decay_t< T > > >
Require type does not satisfy is_matrix_cl.

template<typename... Types>
using require_all_matrix_cl_t = require_all_t< is_matrix_cl< std::decay_t< Types > >... >
Require all of the types satisfy is_matrix_cl.

template<typename... Types>
using require_any_matrix_cl_t = require_any_t< is_matrix_cl< std::decay_t< Types > >... >
Require any of the types satisfy is_matrix_cl.

template<typename... Types>
using require_all_not_matrix_cl_t = require_all_not_t< is_matrix_cl< std::decay_t< Types > >... >
Require none of the types satisfy is_matrix_cl.

template<typename... Types>
using require_any_not_matrix_cl_t = require_any_not_t< is_matrix_cl< std::decay_t< Types > >... >
Require at least one of the types do not satisfy is_matrix_cl.

template<template< class... > class TypeCheck, class... Check>
using require_matrix_cl_vt = require_t< container_type_check_base< is_matrix_cl, value_type_t, TypeCheck, Check... > >
Require type satisfies is_matrix_cl.

template<template< class... > class TypeCheck, class... Check>
using require_not_matrix_cl_vt = require_not_t< container_type_check_base< is_matrix_cl, value_type_t, TypeCheck, Check... > >
Require type does not satisfy is_matrix_cl or.

template<template< class... > class TypeCheck, class... Check>
using require_any_matrix_cl_vt = require_any_t< container_type_check_base< is_matrix_cl, value_type_t, TypeCheck, Check >... >
Require any of the types satisfy is_matrix_cl.

template<template< class... > class TypeCheck, class... Check>
using require_any_not_matrix_cl_vt = require_any_not_t< container_type_check_base< is_matrix_cl, value_type_t, TypeCheck, Check >... >
Require at least one of the types does not satisfy is_matrix_cl.

template<template< class... > class TypeCheck, class... Check>
using require_all_matrix_cl_vt = require_all_t< container_type_check_base< is_matrix_cl, value_type_t, TypeCheck, Check >... >
Require all of the types satisfy is_matrix_cl.

template<template< class... > class TypeCheck, class... Check>
using require_all_not_matrix_cl_vt = require_all_not_t< container_type_check_base< is_matrix_cl, value_type_t, TypeCheck, Check >... >
Require none of the types satisfy is_matrix_cl.

template<template< class... > class TypeCheck, class... Check>
using require_matrix_cl_st = require_t< container_type_check_base< is_matrix_cl, scalar_type_t, TypeCheck, Check... > >
Require type satisfies is_matrix_cl.

template<typename S >
using is_plain_type = std::is_same< std::decay_t< S >, plain_type_t< S > >
Checks whether the template type T is an assignable type.

template<typename T >
using require_plain_type_t = require_t< is_plain_type< std::decay_t< T > > >
Require type satisfies is_plain_type.

template<typename T >
using require_not_plain_type_t = require_not_t< is_plain_type< std::decay_t< T > > >
Require type does not satisfy is_plain_type.

template<typename... Types>
using require_all_plain_type_t = require_all_t< is_plain_type< std::decay_t< Types > >... >
Require all of the types satisfy is_plain_type.

template<typename... Types>
using require_any_not_plain_type_t = require_any_not_t< is_plain_type< std::decay_t< Types > >... >
Require any of the types satisfy is_plain_type.

template<typename T >
using require_rev_matrix_t = require_t< is_rev_matrix< std::decay_t< T > > >
Require type satisfies is_rev_matrix.

template<typename T >
using require_not_rev_matrix_t = require_not_t< is_rev_matrix< std::decay_t< T > > >
Require type does not satisfy is_rev_matrix.

template<typename... Types>
using require_all_rev_matrix_t = require_all_t< is_rev_matrix< std::decay_t< Types > >... >
Require all of the types satisfy is_rev_matrix.

template<typename... Types>
using require_any_rev_matrix_t = require_any_t< is_rev_matrix< std::decay_t< Types > >... >
Require any of the types satisfy is_rev_matrix.

template<typename... Types>
using require_all_not_rev_matrix_t = require_all_not_t< is_rev_matrix< std::decay_t< Types > >... >
Require none of the types satisfy is_rev_matrix.

template<typename T >
using require_rev_col_vector_t = require_t< is_rev_col_vector< std::decay_t< T > > >
Require type satisfies is_rev_col_vector.

template<typename T >
using require_rev_vector_t = require_t< is_rev_vector< std::decay_t< T > > >
Require type satisfies is_rev_vector.

template<typename T >
using require_stan_scalar_t = require_t< is_stan_scalar< std::decay_t< T > > >
Require type satisfies is_stan_scalar.

template<typename T >
using require_not_stan_scalar_t = require_not_t< is_stan_scalar< std::decay_t< T > > >
Require type does not satisfy is_stan_scalar.

template<typename... Types>
using require_all_stan_scalar_t = require_all_t< is_stan_scalar< std::decay_t< Types > >... >
Require all of the types satisfy is_stan_scalar.

template<typename... Types>
using require_any_stan_scalar_t = require_any_t< is_stan_scalar< std::decay_t< Types > >... >
Require any of the types satisfy is_stan_scalar.

template<typename... Types>
using require_all_not_stan_scalar_t = require_all_not_t< is_stan_scalar< std::decay_t< Types > >... >
Require none of the types satisfy is_stan_scalar.

template<typename... Types>
using require_any_not_stan_scalar_t = require_any_not_t< is_stan_scalar< std::decay_t< Types > >... >
Require at least one of the types do not satisfy is_stan_scalar.

template<typename T >
using require_not_vt_stan_scalar = require_not_t< is_stan_scalar< value_type_t< std::decay_t< T > > > >
Require value type does not satisfy is_stan_scalar.

template<typename T >
using require_st_stan_scalar = require_t< is_stan_scalar< scalar_type_t< std::decay_t< T > > > >
Require scalar type satisfies is_stan_scalar.

template<typename T >
using require_not_st_stan_scalar = require_not_t< is_stan_scalar< scalar_type_t< std::decay_t< T > > > >
Require scalar type does not satisfy is_stan_scalar.

template<typename... Types>
using require_all_st_stan_scalar = require_all_t< is_stan_scalar< scalar_type_t< std::decay_t< Types > > >... >
Require all of the scalar types satisfy is_stan_scalar.

template<typename T >
using is_stan_scalar_or_eigen = bool_constant< is_stan_scalar< std::decay_t< T > >::value||is_eigen< std::decay_t< T > >::value >
Extends std::true_type if all the provided types are either a Stan Scalar type or a type inheriting from EigenBase.

template<typename T >
using require_stan_scalar_or_eigen_t = require_t< is_stan_scalar_or_eigen< std::decay_t< T > > >
Require type satisfies is_stan_scalar_or_eigen.

template<typename T >
using is_string_convertible = std::is_convertible< T, std::string >
Deduces whether type is convertible to string.

template<typename T >
using require_string_convertible_t = require_t< is_string_convertible< std::decay_t< T > > >
Require type satisfies is_string_convertible.

template<typename T >
using require_not_string_convertible_t = require_not_t< is_string_convertible< std::decay_t< T > > >
Require type does not satisfy is_string_convertible.

template<typename... Types>
using require_all_string_convertible_t = require_all_t< is_string_convertible< std::decay_t< Types > >... >
Require all of the types satisfy is_string_convertible.

template<typename... Types>
using require_any_string_convertible_t = require_any_t< is_string_convertible< std::decay_t< Types > >... >
Require any of the types satisfy is_string_convertible.

template<typename... Types>
using require_all_not_string_convertible_t = require_all_not_t< is_string_convertible< std::decay_t< Types > >... >
Require none of the types satisfy is_string_convertible.

template<typename... Types>
using require_any_not_string_convertible_t = require_any_not_t< is_string_convertible< std::decay_t< Types > >... >
Require at least one of the types do not satisfy is_string_convertible.

template<typename T >
using require_var_t = require_t< is_var< std::decay_t< T > > >
Require type satisfies is_var.

template<typename T >
using require_not_var_t = require_not_t< is_var< std::decay_t< T > > >
Require type does not satisfy is_var.

template<typename... Types>
using require_all_var_t = require_all_t< is_var< std::decay_t< Types > >... >
Require all of the types satisfy is_var.

template<typename... Types>
using require_any_var_t = require_any_t< is_var< std::decay_t< Types > >... >
Require any of the types satisfy is_var.

template<typename... Types>
using require_all_not_var_t = require_all_not_t< is_var< std::decay_t< Types > >... >
Require none of the types satisfy is_var.

template<typename... Types>
using require_any_not_var_t = require_any_not_t< is_var< std::decay_t< Types > >... >
Require at least one of the types do not satisfy is_var.

template<template< class... > class TypeCheck, class... Check>
using require_var_vt = require_t< container_type_check_base< is_var, value_type_t, TypeCheck, Check... > >
Require type satisfies is_var.

template<template< class... > class TypeCheck, class... Check>
using require_any_var_vt = require_any_t< container_type_check_base< is_var, value_type_t, TypeCheck, Check >... >
Require any of the types satisfy is_var.

template<template< class... > class TypeCheck, class... Check>
using require_all_var_vt = require_all_t< container_type_check_base< is_var, value_type_t, TypeCheck, Check >... >
Require all of the types satisfy is_var.

template<typename T >
using require_not_vt_var = require_not_t< is_var< value_type_t< std::decay_t< T > > > >
Require value type does not satisfy is_var.

template<typename... Types>
using require_any_vt_var = require_any_t< is_var< value_type_t< std::decay_t< Types > > >... >
Require any of the value_types satisfy is_var.

template<typename... Types>
using require_all_not_vt_var = require_all_not_t< is_var< value_type_t< std::decay_t< Types > > >... >
Require none of the value_types satisfy is_var.

template<typename T >
using require_st_var = require_t< is_var< scalar_type_t< std::decay_t< T > > > >
Require scalar_type satisfies is_var.

template<typename T >
using require_not_st_var = require_not_t< is_var< scalar_type_t< std::decay_t< T > > > >
Require scalar type does not satisfy is_var.

template<typename... Types>
using require_all_st_var = require_all_t< is_var< scalar_type_t< std::decay_t< Types > > >... >
Require all of the scalar types satisfy is_var.

template<typename... Types>
using require_any_st_var = require_any_t< is_var< scalar_type_t< std::decay_t< Types > > >... >
Require any of the scalar types satisfy is_var.

template<typename... Types>
using require_all_not_st_var = require_all_not_t< is_var< scalar_type_t< std::decay_t< Types > > >... >
Require none of the scalar types satisfy is_var.

template<typename... Types>
using is_var_and_matrix_types = bool_constant< is_var< return_type_t< Types... > >::value &&stan::math::disjunction< is_matrix< Types >... >::value >
Extends std::true_type when instantiated with at least one type that has a var scalar_type and at least one type is a matrix.

template<typename... Types>
using require_all_not_var_and_matrix_types = require_not_t< is_var_and_matrix_types< Types... > >

template<typename T >
using require_var_dense_dynamic_t = require_t< is_var_dense_dynamic< std::decay_t< T > > >
Require type satisfies is_var_dense_dynamic.

template<typename T >
using require_var_matrix_t = require_t< is_var_matrix< std::decay_t< T > > >
Require type satisfies is_var_matrix.

template<typename T >
using require_not_var_matrix_t = require_not_t< is_var_matrix< std::decay_t< T > > >
Require type does not satisfy is_var_matrix.

template<typename... Types>
using require_all_var_matrix_t = require_all_t< is_var_matrix< std::decay_t< Types > >... >
Require all of the types satisfy is_var_matrix.

template<typename... Types>
using require_any_var_matrix_t = require_any_t< is_var_matrix< std::decay_t< Types > >... >
Require any of the types satisfy is_var_matrix.

template<typename... Types>
using require_all_not_var_matrix_t = require_all_not_t< is_var_matrix< std::decay_t< Types > >... >
Require none of the types satisfy is_var_matrix.

template<typename T >
using require_var_col_vector_t = require_t< is_var_col_vector< std::decay_t< T > > >
Require type satisfies is_var_col_vector.

template<typename T >
using require_not_var_col_vector_t = require_not_t< is_var_col_vector< std::decay_t< T > > >
Require type does not satisfy is_var_col_vector.

template<typename T >
using require_var_row_vector_t = require_t< is_var_row_vector< std::decay_t< T > > >
Require type satisfies is_var_row_vector.

template<typename T >
using require_var_vector_t = require_t< is_var_vector< std::decay_t< T > > >
Require type satisfies is_var_vector.

template<typename... Types>
using require_all_var_vector_t = require_all_t< is_var_vector< std::decay_t< Types > >... >
Require all of the types satisfy is_var_vector.

template<typename... Types>
using require_any_var_vector_t = require_any_t< is_var_vector< std::decay_t< Types > >... >
Require any of the types satisfy is_var_vector.

template<typename... T>
using is_var_or_arithmetic = math::conjunction< is_var_or_arithmetic_type< T >... >
Extends std::true_type if all the provided types are either var or an arithmetic type, extends std::false_type otherwise.

template<typename T >
using require_var_or_arithmetic_t = require_t< is_var_or_arithmetic< std::decay_t< T > > >
Require type satisfies is_var_or_arithmetic.

template<typename T >
using require_not_var_or_arithmetic_t = require_not_t< is_var_or_arithmetic< std::decay_t< T > > >
Require type does not satisfy is_var_or_arithmetic.

template<typename... Types>
using require_all_var_or_arithmetic_t = require_all_t< is_var_or_arithmetic< std::decay_t< Types > >... >
Require all of the types satisfy is_var_or_arithmetic.

template<typename... Types>
using require_any_var_or_arithmetic_t = require_any_t< is_var_or_arithmetic< std::decay_t< Types > >... >
Require any of the types satisfy is_var_or_arithmetic.

template<typename... Types>
using require_all_not_var_or_arithmetic_t = require_all_not_t< is_var_or_arithmetic< std::decay_t< Types > >... >
Require none of the types satisfy is_var_or_arithmetic.

template<typename... Types>
using require_any_not_var_or_arithmetic_t = require_any_not_t< is_var_or_arithmetic< std::decay_t< Types > >... >
Require at least one of the types do not satisfy is_var_or_arithmetic.

template<typename... Types>
using require_all_st_var_or_arithmetic = require_all_t< is_var_or_arithmetic< scalar_type_t< std::decay_t< Types > > >... >
Require all of the scalar types satisfy is_var_or_arithmetic.

template<typename T >
using require_eigen_col_vector_t = require_t< is_eigen_col_vector< std::decay_t< T > > >
Require type satisfies is_eigen_col_vector.

template<typename T >
using require_not_eigen_col_vector_t = require_not_t< is_eigen_col_vector< std::decay_t< T > > >
Require type does not satisfy is_eigen_col_vector.

template<typename... Types>
using require_all_eigen_col_vector_t = require_all_t< is_eigen_col_vector< std::decay_t< Types > >... >
Require all of the types satisfy is_eigen_col_vector.

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... > >
Require type satisfies is_eigen_col_vector.

template<typename T >
using require_col_vector_t = require_t< is_col_vector< std::decay_t< T > > >
Require type satisfies is_col_vector.

template<typename T >
using require_not_col_vector_t = require_not_t< is_col_vector< std::decay_t< T > > >
Require type does not satisfy is_col_vector.

template<typename... Types>
using require_all_col_vector_t = require_all_t< is_col_vector< std::decay_t< Types > >... >
Require all of the types satisfy is_col_vector.

template<typename T >
using require_eigen_row_vector_t = require_t< is_eigen_row_vector< std::decay_t< T > > >
Require type satisfies is_eigen_row_vector.

template<typename T >
using require_row_vector_t = require_t< is_row_vector< std::decay_t< T > > >
Require type satisfies is_row_vector.

template<typename T >
using require_eigen_vector_t = require_t< is_eigen_vector< std::decay_t< T > > >
Require type satisfies is_eigen_vector.

template<typename T >
using require_not_eigen_vector_t = require_not_t< is_eigen_vector< std::decay_t< T > > >
Require type does not satisfy is_eigen_vector.

template<typename... Types>
using require_all_eigen_vector_t = require_all_t< is_eigen_vector< std::decay_t< Types > >... >
Require all of the types satisfy is_eigen_vector.

template<typename... Types>
using require_any_eigen_vector_t = require_any_t< is_eigen_vector< std::decay_t< Types > >... >
Require any of the types satisfy is_eigen_vector.

template<typename... Types>
using require_all_not_eigen_vector_t = require_all_not_t< is_eigen_vector< std::decay_t< Types > >... >
Require none of the types satisfy is_eigen_vector.

template<typename... Types>
using require_any_not_eigen_vector_t = require_any_not_t< is_eigen_vector< std::decay_t< Types > >... >
Require at least one of the types do not satisfy is_eigen_vector.

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... > >
Require type satisfies is_eigen_vector.

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... > >
Require type does not satisfy is_eigen_vector or.

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 >... >
Require any of the types satisfy is_eigen_vector.

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 >... >
Require at least one of the types does not satisfy is_eigen_vector.

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 >... >
Require all of the types satisfy is_eigen_vector.

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 >... >
Require none of the types satisfy is_eigen_vector.

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... > >
Require type satisfies is_eigen_vector.

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... > >
Require type does not satisfy is_eigen_vector.

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 >... >
Require any of the types satisfy is_eigen_vector.

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 >... >
Require at least one of the types does not satisfy is_eigen_vector.

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 >... >
Require all of the types does not satisfy is_eigen_vector.

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 >... >
Require none of the types satisfy is_eigen_vector.

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 > > >
Require Row is a row vector and Col is a column vector.

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 > > >
Require Row is not a row vector and Col is not a column vector.

template<typename Row , typename Col >
using require_row_and_col_vector_t = require_t< math::conjunction< is_row_vector< Row >, is_col_vector< Col > > >
Require Row is a row vector and Col is a column vector.

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 > > >
Require Row is not a row vector and Col is not a column vector.

template<typename T >
using require_vector_t = require_t< is_vector< std::decay_t< T > > >
Require type satisfies is_vector.

template<typename T >
using require_not_vector_t = require_not_t< is_vector< std::decay_t< T > > >
Require type does not satisfy is_vector.

template<typename... Types>
using require_all_vector_t = require_all_t< is_vector< std::decay_t< Types > >... >
Require all of the types satisfy is_vector.

template<typename... Types>
using require_any_vector_t = require_any_t< is_vector< std::decay_t< Types > >... >
Require any of the types satisfy is_vector.

template<typename... Types>
using require_all_not_vector_t = require_all_not_t< is_vector< std::decay_t< Types > >... >
Require none of the types satisfy is_vector.

template<typename... Types>
using require_any_not_vector_t = require_any_not_t< is_vector< std::decay_t< Types > >... >
Require at least one of the types do not satisfy is_vector.

template<template< class... > class TypeCheck, class... Check>
using require_vector_vt = require_t< container_type_check_base< is_vector, value_type_t, TypeCheck, Check... > >
Require type satisfies is_vector.

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... > >
Require type does not satisfy is_vector or.

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 >... >
Require any of the types satisfy is_vector.

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 >... >
Require at least one of the types does not satisfy is_vector.

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 >... >
Require all of the types satisfy is_vector.

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 >... >
Require none of the types satisfy is_vector.

template<template< class... > class TypeCheck, class... Check>
using require_vector_st = require_t< container_type_check_base< is_vector, scalar_type_t, TypeCheck, Check... > >
Require type satisfies is_vector.

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... > >
Require type does not satisfy is_vector.

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 >... >
Require any of the types satisfy is_vector.

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 >... >
Require at least one of the types does not satisfy is_vector.

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 >... >
Require all of the types does not satisfy is_vector.

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 >... >
Require none of the types satisfy is_vector.

template<typename T >
using require_std_vector_t = require_t< is_std_vector< std::decay_t< T > > >
Require type satisfies is_std_vector.

template<typename T >
using require_not_std_vector_t = require_not_t< is_std_vector< std::decay_t< T > > >
Require type does not satisfy is_std_vector.

template<typename... Types>
using require_all_std_vector_t = require_all_t< is_std_vector< std::decay_t< Types > >... >
Require all of the types satisfy is_std_vector.

template<typename... Types>
using require_any_std_vector_t = require_any_t< is_std_vector< std::decay_t< Types > >... >
Require any of the types satisfy is_std_vector.

template<typename... Types>
using require_all_not_std_vector_t = require_all_not_t< is_std_vector< std::decay_t< Types > >... >
Require none of the types satisfy is_std_vector.

template<typename... Types>
using require_any_not_std_vector_t = require_any_not_t< is_std_vector< std::decay_t< Types > >... >
Require at least one of the types do not satisfy is_std_vector.

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... > >
Require type satisfies is_std_vector.

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... > >
Require type does not satisfy is_std_vector or.

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 >... >
Require any of the types satisfy is_std_vector.

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 >... >
Require at least one of the types does not satisfy is_std_vector.

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 >... >
Require all of the types satisfy is_std_vector.

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 >... >
Require none of the types satisfy is_std_vector.

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... > >
Require type satisfies is_std_vector.

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... > >
Require type does not satisfy is_std_vector.

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 >... >
Require any of the types satisfy is_std_vector.

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 >... >
Require at least one of the types does not satisfy is_std_vector.

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 >... >
Require all of the types does not satisfy is_std_vector.

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 >... >
Require none of the types satisfy is_std_vector.

template<typename T >
using require_vector_like_t = require_t< is_vector_like< std::decay_t< T > > >
Require type satisfies is_vector_like.

template<typename T >
using require_not_vector_like_t = require_not_t< is_vector_like< std::decay_t< T > > >
Require type does not satisfy is_vector_like.

template<typename... Types>
using require_all_vector_like_t = require_all_t< is_vector_like< std::decay_t< Types > >... >
Require all of the types satisfy is_vector_like.

template<typename... Types>
using require_any_vector_like_t = require_any_t< is_vector_like< std::decay_t< Types > >... >
Require any of the types satisfy is_vector_like.

template<typename... Types>
using require_all_not_vector_like_t = require_all_not_t< is_vector_like< std::decay_t< Types > >... >
Require none of the types satisfy is_vector_like.

template<typename... Types>
using require_any_not_vector_like_t = require_any_not_t< is_vector_like< std::decay_t< Types > >... >
Require at least one of the types do not satisfy is_vector_like.

template<template< class... > class TypeCheck, class... Check>
using require_vector_like_vt = require_t< container_type_check_base< is_vector_like, value_type_t, TypeCheck, Check... > >
Require type satisfies is_vector_like.

template<typename... Args>
using partials_return_t = typename partials_return_type< Args... >::type

template<typename T >
using partials_type_t = typename partials_type< T >::type
Helper alias for accessing the partial type.

template<typename T >
using plain_type_t = typename plain_type< T >::type

template<typename T >
using eval_return_type_t = typename eval_return_type< T >::type

template<typename... Args>
using promote_args_t = typename boost::math::tools::promote_args< Args... >::type
Convenience alias for boost tools promote_args.

template<typename T >
using ref_type_t = typename ref_type_if< true, T >::type

template<bool Condition, typename T >
using ref_type_if_t = typename ref_type_if< Condition, T >::type

template<typename T >
using ref_type_if_not_constant_t = typename ref_type_if<!is_constant< T >::value, T >::type

template<typename T , typename S >
using require_same_t = require_t< std::is_same< std::decay_t< T >, std::decay_t< S > > >
Require types T and S satisfies std::is_same.

template<typename T , typename S >
using require_not_same_t = require_not_t< std::is_same< std::decay_t< T >, std::decay_t< S > > >
Require types T and S does not satisfy std::is_same.

template<typename T , typename... Types>
using require_all_same_t = require_all_t< std::is_same< std::decay_t< T >, std::decay_t< Types > >... >
Require T and all of the Types satisfy std::is_same.

template<typename T , typename... Types>
using require_any_same_t = require_any_t< std::is_same< std::decay_t< T >, std::decay_t< Types > >... >
Require any of the Types and T satisfy std::is_same.

template<typename T , typename... Types>
using require_all_not_same_t = require_all_not_t< std::is_same< std::decay_t< T >, std::decay_t< Types > >... >
Require none of the Types and T satisfy std::is_same.

template<typename T , typename... Types>
using require_any_not_same_t = require_any_not_t< std::is_same< std::decay_t< T >, std::decay_t< Types > >... >
Any one of the Types and T do not satisfy std::is_same.

template<typename T , typename S >
using require_st_same = require_t< std::is_same< scalar_type_t< std::decay_t< T > >, scalar_type_t< std::decay_t< S > > > >
Require that value types of T and S satisfies std::is_same.

template<typename T , typename S >
using require_not_st_same = require_not_t< std::is_same< scalar_type_t< std::decay_t< T > >, scalar_type_t< std::decay_t< S > > > >
Require scalar types of T and S does not satisfy std::is_same.

template<typename T , typename... Types>
using require_all_st_same = require_all_t< std::is_same< scalar_type_t< std::decay_t< T > >, scalar_type_t< std::decay_t< Types > > >... >
All scalar types of T and all of the Types satisfy std::is_same.

template<typename T , typename... Types>
using require_any_not_st_same = require_any_not_t< std::is_same< scalar_type_t< std::decay_t< T > >, scalar_type_t< std::decay_t< Types > > >... >
Any of the scalar types Types and T do not satisfy std::is_same.

template<typename T , typename S >
using require_vt_same = require_t< std::is_same< value_type_t< std::decay_t< T > >, value_type_t< std::decay_t< S > > > >
Value types of T and S satisfies std::is_same.

template<typename T , typename... Types>
using require_all_vt_same = require_all_t< std::is_same< value_type_t< std::decay_t< T > >, value_type_t< std::decay_t< Types > > >... >
Value types of T and all of the Types satisfy std::is_same.

template<typename T , typename S >
using require_convertible_t = require_t< std::is_convertible< std::decay_t< T >, std::decay_t< S > > >
Require types T and S satisfies std::is_convertible.

template<typename T , typename S >
using require_not_convertible_t = require_not_t< std::is_convertible< std::decay_t< T >, std::decay_t< S > > >
Require types T and S does not satisfy std::is_convertible.

template<typename T , typename... Types>
using require_all_convertible_t = require_all_t< std::is_convertible< std::decay_t< T >, std::decay_t< Types > >... >
Require T and all of the Types satisfy std::is_convertible.

template<typename T , typename... Types>
using require_any_not_convertible_t = require_any_not_t< std::is_convertible< std::decay_t< T >, std::decay_t< Types > >... >
Any one of the Types and T do not satisfy.

template<typename T , typename S >
using require_assignable_t = require_t< std::is_assignable< std::decay_t< T >, std::decay_t< S > > >
Require types T and S satisfies std::is_assignable.

template<typename T , typename S >
using require_not_assignable_t = require_not_t< std::is_assignable< std::decay_t< T >, std::decay_t< S > > >
Require types T and S does not satisfy std::is_assignable.

template<typename T , typename S >
using require_st_assignable = require_t< std::is_assignable< scalar_type_t< std::decay_t< T > >, scalar_type_t< std::decay_t< S > > > >
Require that value types of T and S satisfies std::is_assignable.

template<typename T , typename S >
using require_not_st_assignable = require_not_t< std::is_assignable< scalar_type_t< std::decay_t< T > >, scalar_type_t< std::decay_t< S > > > >
Require scalar types of T and S does not satisfy std::is_assignable.

template<typename T , typename... Types>
using require_all_st_assignable = require_all_t< std::is_assignable< scalar_type_t< std::decay_t< T > >, scalar_type_t< std::decay_t< Types > > >... >
All scalar types of T and all of the Types satisfy std::is_assignable.

template<typename T , typename... Types>
using require_any_st_assignable = require_any_t< std::is_assignable< scalar_type_t< std::decay_t< T > >, scalar_type_t< std::decay_t< Types > > >... >
Any of the scalar types of Types and T satisfy std::is_assignable.

template<typename T , typename... Types>
using require_all_not_st_assignable = require_all_not_t< std::is_assignable< scalar_type_t< std::decay_t< T > >, scalar_type_t< std::decay_t< Types > > >... >
None of the scalar types of Types and T satisfy std::is_assignable.

template<typename T , typename... Types>
using require_any_not_st_assignable = require_any_not_t< std::is_assignable< scalar_type_t< std::decay_t< T > >, scalar_type_t< std::decay_t< Types > > >... >
Any of the scalar types Types and T do not satisfy std::is_assignable.

template<typename T , typename S >
using require_vt_assignable = require_t< std::is_assignable< value_type_t< std::decay_t< T > >, value_type_t< std::decay_t< S > > > >
Value types of T and S satisfies std::is_assignable.

template<typename T , typename S >
using require_not_vt_assignable = require_not_t< std::is_assignable< value_type_t< std::decay_t< T > >, value_type_t< std::decay_t< S > > > >
Value types of T and S does not satisfy std::is_assignable.

template<typename T , typename... Types>
using require_all_vt_assignable = require_all_t< std::is_assignable< value_type_t< std::decay_t< T > >, value_type_t< std::decay_t< Types > > >... >
Value types of T and all of the Types satisfy std::is_assignable.

template<typename T , typename... Types>
using require_any_vt_assignable = require_any_t< std::is_assignable< value_type_t< std::decay_t< T > >, value_type_t< std::decay_t< Types > > >... >
Any of the value types of Types and T satisfy std::is_assignable.

template<typename T , typename... Types>
using require_all_not_vt_assignable = require_all_not_t< std::is_assignable< value_type_t< std::decay_t< T > >, value_type_t< std::decay_t< Types > > >... >
None of the value types of Types and T satisfy std::is_assignable.

template<typename T , typename... Types>
using require_any_not_vt_assignable = require_any_not_t< std::is_assignable< value_type_t< std::decay_t< T > >, value_type_t< std::decay_t< Types > > >... >
Any of the value types Types and T do not satisfy std::is_assignable.

template<typename T , typename S >
using require_constructible_t = require_t< std::is_constructible< std::decay_t< T >, std::decay_t< S > > >
Require types T and S satisfies std::is_constructible.

template<typename T , typename S >
using require_st_constructible = require_t< std::is_constructible< scalar_type_t< std::decay_t< T > >, scalar_type_t< std::decay_t< S > > > >
Require that value types of T and S satisfies std::is_constructible.

template<typename T , typename S >
using require_not_st_constructible = require_not_t< std::is_constructible< scalar_type_t< std::decay_t< T > >, scalar_type_t< std::decay_t< S > > > >
Require scalar types of T and S does not satisfy std::is_constructible.

template<typename T , typename... Types>
using require_all_st_constructible = require_all_t< std::is_constructible< scalar_type_t< std::decay_t< T > >, scalar_type_t< std::decay_t< Types > > >... >
All scalar types of T and all of the Types satisfy std::is_constructible.

template<typename T , typename... Types>
using require_any_st_constructible = require_any_t< std::is_constructible< scalar_type_t< std::decay_t< T > >, scalar_type_t< std::decay_t< Types > > >... >
Any of the scalar types of Types and T satisfy std::is_constructible.

template<typename T , typename... Types>
using require_all_not_st_constructible = require_all_not_t< std::is_constructible< scalar_type_t< std::decay_t< T > >, scalar_type_t< std::decay_t< Types > > >... >
None of the scalar types of Types and T satisfy std::is_constructible.

template<typename T , typename... Types>
using require_any_not_st_constructible = require_any_not_t< std::is_constructible< scalar_type_t< std::decay_t< T > >, scalar_type_t< std::decay_t< Types > > >... >
Any of the scalar types Types and T do not satisfy std::is_constructible.

template<typename T , typename S >
using require_vt_constructible = require_t< std::is_constructible< value_type_t< std::decay_t< T > >, value_type_t< std::decay_t< S > > > >
Value types of T and S satisfies std::is_constructible.

template<typename T , typename S >
using require_not_vt_constructible = require_not_t< std::is_constructible< value_type_t< std::decay_t< T > >, value_type_t< std::decay_t< S > > > >
Value types of T and S does not satisfy std::is_constructible.

template<typename T , typename... Types>
using require_all_vt_constructible = require_all_t< std::is_constructible< value_type_t< std::decay_t< T > >, value_type_t< std::decay_t< Types > > >... >
Value types of T and all of the Types satisfy std::is_constructible.

template<typename T , typename... Types>
using require_any_vt_constructible = require_any_t< std::is_constructible< value_type_t< std::decay_t< T > >, value_type_t< std::decay_t< Types > > >... >
Any of the value types of Types and T satisfy std::is_constructible.

template<typename T , typename... Types>
using require_all_not_vt_constructible = require_all_not_t< std::is_constructible< value_type_t< std::decay_t< T > >, value_type_t< std::decay_t< Types > > >... >
None of the value types of Types and T satisfy std::is_constructible.

template<typename T , typename... Types>
using require_any_not_vt_constructible = require_any_not_t< std::is_constructible< value_type_t< std::decay_t< T > >, value_type_t< std::decay_t< Types > > >... >
Any of the value types Types and T do not satisfy std::is_constructible.

template<typename T >
using require_arithmetic_t = require_t< std::is_arithmetic< std::decay_t< T > > >
Require type satisfies std::is_arithmetic.

template<typename T >
using require_not_arithmetic_t = require_not_t< std::is_arithmetic< std::decay_t< T > > >
Require type does not satisfy std::is_arithmetic.

template<typename... Types>
using require_all_arithmetic_t = require_all_t< std::is_arithmetic< std::decay_t< Types > >... >
Require all of the types satisfy std::is_arithmetic.

template<typename... Types>
using require_any_arithmetic_t = require_any_t< std::is_arithmetic< std::decay_t< Types > >... >
Require any of the types satisfy std::is_arithmetic.

template<typename... Types>
using require_all_not_arithmetic_t = require_all_not_t< std::is_arithmetic< std::decay_t< Types > >... >
Require none of the types satisfy std::is_arithmetic.

template<typename... Types>
using require_any_not_arithmetic_t = require_any_not_t< std::is_arithmetic< std::decay_t< Types > >... >
Require at least one of the types do not satisfy std::is_arithmetic.

template<typename... Types>
using require_all_vt_arithmetic = require_all_t< std::is_arithmetic< value_type_t< std::decay_t< Types > > >... >
Require all of the value types satisfy std::is_arithmetic.

template<typename... Types>
using require_any_not_vt_arithmetic = require_any_not_t< std::is_arithmetic< value_type_t< std::decay_t< Types > > >... >
Require at least one of the value types do not satisfy std::is_arithmetic.

template<typename T >
using require_st_arithmetic = require_t< std::is_arithmetic< scalar_type_t< std::decay_t< T > > > >
Require scalar type satisfies std::is_arithmetic.

template<typename T >
using require_not_st_arithmetic = require_not_t< std::is_arithmetic< scalar_type_t< std::decay_t< T > > > >
Require scalar type does not satisfy std::is_arithmetic.

template<typename... Types>
using require_all_st_arithmetic = require_all_t< std::is_arithmetic< scalar_type_t< std::decay_t< Types > > >... >
Require all of the scalar types satisfy std::is_arithmetic.

template<typename... Types>
using require_any_st_arithmetic = require_any_t< std::is_arithmetic< scalar_type_t< std::decay_t< Types > > >... >
Require any of the scalar types satisfy std::is_arithmetic.

template<typename... Types>
using require_any_not_st_arithmetic = require_any_not_t< std::is_arithmetic< scalar_type_t< std::decay_t< Types > > >... >
Any of the scalar types do not satisfy std::is_arithmetic.

template<typename T >
using require_floating_point_t = require_t< std::is_floating_point< std::decay_t< T > > >
Require type satisfies std::is_floating_point.

template<typename T >
using require_integral_t = require_t< std::is_integral< std::decay_t< T > > >
Require type satisfies std::is_integral.

template<typename T >
using require_vt_integral = require_t< std::is_integral< value_type_t< std::decay_t< T > > > >
Require value type satisfies std::is_integral.

template<typename T >
using require_st_integral = require_t< std::is_integral< scalar_type_t< std::decay_t< T > > > >
Require scalar type satisfies std::is_integral.

template<typename T >
using require_not_st_integral = require_not_t< std::is_integral< scalar_type_t< std::decay_t< T > > > >
Require scalar type does not satisfy std::is_integral.

template<typename... Types>
using require_all_not_st_integral = require_all_not_t< std::is_integral< scalar_type_t< std::decay_t< Types > > >... >
Require none of the scalar types satisfy std::is_integral.

template<class Check >
using require_t = std::enable_if_t< Check::value >
If condition is true, template is enabled.

template<typename Check >
using require_not_t = std::enable_if_t<!Check::value >
If condition is false, template is disabled.

template<class... Checks>
using require_all_t = std::enable_if_t< math::conjunction< Checks... >::value >
If all conditions are true, template is enabled Returns a type void if all conditions are true and otherwise fails.

template<class... Checks>
using require_any_t = std::enable_if_t< math::disjunction< Checks... >::value >
If any condition is true, template is enabled.

template<class... Checks>
using require_all_not_t = std::enable_if_t<!math::disjunction< Checks... >::value >
If all conditions are false, template is enabled.

template<class... Checks>
using require_any_not_t = std::enable_if_t<!math::conjunction< Checks... >::value >
If any condition is false, template is enabled.

template<template< class... > class ContainerCheck, template< class... > class ValueCheck, template< class... > class TypeCheck, class... Check>
using container_type_check_base = bool_constant< math::conjunction< ContainerCheck< std::decay_t< Check > >..., TypeCheck< ValueCheck< Check > >... >::value >
Used as the base for checking whether a type is a container with an underlying scalar type.

template<typename... Ts>
using real_return_t = typename real_return< Ts... >::type
Convenience type to calculate the real return type.

template<typename... Ts>
using complex_return_t = std::complex< real_return_t< Ts... > >
Convenience type to calculate the complex return type, which wraps std::complex around the return type of the specified template parameters.

template<typename... Ts>
using std_vector_return_t = std::vector< real_return_t< Ts... > >
Convenience type to calculate the complex return type, which wraps std::vector around the return type of the specified template parameters.

template<typename... Ts>
using matrix_return_t = Eigen::Matrix< real_return_t< Ts... >, -1, -1 >
Convenience type to calculate the complex return type, which wraps Eigen::Matrix< , -1, -1> around the return type of the specified template parameters.

template<typename... Ts>
using vector_return_t = Eigen::Matrix< real_return_t< Ts... >, -1, 1 >
Convenience type to calculate the complex return type, which wraps Eigen::Matrix< , -1, 1> around the return type of the specified template parameters.

template<typename... Ts>
using row_vector_return_t = Eigen::Matrix< real_return_t< Ts... >, 1, -1 >
Convenience type to calculate the complex return type, which wraps Eigen::Matrix< , 1, -1> around the return type of the specified template parameters.

template<typename T1 , typename T2 >
using scalar_lub_t = typename scalar_lub< T1, T2 >::type
Convenience type for the least upper bound of the specified template parameters in Stan's assignment ordering.

template<typename... Ts>
using return_type_t = typename return_type< Ts... >::type
Convenience type for the return type of the specified template parameters.

template<template< class... > class Check, typename... Ts>
using require_return_type_t = require_t< Check< return_type_t< Ts... > > >

template<template< class... > class Check, typename... Ts>
using require_not_return_type_t = require_not_t< Check< return_type_t< Ts... > > >

template<typename T >
using scalar_type_t = typename scalar_type< T >::type

template<typename T >
using value_type_t = typename value_type< T >::type
Helper function for accessing underlying type.

template<typename... Ts>
using void_t = typename make_void< Ts... >::type
Utility metafunction that maps a sequence of any types to the type void This metafunction is used in template metaprogramming to detect ill-formed types or the validity of an expression in an SFINAE context:

template<typename T >
using arena_t = typename internal::arena_type_impl< std::decay_t< T > >::type
Determines a type that can be used in place of T that does any dynamic allocations on the AD stack.

template<typename T_scalar , typename T_container >
using conditional_var_value_t = typename conditional_var_value< T_scalar, T_container >::type

template<typename ReturnType , typename... Types>
using promote_var_matrix_t = std::conditional_t< is_any_var_matrix< ReturnType, Types... >::value, stan::math::var_value< stan::math::promote_scalar_t< double, ReturnType > >, stan::math::promote_scalar_t< stan::math::var_value< double >, ReturnType > >
Given an Eigen type and several inputs, determine if a matrix should be var<Matrix> or Matrix<var>.

template<typename ReturnType , typename... Types>
using return_var_matrix_t = std::conditional_t< is_any_var_matrix< ReturnType, Types... >::value, stan::math::var_value< stan::math::promote_scalar_t< double, plain_type_t< ReturnType > > >, stan::math::promote_scalar_t< stan::math::var_value< double >, plain_type_t< ReturnType > > >
Given an Eigen type and several inputs, determine if a matrix should be var<Matrix> or Matrix<var>.

template<int Rows, int Cols, typename... Inputs>
using rev_matrix_t = typename rev_matrix_type< Rows, Cols, Inputs... >::type

## Functions

template<typename T , typename = require_stan_scalar_t<T>>
get (const T &x, size_t n)
Returns the provided element.

template<typename T >
get (const std::vector< T > &x, size_t n)
Returns the n-th element of the provided std::vector.

template<typename T , typename = require_eigen_t<T>>
scalar_type_t< T > get (const T &m, size_t n)
Returns the n-th element of the provided Eigen matrix.