Type Traits

Detailed Description

The type traits in Stan math are a mix of custom traits for detecting value and container types of Eigen matrices, standard vectors, standard complex numbers, and backports of C++17 traits.

Classes
class	stan::math::operands_and_partials< Op1, Op2, Op3, Op4, Op5, Op6, Op7, Op8, fvar< Dx > >
	This class builds partial derivatives with respect to a set of operands. More...
struct	stan::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...
class	stan::math::internal::ops_partials_edge< ViewElt, Op, Enable >
	An edge holds both the operands and its associated partial derivatives. More...
class	stan::math::operands_and_partials< Op1, Op2, Op3, Op4, Op5, Op6, Op7, Op8, T_return_type >
	This template builds partial derivatives with respect to a set of operands. More...
class	stan::math::internal::partials_propagator< ReturnType, require_arithmetic_t< ReturnType >, Ops... >
	This template builds partial derivatives with respect to a set of operands. More...
struct	stan::math::ad_promotable< From, To, typename >
	If the type From can be converted to To using implicit conversions, or both From and To are possibly cv-qualified void), provides the member constant value equal to true. More...
struct	stan::math::append_return_type< T1, T2 >
	This template metaprogram is used to compute the return type for append_array. More...
struct	stan::math::append_return_type< int, int >
	This template metaprogram is used to compute the return type for append_array. More...
struct	stan::math::append_return_type< Eigen::Matrix< T1, R, C >, Eigen::Matrix< T2, R, C > >
	This template metaprogram is used to compute the return type for append_array. More...
struct	stan::math::append_return_type< std::vector< T1 >, std::vector< T2 > >
	This template metaprogram is used to compute the return type for append_array. More...
struct	stan::base_type< T, typename >
	Metaprogram structure to determine the base base type of a template argument. More...
struct	stan::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	stan::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	stan::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	stan::math::conjunction< T >
	Extends std::true_type when instantiated with zero or more template parameters, all of which extend the std::true_type. More...
struct	stan::math::disjunction< Conds >
	Extends std::false_type when instantiated with zero or more template parameters, all of which extend the std::false_type. More...
struct	stan::math::include_summand< propto, T, T_pack >
	Template metaprogram to calculate whether a summand needs to be included in a proportional (log) probability calculation. More...
struct	stan::math::include_summand< propto, T >
	true if a term with the specified propto value and subterm types should be included in a proportionality calculation. More...
struct	stan::math::index_type< T, typename >
	Primary template class for the metaprogram to compute the index type of a container. More...
struct	stan::math::index_type< T, std::enable_if_t< std::is_pointer< T >::value > >
	Specialization of index_type for pointers. More...
struct	stan::math::index_type< T, require_std_vector_t< T > >
	Template metaprogram class to compute the type of index for a standard vector. More...
struct	stan::math::index_type< T, require_eigen_t< T > >
	Template metaprogram defining typedef for the type of index for an Eigen matrix, vector, or row vector. More...
struct	stan::is_arena_matrix< T, typename >
	Defines a static member named value which is defined to be true if the type is arena_matrix<T> More...
struct	stan::is_autodiff< T >
	Checks if decayed type is a var or fvar. More...
struct	stan::is_base_pointer_convertible< Base, Derived >
	Checks if a type's pointer is convertible to a templated base type's pointer. More...
struct	stan::internal::is_complex_impl< T >
	Provides a member constant value which is equal to true if T is an instance of std::complex and false otherwise. More...
struct	stan::is_complex< T, typename >
	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	stan::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	stan::is_vt_complex< T >
	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	stan::is_vt_not_complex< T >
	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	stan::is_constant< T, typename >
	Metaprogramming struct to detect whether a given type is constant in the mathematical sense (not the C++ const sense). More...
struct	stan::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	stan::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	stan::is_double_or_int< T >
	Checks if decayed type is a double or integer. More...
struct	stan::is_eigen< T >
	Check if type derives from EigenBase More...
struct	stan::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	stan::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	stan::is_eigen_array< T >
	Check if a type is derived from Eigen::ArrayBase More...
struct	stan::is_eigen_contiguous_map< T >
	Check if a type is an Eigen::Map with contiguous stride. More...
struct	stan::is_eigen_dense_base< T >
	Checks whether type T is derived from Eigen::DenseBase. More...
struct	stan::is_eigen_matrix_dynamic< T >
	Checks whether type T is derived from Eigen::MatrixBase and has columns and rows not equal to 1. More...
struct	stan::is_eigen_matrix_base< T >
	Checks whether type T is derived from Eigen::MatrixBase. More...
struct	stan::is_eigen_sparse_base< T >
	Checks whether type T is derived from Eigen::SparseMatrixBase. More...
struct	stan::is_fvar< T, typename >
	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	stan::is_matrix< T >
	Check if a type is derived from Eigen::EigenBase or is a var_value whose value_type is derived from Eigen::EigenBase More...
struct	stan::is_rev_matrix< T, typename >
	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	stan::is_rev_col_vector< T, typename >
	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	stan::is_rev_row_vector< T, typename >
	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	stan::is_rev_vector< T, typename >
	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	stan::is_stan_scalar< T >
	Checks if decayed type is a var, fvar, or arithmetic. More...
struct	stan::is_var< T, typename >
	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	stan::is_var_dense_dynamic< T >
	Check if a type is a var_value whose value_type is derived from Eigen::EigenBase and has dynamic rows and columns. More...
struct	stan::is_var_eigen< T >
	Check if a type is a var_value whose value_type is derived from Eigen::EigenBase More...
struct	stan::is_var_matrix< T >
	Check if a type is a var_value whose value_type is derived from Eigen::EigenBase More...
struct	stan::is_var_col_vector< T >
	Check if a type is a var_value whose value_type is derived from Eigen::EigenBase. More...
struct	stan::is_var_row_vector< T >
	Check if a type is a var_value whose value_type is derived from Eigen::EigenBase. More...
struct	stan::is_var_vector< T >
	Check if a type is a var_value whose value_type is derived from Eigen::EigenBase. More...
struct	stan::is_any_var_matrix< Types >
	Check if any types in a parameter pack are a var_value whose value_type is derived from Eigen::EigenBase More...
struct	stan::is_var_or_arithmetic_type< T >
	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	stan::is_vari< T, typename >
	Specialization for checking if value of T minus cv qualifier and pointer is a vari. More...
struct	stan::is_std_vector< T, typename >
	Base implementation for checking if type is std vector. More...
struct	stan::internal::is_eigen_col_vector_impl< T, bool >
	Underlying implementation for detecting if an Eigen Matrix is a column vector. More...
struct	stan::internal::is_eigen_col_vector_impl< T, false >
	Specialization for when type is not an eigen vector. More...
struct	stan::internal::is_eigen_row_vector_impl< T, bool >
	Underlying implementation for detecting if an Eigen Matrix is a row vector. More...
struct	stan::internal::is_eigen_row_vector_impl< T, false >
	Specialization for when type is not an eigen vector. More...
struct	stan::internal::is_col_vector_impl< T, bool >
	Underlying implementation for detecting if a Matrix is a column vector. More...
struct	stan::internal::is_col_vector_impl< T, false >
	Specialization for when type is not a vector. More...
struct	stan::internal::is_row_vector_impl< T, bool >
	Underlying implementation for detecting if a Matrix is a row vector. More...
struct	stan::internal::is_row_vector_impl< T, false >
	Specialization for when type is not an vector. More...
struct	stan::is_eigen_col_vector< T >
	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	stan::is_col_vector< T >
	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	stan::is_eigen_row_vector< T >
	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	stan::is_row_vector< T >
	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	stan::is_eigen_vector< T >
	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	stan::is_vector< T >
	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	stan::internal::is_std_vector_impl< T >
	This underlying implementation is used when the type is not an std vector. More...
struct	stan::internal::is_std_vector_impl< std::vector< Args... > >
	This specialization implementation has a static member named value when the template type is an std vector. More...
struct	stan::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	stan::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	stan::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	stan::is_vector_like< T >
	Template metaprogram indicates whether a type is vector_like. More...
struct	stan::partials_return_type< T, T_pack >
	Template metaprogram to calculate the partial derivative type resulting from promoting all the scalar types of the template parameters. More...
struct	stan::partials_type< T, typename >
	This base implementation will contain a static member function named type equal to the type passed into it. More...
struct	stan::real_return< Ts >
	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	stan::scalar_lub< T1, T2 >
	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	stan::return_type< Ts >
	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	stan::scalar_type< T, typename >
	Metaprogram structure to determine the base scalar type of a template argument. More...
class	stan::StdVectorBuilder< used, T1, T2, T3, T4, T5, T6, T7 >
	StdVectorBuilder allocates type T1 values to be used as intermediate values. More...
struct	stan::value_type< T, typename >
	Primary template class for metaprogram to compute the type of values stored in a container. More...
struct	stan::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	stan::VectorBuilder< used, T1, Args >
	VectorBuilder allocates type T1 values to be used as intermediate values. More...
class	stan::VectorBuilderHelper< T1, used, is_vec >
	VectorBuilder allocates type T1 values to be used as intermediate values. More...
class	stan::VectorBuilderHelper< T1, true, true >
	Template specialization for using a vector. More...
struct	stan::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	stan::math::internal::ops_partials_edge< double, var >
class	stan::math::operands_and_partials< Op1, Op2, Op3, Op4, Op5, Op6, Op7, Op8, var >
	This class builds partial derivatives with respect to a set of operands. More...
class	stan::math::internal::partials_propagator< ReturnType, require_var_t< ReturnType >, Ops... >
	This class builds partial derivatives with respect to a set of operands. More...
struct	stan::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	stan::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	stan::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	stan::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	stan::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	stan::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	stan::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	stan::partials_type< T, require_var_t< T > >
	Specialization of partials type returns double if input type is a double. More...

Typedefs
template<bool B>
using	stan::bool_constant = std::integral_constant< bool, B >
	Alias for structs used for wraps a static constant of bool.
template<typename... Ts>
using	stan::contains_std_vector = math::disjunction< is_std_vector< Ts >... >
	Checks if any types are std vectors.
template<typename... T>
using	stan::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 T >
using	stan::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	stan::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<typename T >
using	stan::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 S >
using	stan::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	stan::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	stan::is_string_convertible = std::is_convertible< T, std::string >
	Deduces whether type is convertible to string.
template<typename... Types>
using	stan::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... T>
using	stan::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	stan::partials_type_t = typename partials_type< T >::type
	Helper alias for accessing the partial type.
template<typename... Args>
using	stan::promote_args_t = typename boost::math::tools::promote_args< Args... >::type
	Convenience alias for boost tools promote_args.
template<typename... Ts>
using	stan::real_return_t = typename real_return< Ts... >::type
	Convenience type to calculate the real return type.
template<typename... Ts>
using	stan::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	stan::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	stan::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	stan::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	stan::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	stan::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	stan::return_type_t = typename return_type< Ts... >::type
	Convenience type for the return type of the specified template parameters.
template<typename T >
using	stan::value_type_t = typename value_type< T >::type
	Helper function for accessing underlying type.

Functions
T_return_type	stan::math::operands_and_partials< Op1, Op2, Op3, Op4, Op5, Op6, Op7, Op8, fvar< Dx > >::build (Dx value)
	Build the node to be stored on the autodiff graph.
T_return_type	stan::math::internal::partials_propagator< ReturnType, require_fvar_t< ReturnType >, Ops... >::build (Dx value)
	Build the node to be stored on the autodiff graph.
template<typename T , typename = require_stan_scalar_t<T>>
T	stan::get (const T &x, size_t n)
	Returns the provided element.
template<typename T >
T	stan::get (const std::vector< T > &x, size_t n)
	Returns the n-th element of the provided std::vector.
template<typename T , require_nonscalar_prim_or_rev_kernel_expression_t< T > * = nullptr>
size_t	stan::math::size (const T &m)
	Returns the size (number of the elements) of a matrix_cl or var_value<matrix_cl<T>>.
template<typename ScalarT , require_stan_scalar_t< ScalarT > * = nullptr>
size_t	stan::math::size_mvt (const ScalarT &)
	Provides the size of a multivariate argument.
template<typename Y >
void	stan::math::internal::broadcast_array< T >::operator= (const Y &m)
	Broadcast array can be assigned a scalar or a vector.
T &	stan::math::internal::empty_broadcast_array< T, S, Enable >::operator[] (int)
	Not implemented so cannot be called.
template<typename Y >
void	stan::math::internal::empty_broadcast_array< T, S, Enable >::operator= (const Y &)
	Not implemented so cannot be called.
ViewElt &	stan::math::internal::empty_broadcast_array< ViewElt, T, require_eigen_t< T > >::operator[] (int)
	Not implemented so cannot be called.
ViewElt &	stan::math::internal::empty_broadcast_array< ViewElt, T, require_eigen_t< T > >::operator() (int)
	Not implemented so cannot be called.
void	stan::math::internal::empty_broadcast_array< ViewElt, T, require_eigen_t< T > >::operator= (const T_arg &)
	Not implemented so cannot be called.
void	stan::math::internal::empty_broadcast_array< ViewElt, T, require_eigen_t< T > >::operator+= (T_arg)
	Not implemented so cannot be called.
void	stan::math::internal::empty_broadcast_array< ViewElt, T, require_eigen_t< T > >::operator-= (T_arg)
	Not implemented so cannot be called.
T &	stan::math::internal::empty_broadcast_array< ViewElt, T, require_eigen_t< T > >::row (int)
	Not implemented so cannot be called.
T &	stan::math::internal::empty_broadcast_array< ViewElt, T, require_eigen_t< T > >::col (int)
	Not implemented so cannot be called.
double	stan::math::operands_and_partials< Op1, Op2, Op3, Op4, Op5, Op6, Op7, Op8, T_return_type >::build (double value) const noexcept
	Build the node to be stored on the autodiff graph.
static double	stan::math::internal::partials_propagator< ReturnType, require_arithmetic_t< ReturnType >, Ops... >::build (double value) noexcept
	Build the node to be stored on the autodiff graph.
template<typename T_desired , typename T_actual , typename = std::enable_if_t<std::is_same<std::decay_t<T_actual>, std::decay_t<T_desired>>::value && !is_eigen<T_desired>::value>>
T_actual &&	stan::math::forward_as (T_actual &&a)
	Assume which type we get.
template<typename T_desired , typename T_actual , typename = std::enable_if_t< !std::is_same<std::decay<T_actual>, std::decay<T_desired>>::value && (!is_eigen<T_desired>::value || !is_eigen<T_actual>::value)>>
T_desired	stan::math::forward_as (const T_actual &a)
	Assume which type we get.
template<typename T_desired , typename T_actual , require_eigen_t< T_desired > * = nullptr, std::enable_if_t< std::is_same< value_type_t< T_actual >, value_type_t< T_desired > >::value &&is_eigen< T_desired >::value &&is_eigen< T_actual >::value &&internal::eigen_static_size_match(T_desired::RowsAtCompileTime, std::decay_t< T_actual >::RowsAtCompileTime) &&internal::eigen_static_size_match(T_desired::ColsAtCompileTime, std::decay_t< T_actual >::ColsAtCompileTime)> * = nullptr>
T_actual &&	stan::math::forward_as (T_actual &&a)
	Assume which type we get.
var	stan::math::operands_and_partials< Op1, Op2, Op3, Op4, Op5, Op6, Op7, Op8, var >::build (double value)
	Build the node to be stored on the autodiff graph.
var	stan::math::internal::partials_propagator< ReturnType, require_var_t< ReturnType >, Ops... >::build (double value)
	Build the node to be stored on the autodiff graph.