Class List

Here are the classes, structs, unions and interfaces with brief descriptions:

[detail level 12345]

►NEigen	(Expert) Numerical traits for algorithmic differentiation variables
►Ninternal	(Expert) Product traits for algorithmic differentiation variables
Cevaluator< stan::math::Holder< ArgType, Ptrs... > >
Cfunctor_has_linear_access< stan::math::read_fvar_functor< EigFvar, EigOut > >	Enable linear access of inputs when using read_fvar
Cfunctor_has_linear_access< stan::math::val_adj_functor< EigVar, EigDbl > >	Enable linear access of inputs when using read_val_adj
Cfunctor_has_linear_access< stan::math::vi_adj_functor< EigVar, EigVari > >	Enable linear access of inputs when using read_vi_adj
Cfunctor_has_linear_access< stan::math::vi_val_adj_functor< EigVar, EigVari, EigDbl > >	Enable linear access of inputs when using read_vi_val_adj
Cfunctor_has_linear_access< stan::math::vi_val_functor< EigVar, EigVari > >	Enable linear access of inputs when using read_vi_val
Cgeneral_matrix_matrix_product< Index, stan::math::var, LhsStorageOrder, ConjugateLhs, stan::math::var, RhsStorageOrder, ConjugateRhs, ColMajor, ResInnerStride >
Cgeneral_matrix_vector_product< Index, stan::math::var, LhsMapper, ColMajor, ConjugateLhs, stan::math::var, RhsMapper, ConjugateRhs, Version >	Specialization of matrix-vector products for reverse-mode autodiff variables
Cgeneral_matrix_vector_product< Index, stan::math::var, LhsMapper, RowMajor, ConjugateLhs, stan::math::var, RhsMapper, ConjugateRhs, Version >
Cremove_all< stan::math::vari * >	Partial specialization of Eigen's remove_all struct to stop Eigen removing pointer from vari* variables
Ctraits< stan::math::arena_matrix< T > >
Ctraits< stan::math::Holder< ArgType, Ptrs... > >
Ctraits< stan::math::pinned_matrix< T > >
CNumTraits< stan::math::fvar< T > >	Numerical traits template override for Eigen for automatic gradient variables
CNumTraits< stan::math::var >	Numerical traits template override for Eigen for automatic gradient variables
CScalarBinaryOpTraits< double, int, BinaryOp >	Traits specialization for Eigen binary operations for double and int arguments
CScalarBinaryOpTraits< double, stan::math::fvar< T >, BinaryOp >	Traits specialization for Eigen binary operations for double and autodiff arguments
CScalarBinaryOpTraits< double, stan::math::var, BinaryOp >	Traits specialization for Eigen binary operations for double and reverse-mode autodiff arguments
CScalarBinaryOpTraits< double, std::complex< stan::math::fvar< T > >, BinaryOp >	Traits specialization for Eigen binary operations for double and complex autodiff arguments
CScalarBinaryOpTraits< double, std::complex< stan::math::var >, BinaryOp >	Traits specialization for Eigen binary operations for double and complex autodiff arguments
CScalarBinaryOpTraits< int, double, BinaryOp >	Traits specialization for Eigen binary operations for int and double arguments
CScalarBinaryOpTraits< int, stan::math::fvar< T >, BinaryOp >	Traits specialization for Eigen binary operations for int and autodiff arguments
CScalarBinaryOpTraits< int, stan::math::var, BinaryOp >	Traits specialization for Eigen binary operations for int and reverse-mode autodiff arguments
CScalarBinaryOpTraits< int, std::complex< double >, BinaryOp >	Traits specialization for Eigen binary operations for int and complex double arguments
CScalarBinaryOpTraits< int, std::complex< stan::math::fvar< T > >, BinaryOp >	Traits specialization for Eigen binary operations for int and complex autodiff arguments
CScalarBinaryOpTraits< int, std::complex< stan::math::var >, BinaryOp >	Traits specialization for Eigen binary operations for int and complex autodiff arguments
CScalarBinaryOpTraits< stan::math::fvar< T >, double, BinaryOp >	Traits specialization for Eigen binary operations for autodiff and double arguments
CScalarBinaryOpTraits< stan::math::fvar< T >, int, BinaryOp >	Traits specialization for Eigen binary operations for autodiff and int arguments
CScalarBinaryOpTraits< stan::math::fvar< T >, std::complex< double >, BinaryOp >	Traits specialization for Eigen binary operations for autodiff and complex double arguments
CScalarBinaryOpTraits< stan::math::var, double, BinaryOp >	Traits specialization for Eigen binary operations for reverse-mode autodiff and double arguments
CScalarBinaryOpTraits< stan::math::var, int, BinaryOp >	Traits specialization for Eigen binary operations for reverse-mode autodiff and int arguments
CScalarBinaryOpTraits< stan::math::var, stan::math::var, BinaryOp >	Traits specialization for Eigen binary operations for reverse-mode autodiff arguments
CScalarBinaryOpTraits< stan::math::var, std::complex< double >, BinaryOp >	Traits specialization for Eigen binary operations for autodiff and complex double arguments
CScalarBinaryOpTraits< stan::math::var, std::complex< stan::math::var >, BinaryOp >
CScalarBinaryOpTraits< std::complex< double >, int, BinaryOp >	Traits specialization for Eigen binary operations for complex double and int arguments
CScalarBinaryOpTraits< std::complex< double >, stan::math::fvar< T >, BinaryOp >	Traits specialization for Eigen binary operations for complex double and autodiff arguments
CScalarBinaryOpTraits< std::complex< double >, stan::math::var, BinaryOp >	Traits specialization for Eigen binary operations for complex double and autodiff arguments
CScalarBinaryOpTraits< std::complex< double >, std::complex< stan::math::fvar< T > >, BinaryOp >	Traits specialization for Eigen binary operations for complex double and complex autodiff arguments
CScalarBinaryOpTraits< std::complex< double >, std::complex< stan::math::var >, BinaryOp >	Traits specialization for Eigen binary operations for complex double and complex autodiff arguments
CScalarBinaryOpTraits< std::complex< stan::math::fvar< T > >, double, BinaryOp >	Traits specialization for Eigen binary operations for complex autodiff and double arguments
CScalarBinaryOpTraits< std::complex< stan::math::fvar< T > >, int, BinaryOp >	Traits specialization for Eigen binary operations for complex autodiff and int arguments
CScalarBinaryOpTraits< std::complex< stan::math::fvar< T > >, std::complex< double >, BinaryOp >	Traits specialization for Eigen binary operations for complex autodiff and complex double arguments
CScalarBinaryOpTraits< std::complex< stan::math::var >, double, BinaryOp >	Traits specialization for Eigen binary operations for complex autodiff and double arguments
CScalarBinaryOpTraits< std::complex< stan::math::var >, int, BinaryOp >	Traits specialization for Eigen binary operations for complex autodiff and int arguments
CScalarBinaryOpTraits< std::complex< stan::math::var >, stan::math::var, BinaryOp >
CScalarBinaryOpTraits< std::complex< stan::math::var >, std::complex< double >, BinaryOp >	Traits specialization for Eigen binary operations for complex autodiff and complex double arguments
CScalarBinaryOpTraits< std::complex< stan::math::var >, std::complex< stan::math::var >, BinaryOp >
►Nstan	The lgamma implementation in stan-math is based on either the reentrant safe lgamma_r implementation from C or the boost::math::lgamma implementation
►Ninternal
Carena_type_impl
Carena_type_impl< stan::math::matrix_cl< T > >
Carena_type_impl< std::vector< T, Alloc > >
Carena_type_impl< T, require_all_t< is_kernel_expression_and_not_scalar< T >, bool_constant<!is_matrix_cl< T >::value >, bool_constant<!is_arena_matrix_cl< T >::value > > >
Carena_type_impl< T, require_all_t< std::is_trivially_destructible< T >, bool_constant<!is_eigen< T >::value > > >
Carena_type_impl< T, require_eigen_t< T >, std::enable_if_t< T::RowsAtCompileTime !=Eigen::Dynamic &&T::ColsAtCompileTime !=Eigen::Dynamic > >
Carena_type_impl< T, require_eigen_t< T >, std::enable_if_t< T::RowsAtCompileTime==Eigen::Dynamic||T::ColsAtCompileTime==Eigen::Dynamic > >
Carena_type_impl< T, require_t< std::is_base_of< stan::math::chainable_alloc, T > > >
Chas_eval
Chas_eval< T, void_t< decltype(std::declval< std::decay_t< T > & >().eval())> >
Chas_internal_trait
Chas_internal_trait< T, std::void_t< Eigen::internal::traits< std::decay_t< T > > > >
Chas_plain_object
Chas_plain_object< T, void_t< typename std::decay_t< T >::PlainObject > >
Chas_scalar_trait
Chas_scalar_trait< T, std::void_t< typename std::decay_t< T >::Scalar > >
Cis_arena_matrix_cl_impl
Cis_arena_matrix_cl_impl< math::arena_matrix_cl< T > >
Cis_arena_matrix_impl
Cis_arena_matrix_impl< math::arena_matrix< T > >
Cis_col_vector_impl	Underlying implementation for detecting if a Matrix is a column vector
Cis_col_vector_impl< T, false >	Specialization for when type is not a vector
Cis_complex_impl	Provides a member constant value which is equal to true if T is an instance of std::complex and false otherwise
Cis_complex_impl< std::complex< Ts... > >
Cis_dense_dynamic_impl
Cis_dense_dynamic_impl< T, require_t< is_eigen_dense_dynamic< std::decay_t< T > > > >
Cis_dense_dynamic_impl< T, require_t< is_var< T > > >
Cis_eigen_col_vector_impl	Underlying implementation for detecting if an Eigen Matrix is a column vector
Cis_eigen_col_vector_impl< T, false >	Specialization for when type is not an eigen vector
Cis_eigen_contiguous_map_impl
Cis_eigen_contiguous_map_impl< Eigen::Map< T, Opts, Eigen::Stride< 0, 0 > > >
Cis_eigen_matrix_dynamic_impl	Underlying implimenation to check if an Eigen matrix has rows or cols not equal to 1
Cis_eigen_matrix_dynamic_impl< T, false >
Cis_eigen_matrix_dynamic_impl< T, true >
Cis_eigen_row_vector_impl	Underlying implementation for detecting if an Eigen Matrix is a row vector
Cis_eigen_row_vector_impl< T, false >	Specialization for when type is not an eigen vector
Cis_fvar_impl
Cis_fvar_impl< math::fvar< T > >
Cis_row_vector_impl	Underlying implementation for detecting if a Matrix is a row vector
Cis_row_vector_impl< T, false >	Specialization for when type is not an vector
Cis_std_vector_impl	This underlying implementation is used when the type is not an std vector
Cis_std_vector_impl< std::vector< Args... > >	This specialization implementation has a static member named value when the template type is an std vector
Cis_trivial_kg_expression
Cis_trivial_kg_expression< double >
Cis_trivial_kg_expression< int >
Cis_trivial_kg_expression< math::as_column_vector_or_scalar_< T > >
Cis_trivial_kg_expression< math::block_< T > >
Cis_trivial_kg_expression< math::broadcast_< T, Colwise, Rowwise > >
Cis_trivial_kg_expression< math::calc_if_< false, T > >
Cis_trivial_kg_expression< math::calc_if_< true, T > >
Cis_trivial_kg_expression< math::col_index >
Cis_trivial_kg_expression< math::constant_< T > >
Cis_trivial_kg_expression< math::holder_cl_< T > >
Cis_trivial_kg_expression< math::load_< T > >
Cis_trivial_kg_expression< math::matrix_cl< T > >
Cis_trivial_kg_expression< math::optional_broadcast_< T, Colwise, Rowwise > >
Cis_trivial_kg_expression< math::row_index >
Cis_trivial_kg_expression< math::scalar_< T > >
Cis_var_impl
Cis_var_impl< math::var_value< T > >
Cis_vari_impl
Cis_vari_impl< math::vari_value< T > >
Cis_vari_impl< math::vari_view< T > >
Creturn_type_impl
Creturn_type_impl< std::tuple< T... >, Ts... >
Creturn_type_impl< T, Ts... >
►Nmath	Matrices and templated mathematical functions
►Ninternal	A comparator that works for any container type that has the brackets operator
Carena_matrix_cl_impl
Cassignment_op_str
Cassignment_op_str< T, void_t< decltype(T::assignment_op)> >
Cassignment_op_str_impl
Cassignment_op_str_impl< assign_op_cl::divide_equals >
Cassignment_op_str_impl< assign_op_cl::equals >
Cassignment_op_str_impl< assign_op_cl::minus_equals >
Cassignment_op_str_impl< assign_op_cl::multiply_equals >
Cassignment_op_str_impl< assign_op_cl::plus_equals >
Cbounded
Cbounded< T_y, T_low, T_high, true >
CBox	Compute the integral of the function to be integrated (integrand) from a to b for more than one dimensions
Cbroadcast_array
Ccallback_vari
Cchange_eigen_options_impl	Change the options of an Eigen matrix or array
Cchange_eigen_options_impl< Mat, NewOptions, require_eigen_array_t< Mat > >
Cchange_eigen_options_impl< Mat, NewOptions, require_eigen_matrix_base_t< Mat > >
Cchange_eigen_options_impl< var_value< Mat >, NewOptions, require_eigen_array_t< Mat > >
Cchange_eigen_options_impl< var_value< Mat >, NewOptions, require_eigen_matrix_base_t< Mat > >
Ccolwise_reduction_base
Ccsr_adjoint	vari for csr_matrix_times_vector
Cdouble_d
Cempty_broadcast_array
Cempty_broadcast_array< ViewElt, T, require_eigen_t< T > >
Cequal_profile_key
Cfdim_dv_vari
Cfdim_vd_vari
Cfdim_vv_vari
Cfmod_dv_vari
Cfmod_vd_vari
Cfmod_vv_vari
Cgamma_p_dv_vari
Cgamma_p_vd_vari
Cgamma_p_vv_vari
Cgamma_q_dv_vari
Cgamma_q_vd_vari
Cgamma_q_vv_vari
Chash_profile_key
Cinc_beta_vvv_vari
Cindex_comparator
Cintegrate_ode_std_vector_interface_adapter	Wrap a functor designed for use with integrate_ode_bdf, integrate_ode_rk45, and integrate_ode_adams to use with the new ode_bdf/ode_rk45 interfaces
Cis_colwise_reduction_impl
Cis_colwise_reduction_impl< calc_if_< true, T > >
Cis_reduction_2d_impl
Cis_reduction_2d_impl< calc_if_< true, T > >
Cis_scalar_check_impl
Cis_scalar_check_impl< check_cl_< scalar_< T > > >
Cis_tuple_impl
Cis_tuple_impl< std::tuple< Types... > >
Cis_without_output_impl
Cis_without_output_impl< calc_if_< false, T > >
CIser	Apply an error check to a container, signal failure with false
Clambert_w0_fun	Structure to wrap lambert_w0() so it can be vectorized
Clambert_wm1_fun	Structure to wrap lambert_wm1() so it can be vectorized
Clbeta_dv_vari
Clbeta_vd_vari
Clbeta_vv_vari
Clmgamma_dv_vari
Clmultiply_dv_vari
Clmultiply_vd_vari
Clmultiply_vv_vari
Clog_diff_exp_dv_vari
Clog_diff_exp_vd_vari
Clog_diff_exp_vv_vari
Clog_falling_factorial_dv_vari
Clog_falling_factorial_vd_vari
Clog_falling_factorial_vv_vari
Clog_inv_logit_diff_dv_vari
Clog_inv_logit_diff_vd_vari
Clog_inv_logit_diff_vv_vari
Clog_rising_factorial_dv_vari
Clog_rising_factorial_vd_vari
Clog_rising_factorial_vv_vari
Clog_softmax_elt_vari
Clog_sum_exp_vd_vari
Clog_sum_exp_vv_vari
Cmap_rect_combine
Cmap_rect_reduce
Cmap_rect_reduce< F, double, double >
Cmap_rect_reduce< F, double, var >
Cmap_rect_reduce< F, var, double >
Cmap_rect_reduce< F, var, var >
Cmatvec_mul_opt	Implementation of an optimization for usage of rowwise reduction in matrix-vector multiplication
Cmatvec_mul_opt< elt_multiply_< Mat, broadcast_< VecT, true, false > > >
Cmdivide_left_spd_alloc
Cmdivide_left_spd_dv_vari
Cmdivide_left_spd_vd_vari
Cmdivide_left_spd_vv_vari
Cmdivide_left_tri_dv_vari
Cmdivide_left_tri_vd_vari
Cmdivide_left_tri_vv_vari
Cmodified_bessel_first_kind_dv_vari
Cmodified_bessel_second_kind_dv_vari
Cmpi_parallel_call_cache	Container for locally cached data which is essentially implemented as singleton
Cmrrr_task
►Cmulti_result_kernel_internal
Cinner
►Cmulti_result_kernel_internal<-1, T_results... >
Cinner
Cmultiply_log_dv_vari
Cmultiply_log_vd_vari
Cmultiply_log_vv_vari
Cmultiply_vd_vari
Cmultiply_vv_vari
Cnonexisting_adjoint
Copencl_code_impl
Cops_partials_edge	An edge holds both the operands and its associated partial derivatives
Cops_partials_edge< double, Op, require_eigen_st< is_var, Op > >
Cops_partials_edge< double, std::vector< Eigen::Matrix< var, R, C > > >
Cops_partials_edge< double, std::vector< std::vector< var > > >
Cops_partials_edge< double, std::vector< var > >
Cops_partials_edge< double, std::vector< var_value< Op > >, require_eigen_t< Op > >
Cops_partials_edge< double, var >
Cops_partials_edge< double, var_value< Op >, require_eigen_t< Op > >
Cops_partials_edge< double, var_value< Op >, require_kernel_expression_lhs_t< Op > >
Cops_partials_edge< Dx, std::vector< Eigen::Matrix< fvar< Dx >, R, C > > >
Cops_partials_edge< Dx, std::vector< std::vector< fvar< Dx > > > >
Cops_partials_edge< Dx, ViewElt, require_eigen_vt< is_fvar, ViewElt > >
Cops_partials_edge< InnerType, T, require_fvar_t< T > >
Cops_partials_edge< InnerType, T, require_std_vector_vt< is_fvar, T > >
Cops_partials_edge< ViewElt, Op, require_st_arithmetic< Op > >	Class representing an edge with an inner type of double
Cpartials_propagator
Cpartials_propagator< ReturnType, require_arithmetic_t< ReturnType >, Ops... >	This template builds partial derivatives with respect to a set of operands
Cpartials_propagator< ReturnType, require_fvar_t< ReturnType >, Ops... >	This class builds partial derivatives with respect to a set of operands
Cpartials_propagator< ReturnType, require_var_t< ReturnType >, Ops... >	This class builds partial derivatives with respect to a set of operands
Cquad_form_vari
Cquad_form_vari_alloc
Creduce_sum_impl	Reduce_sum_impl implementation for any autodiff type
►Creduce_sum_impl< ReduceFunction, require_arithmetic_t< ReturnType >, ReturnType, Vec, Args... >	Specialization of reduce_sum_impl for arithmetic types
Crecursive_reducer	This struct is used by the TBB to accumulate partial sums over consecutive ranges of the input
►Creduce_sum_impl< ReduceFunction, require_var_t< ReturnType >, ReturnType, Vec, Args... >	Var specialization of reduce_sum_impl
Crecursive_reducer	This struct is used by the TBB to accumulate partial sums over consecutive ranges of the input
Cscoped_args_tuple
Creduction_2d_base
Creverse_pass_callback_vari
Crising_factorial_vd_vari
Csquared_distance_vd_vari
Csquared_distance_vv_vari
Ctrace_gen_quad_form_vari
Ctrace_gen_quad_form_vari_alloc
Ctrace_quad_form_vari
Ctrace_quad_form_vari_alloc
►Nopencl_kernels
►Ninternal
Cto_buffer	Kernel_executor_opencl
Cto_buffer< in_buffer >
Cto_buffer< in_out_buffer >
Cto_buffer< out_buffer >
Ccumulative_sum	Struct containing cumulative_sum kernels, grouped by scalar type
Ccumulative_sum< double, T >
Ccumulative_sum< int, T >
Cin_buffer	An in_buffer signifies a cl::Buffer argument used as input
Cin_out_buffer	An in_out_buffer signifies a cl::Buffer argument used as both input and output
Ckernel_cl	Creates functor for kernels
Cout_buffer	An out_buffer signifies a cl::Buffer argument used as output
Csort_asc	Struct containing sort_asc kernels, grouped by scalar type
Csort_asc< double, T >
Csort_asc< int, T >
Csort_desc	Struct containing sort_desc kernels, grouped by scalar type
Csort_desc< double, T >
Csort_desc< int, T >
Cabs_fun	Return elementwise absolute value of the specified real-valued container
Caccumulator	Class to accumulate values and eventually return their sum
Caccumulator< T, require_fvar_t< T > >	Class to accumulate values and eventually return their sum
Caccumulator< T, require_var_t< T > >	Class to accumulate values and eventually return their sum
Cacos_
Cacos_fun	Structure to wrap acos() so it can be vectorized
Cacosh_
Cacosh_fun	Structure to wrap acosh() so it can be vectorized
Cad_promotable	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
Cad_tape_observer	TBB observer object which is a callback hook called whenever the TBB scheduler adds a new thread to the TBB managed threadpool
Caddition_
Caddition_operator_
Cadjoint_results_cl	Represents results that are adjoints of vars in kernel generrator expressions
Cappend_col_	Represents appending of cols in kernel generator expressions
Cappend_return_type	This template metaprogram is used to compute the return type for append_array
Cappend_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
Cappend_return_type< int, int >	This template metaprogram is used to compute the return type for append_array
Cappend_return_type< std::vector< T1 >, std::vector< T2 > >	This template metaprogram is used to compute the return type for append_array
Cappend_row_	Represents appending of rows in kernel generator expressions
Capply_scalar_unary	Base template class for vectorization of unary scalar functions defined by a template class F to a scalar, standard library vector, or Eigen dense matrix expression template
Capply_scalar_unary< F, fvar< T > >	Template specialization to fvar for vectorizing a unary scalar function
Capply_scalar_unary< F, T, require_complex_t< T > >	Template specialization for vectorized functions applying to complex arguments
Capply_scalar_unary< F, T, require_eigen_t< T > >	Template specialization for vectorized functions applying to Eigen matrix arguments
Capply_scalar_unary< F, T, require_floating_point_t< T > >	Template specialization for vectorized functions applying to double arguments
Capply_scalar_unary< F, T, require_integral_t< T > >	Template specialization for vectorized functions applying to integer arguments
Capply_scalar_unary< F, T, require_std_vector_t< T > >	Template specialization for vectorized functions applying to standard vector containers
Capply_scalar_unary< F, T, require_var_matrix_t< T > >
Capply_scalar_unary< F, var >	Template specialization to var for vectorizing a unary scalar function
Capply_vector_unary
Capply_vector_unary< T, require_eigen_t< T > >	Base template class for vectorization of unary vector functions defined by applying a functor to a standard library vector, Eigen dense matrix expression template, or container of these
Capply_vector_unary< T, require_std_vector_vt< is_container_or_var_matrix, T > >	Specialization for use with nested containers (std::vectors)
Capply_vector_unary< T, require_std_vector_vt< is_stan_scalar, T > >	Specialization for use with (non-nested) std::vectors
Capply_vector_unary< T, require_var_matrix_t< T > >	Specialization for use with var_value<T> types where T inherits from EigenBase
Carena_allocator	Std library compatible allocator that uses AD stack
Carena_matrix	Equivalent to Eigen::Matrix, except that the data is stored on AD stack
Carena_matrix< MatrixType, require_eigen_dense_base_t< MatrixType > >
Carena_matrix< MatrixType, require_eigen_sparse_base_t< MatrixType > >
Carena_matrix_cl	A variant of matrix_cl that schedules its destructor to be called, so it can be used on the AD stack
Carray_builder	Structure for building up arrays in an expression (rather than in statements) using an argument-chaining add() method and a getter method array() to return the result
Cas_column_vector_or_scalar_	Represents as_column_vector_or_scalar of a row or column vector in kernel generator expressions
Casin_
Casin_fun	Structure to wrap asin() so it can be vectorized
Casinh_
Casinh_fun	Structure to wrap asinh() so it can be vectorized
Catan_
Catan_fun	Structure to wrap atan() so it can be vectorized
Catanh_
Catanh_fun	Structure to wrap atanh() so it can be vectorized
►CAutodiffStackSingleton	This struct always provides access to the autodiff stack using the singleton pattern
CAutodiffStackStorage
Cbeta_
Cbinary_operation	Represents a binary operation in kernel generator expressions
Cbinomial_coefficient_log_
Cblock_	Represents submatrix block in kernel generator expressions
Cbroadcast_	Represents a broadcasting operation in kernel generator expressions
Ccalc_if_	Represents a calc_if in kernel generator expressions
Ccast_	Represents a typecast os scalar in kernel generator expressions
Ccbrt_
Ccbrt_fun	Structure to wrap cbrt() so it can be vectorized
Cceil_
Cceil_fun	Structure to wrap ceil() so it can be vectorized
Cchainable_alloc	A chainable_alloc is an object which is constructed and destructed normally but the memory lifespan is managed along with the arena allocator for the gradient calculation
Cchainable_object	chainable_object hold another object is useful for connecting the lifetime of a specific object to the chainable stack
Ccheck_cl_	Represents a check in kernel generator expressions
Ccol_index	Represents operation that determines column index
Ccolwise_max_	Represents column wise max - reduction in kernel generator expressions
Ccolwise_min_	Represents column wise min - reduction in kernel generator expressions
Ccolwise_prod_	Represents column wise product - reduction in kernel generator expressions
Ccolwise_reduction	Represents a column wise reduction in kernel generator expressions
Ccolwise_sum_	Represents column wise sum - reduction in kernel generator expressions
Ccomplex_base	Base class for complex numbers
Cconjunction	Extends std::true_type when instantiated with zero or more template parameters, all of which extend the std::true_type
Cconjunction< T, Ts... >
Cconstant_	Represents a matrix of single repeated value in kernel generator expressions
Ccopysign_
Ccos_
Ccos_fun	Structure to wrap cos() so it can be vectorized
Ccosh_
Ccosh_fun	Structure to wrap cosh() so it can be vectorized
Ccoupled_ode_system
Ccoupled_ode_system_impl
Ccoupled_ode_system_impl< false, F, T_y0, Args... >	The coupled_ode_system_impl template specialization when the state or parameters are autodiff types
Ccoupled_ode_system_impl< true, F, T_y0, Args... >	The coupled_ode_system_impl for arithmetic arguments reduces to the regular ode system (there are no sensitivities)
Ccov_exp_quad_vari
Ccov_exp_quad_vari< T_x, double, T_l >
Ccvodes_integrator	Integrator interface for CVODES' ODE solvers (Adams & BDF methods)
►Ccvodes_integrator_adjoint_vari	Integrator interface for CVODES' adjoint ODE solvers (Adams & BDF methods)
Ccvodes_solver	Since the CVODES solver manages memory with malloc calls, these resources must be freed using a destructor call (which is not being called for the vari class)
Cdae_system	IDAS DAE system that contains information on residual equation functor, sensitivity residual equation functor, as well as initial conditions
Cdeserializer	A class to store a sequence of values which can be deserialized back into structured objects such as scalars, vectors, and matrices
Cdiagonal_	Represents diagonal of a matrix (as column vector) in kernel generator expressions
Cdigamma_
Cdigamma_fun	Structure to wrap digamma() so it can be vectorized
Cdisjunction	Extends std::false_type when instantiated with zero or more template parameters, all of which extend the std::false_type
Cdisjunction< Cond, Conds... >
Celt_divide_
Celt_function_cl	Represents an element-wise function in kernel generator expressions
Celt_modulo_
Celt_multiply_
Cequals_
Cerf_
Cerf_fun	Structure to wrap erf() so it can be vectorized
Cerfc_
Cerfc_fun	Structure to wrap the erfc() so that it can be vectorized
Cexp2_
Cexp2_fun	Structure to wrap exp2() so it can be vectorized
Cexp_
Cexp_fun	Structure to wrap exp() so that it can be vectorized
Cexpm1_
Cexpm1_fun	Structure to wrap expm1() so that it can be vectorized
Cexpressions_cl	Represents multiple expressions that will be calculated in same kernel
Cfabs_
Cfabs_fun	Structure to wrap fabs() so that it can be vectorized
Cfdim_
CFixedPointADJac	Calculate Jacobian Jxy(Jacobian of unknown x w.r.t
CFixedPointSolver	Fixed point solver for problem of form
CFixedPointSolver< KinsolFixedPointEnv< F >, fp_jac_type >	Specialization for fixed point solver when using KINSOL
Cfloor_
Cfloor_fun	Structure to wrap floor() so that it can be vectorized
Cfmax_
Cfmin_
Cfmod_
Cfvar	This template class represents scalars used in forward-mode automatic differentiation, which consist of values and directional derivatives of the specified template type
Cgevv_vvv_vari
Cgreater_than_
Cgreater_than_or_equal_
CHolder	A no-op Eigen operation
Cholder_cl_	Represents a no-op in kernel generator expressions
Chybrj_functor_solver	A functor with the required operators to call Eigen's algebraic solver
Chypot_
Cidas_integrator	IDAS DAE integrator
Cidas_service	For each type of Ode(with different rhs functor F and senstivity parameters), we allocate mem and workspace for idas
Cinclude_summand	Template metaprogram to calculate whether a summand needs to be included in a proportional (log) probability calculation
Cinclude_summand< propto, T >	true if a term with the specified propto value and subterm types should be included in a proportionality calculation
Cindex_type	Primary template class for the metaprogram to compute the index type of a container
Cindex_type< T, require_eigen_t< T > >	Template metaprogram defining typedef for the type of index for an Eigen matrix, vector, or row vector
Cindex_type< T, require_std_vector_t< T > >	Template metaprogram class to compute the type of index for a standard vector
Cindex_type< T, std::enable_if_t< std::is_pointer< T >::value > >	Specialization of index_type for pointers
Cindexing_	Represents indexing of a matrix with two matrices of indices
Cinv_cloglog_fun	Structure to wrap inv_cloglog() so that it can be vectorized
Cinv_erfc_fun	Structure to wrap the inv_erfc() function so that it can be vectorized
Cinv_fun	Structure to wrap 1.0 / x so that it can be vectorized
Cinv_logit_
Cinv_logit_fun	Structure to wrap inv_logit() so that it can be vectorized
Cinv_Phi_
Cinv_Phi_fun	Structure to wrap inv_Phi() so it can be vectorized
Cinv_sqrt_fun	Structure to wrap 1 / sqrt(x) so that it can be vectorized
Cinv_square_
Cis_tuple
Cisfinite_
Cisinf_
Cisnan_
Ckernel_parts	Parts of an OpenCL kernel, generated by an expression
Ckinsol_system_data	KINSOL algebraic system data holder
CKinsolFixedPointEnv	KINSOL algebraic system data holder that handles construction & destruction of SUNDIALS data, as well as auxiliary data that will be used for functor evaluation
Clbeta_
Cldexp_
CLDLT_factor	LDLT_factor is a structure that holds a matrix of type T and the LDLT of its values
CLDLT_factor< T, require_eigen_matrix_dynamic_vt< is_var, T > >	An LDLT_factor of an Eigen::Matrix<var, Eigen::Dynamic, Eigen::Dynamic> with alloc_in_arena = True holds a copy of the input matrix and the LDLT of its values, with all member variable allocations are done in the arena
CLDLT_factor< T, require_var_matrix_t< T > >	An LDLT_factor of a var_value<Eigen::MatrixXd> holds a copy of the input var_value and the LDLT of its values
CLDLT_factor< T, std::enable_if_t< bool_constant< is_eigen_matrix_dynamic< T >::value &&!is_var< scalar_type_t< T > >::value >::value > >	An LDLT_factor is a structure that holds a matrix of type T and the LDLT of its values
Cless_than_
Cless_than_or_equal_
Clgamma_
Clgamma_fun	Structure to wrap lgamma() so that it can be vectorized
Clmultiply_
Cload_	Represents an access to a matrix_cl in kernel generator expressions
Clog10_
Clog10_fun	Structure to wrap log10() so it can be vectorized
Clog1m_
Clog1m_exp_
Clog1m_exp_fun	Structure to wrap log1m_exp() so it can be vectorized
Clog1m_fun	Structure to wrap log1m() so it can be vectorized
Clog1m_inv_logit_
Clog1m_inv_logit_fun	Structure to wrap log1m_inv_logit() so it can be vectorized
Clog1p_
Clog1p_exp_
Clog1p_exp_fun	Structure to wrap log1p_exp() so that it can be vectorized
Clog1p_fun	Structure to wrap log1p() so it can be vectorized
Clog2_
Clog2_fun	Structure to wrap log2() so it can be vectorized
Clog_
Clog_diff_exp_
Clog_fun	Structure to wrap log() so that it can be vectorized
Clog_inv_logit_
Clog_inv_logit_diff_
Clog_inv_logit_fun	Structure to wrap log_inv_logit() so it can be vectorized
Clogical_and_
Clogical_negation_	Represents a logical negation in kernel generator expressions
Clogical_or_
Clogit_
Clogit_fun	Structure to wrap logit() so it can be vectorized
Cmatrix_cl	Represents an arithmetic matrix on the OpenCL device
Cmatrix_cl_base	Non-templated base class for matrix_cl simplifies checking if something is matrix_cl
Cmatrix_exp_action_handler	The implementation of the work by Awad H
Cmax_2d_	Represents two dimensional max - reduction in kernel generator expressions
Cmax_op	Operation for max reduction
Cmin_2d_	Represents two dimensional min - reduction in kernel generator expressions
Cmin_op	Operation for min reduction
Cmpi_cluster	MPI cluster holds MPI resources and must be initialized only once in any MPI program
Cmpi_command	A MPI command object is used to execute code on worker nodes
Cmpi_distributed_apply	MPI command template which calls the static method distributed_apply of the given class F
Cmpi_is_in_use	Exception thrown whenever the MPI resource is busy
Cmpi_parallel_call	The MPI parallel call class manages the distributed evaluation of a collection of tasks following the map - reduce - combine pattern
Cmpi_stop_listen	Exception used to stop workers nodes from further listening to commands send from the root
Cmpi_stop_worker	MPI command used to stop childs nodes from listening for further commands
Cmultiply_log_
Cname_generator	Unique name generator for variables used in generated kernels
Cnested_rev_autodiff	A class following the RAII idiom to start and recover nested autodiff scopes
Cnlo_functor	A structure which gets passed to Eigen's dogleg algebraic solver
Cnot_equals_
Cop_ddv_vari
Cop_dv_vari
Cop_dvd_vari
Cop_dvv_vari
Cop_matrix_vari
Cop_v_vari
Cop_vd_vari
Cop_vdd_vari
Cop_vdv_vari
Cop_vector_vari
Cop_vv_vari
Cop_vvd_vari
Cop_vvv_vari
Copencl_code_	Represents custom code in kernel generator expressions
Copencl_code_output	Represents output variable of custom code in kernel generator expressions
Copencl_context	The API to access the methods and values in opencl_context_base
►Copencl_context_base	The opencl_context_base class represents an OpenCL context in the standard Meyers singleton design pattern
Ctuning_struct
Coperands_and_partials	This template builds partial derivatives with respect to a set of operands
Coperands_and_partials< Op1, Op2, Op3, Op4, Op5, Op6, Op7, Op8, fvar< Dx > >	This class builds partial derivatives with respect to a set of operands
Coperands_and_partials< Op1, Op2, Op3, Op4, Op5, Op6, Op7, Op8, var >	This class builds partial derivatives with respect to a set of operands
Coperation_cl	Base for all kernel generator operations
Coperation_cl_lhs	Base for all kernel generator operations that can be used on left hand side of an expression
Coptional_broadcast_	Represents an optional broadcasting operation in kernel generator expressions
Cpass_type
Cpass_type< double >
Cpass_type< int >
CPhi_
CPhi_approx_
CPhi_approx_fun	Structure to wrap Phi_approx() so it can be vectorized
CPhi_fun	Structure to wrap Phi() so it can be vectorized
Cpinned_matrix	Equivalent to Eigen::Matrix, except that the data is stored in (hopefully pinned) memory, allocated by OpenCL driver
Cpow_
Cprecomp_vv_vari
Cprecomp_vvv_vari
Cprecomputed_gradients_vari_template	A variable implementation taking a sequence of operands and partial derivatives with respect to the operands
Cprod_2d_	Represents two dimensional product - reduction in kernel generator expressions
Cprod_op	Operation for product reduction
Cprofile	Profiles C++ lines where the object is in scope
Cprofile_info	Class used for storing profiling information
Cpromote_elements	Struct with static function for elementwise type promotion
Cpromote_elements< Eigen::Matrix< T, R, C >, Eigen::Matrix< S, R, C > >	Struct with static function for elementwise type promotion
Cpromote_elements< Eigen::Matrix< T, R, C >, Eigen::Matrix< T, R, C > >	Struct with static function for elementwise type promotion
Cpromote_elements< std::vector< T >, std::vector< S > >	Struct with static function for elementwise type promotion
Cpromote_elements< std::vector< T >, std::vector< T > >	Struct with static function for elementwise type promotion
Cpromote_elements< T, T >	Struct with static function for elementwise type promotion
Cpromote_scalar_type	Template metaprogram to calculate a type for converting a convertible type
Cpromote_scalar_type< std::tuple< PromotionScalars... >, std::tuple< UnPromotedTypes... > >
Cpromote_scalar_type< T, S, require_all_t< is_var< T >, is_var< S >, is_eigen< value_type_t< S > > > >	Specialization for var_value when the type to convert to is a var_value
Cpromote_scalar_type< T, S, require_all_t< std::is_arithmetic< T >, is_var< S >, is_eigen< value_type_t< S > > > >	Specialization for var_value when the type to convert to is arithmetic
Cpromote_scalar_type< T, S, require_eigen_dense_base_t< S > >	Template metaprogram to calculate a type for a matrix, vector, row vector or Eigen::Array whose underlying scalar is converted from the second template parameter type to the first
Cpromote_scalar_type< T, S, require_eigen_sparse_base_t< S > >
Cpromote_scalar_type< T, std::vector< S > >	Template metaprogram to calculate a type for a container whose underlying scalar is converted from the second template parameter type to the first
Cread_fvar_functor	Functor for extracting the values and tangents from a matrix of fvar
Creduction_2d	Represents a two dimensional reduction in kernel generator expressions
Cref_type_for_opencl	Determines appropriate type for assigning expression of given type to, so that the resulting type has directly accessible contiguous colum-major data, which is needed to copy to OpenCL device for construction of matrix_cl
Cref_type_for_opencl< T, require_arena_matrix_t< T > >
Cref_type_for_opencl< T, require_not_eigen_t< T > >
Cresults_cl	Represents results that will be calculated in same kernel
Cround_
Cround_fun	Structure to wrap round() so it can be vectorized
Crow_index	Represents operation that determines row index
Crowwise_max_	Represents rowwise max reduction in kernel generator expressions
Crowwise_min_	Represents rowwise min reduction in kernel generator expressions
Crowwise_prod_	Represents rowwise product reduction in kernel generator expressions
Crowwise_reduction	Represents a rowwise reduction in kernel generator expressions
Crowwise_sum_	Represents rowwise sum reduction in kernel generator expressions
Crsqrt_
Cscalar_	Represents a scalar in kernel generator expressions
►CScopedChainableStack	The AD tape of reverse mode AD is by default stored globally within the process (or thread)
Cactivate_scope
Cselect_	Represents a selection operation in kernel generator expressions
Cseq_view
Cseq_view< double, std::vector< int > >
Cseq_view< T, Eigen::Matrix< S, 1, Eigen::Dynamic > >
Cseq_view< T, Eigen::Matrix< S, Eigen::Dynamic, 1 > >
Cseq_view< T, Eigen::Matrix< S, Eigen::Dynamic, Eigen::Dynamic > >
Cseq_view< T, std::vector< S > >
Cseq_view< T, std::vector< std::vector< T > > >
Cseq_view< T, std::vector< T > >
Cserializer	A structure to serialize structures to an internal stored sequence of scalars
Csign_fun	Structure to wrap sign() so it can be vectorized
Csin_
Csin_fun	Structure to wrap sin() so it can be vectorized
Csinh_
Csinh_fun	Structure to wrap sinh() so that it can be vectorized
Csqrt_
Csqrt_fun	Structure to wrap sqrt() so that it can be vectorized
Csquare_
Csquare_fun	Structure to wrap square() so that it can be vectorized
Cstack_alloc	An instance of this class provides a memory pool through which blocks of raw memory may be allocated and then collected simultaneously
Cstd_normal_log_qf_fun	Structure to wrap std_normal_log_qf() so it can be vectorized
Cstep_fun	Structure to wrap step() so it can be vectorized
Cstore_type
Cstore_type< double >
Cstore_type< int >
Cstored_gradient_vari	A var implementation that stores the daughter variable implementation pointers and the partial derivative with respect to the result explicitly in arrays constructed on the autodiff memory stack
Csubtraction_
Csubtraction_operator_
Csum_2d_	Represents two dimensional sum - reduction in kernel generator expressions
Csum_op	Operation for sum reduction
Ctan_
Ctan_fun	Structure to wrap tan() so that it can be vectorized
Ctanh_
Ctanh_fun	Structure to wrap tanh() so that it can be vectorized
Ctgamma_
Ctgamma_fun	Structure to wrap tgamma() so that it can be vectorized
Cto_int_fun	Return elementwise integer value of the specified real-valued container
Ctranspose_	Represents a transpose in kernel generator expressions
Ctrigamma_
Ctrigamma_fun	Structure to wrap trigamma() so it can be vectorized
Ctrunc_
Ctrunc_fun	Structure to wrap trunc() so it can be vectorized
Cunary_minus_	Represents an unary minus operation in kernel generator expressions
Cunary_operation_cl	Represents a unary operation in kernel generator expressions
Cunsafe_chainable_object	unsafe_chainable_object hold another object and is useful for connecting the lifetime of a specific object to the chainable stack
Cval_adj_functor	Functor for extracting the values and adjoints from a matrix of var or vari
Cvar_value
Cvar_value< T, internal::require_matrix_var_value< T > >	Independent (input) and dependent (output) variables for gradients
Cvar_value< T, require_floating_point_t< T > >	Independent (input) and dependent (output) variables for gradients
Cvari_base	Abstract base class that all vari_value and it's derived classes inherit
Cvari_cl_base
Cvari_value
Cvari_value< T, require_all_t< is_plain_type< T >, is_eigen_dense_base< T > > >	The variable implementation for Eigen dense matrix types
Cvari_value< T, require_eigen_sparse_base_t< T > >	The variable implementation for Eigen sparse matrix types
Cvari_value< T, require_matrix_cl_t< T > >	The variable implementation for matrix_cl
Cvari_value< T, require_t< std::is_floating_point< T > > >	The variable implementation for floating point types
Cvari_view	A vari_view is used to read from a slice of a vari_value with an inner eigen type
Cvari_view< T, require_all_t< is_eigen< T >, bool_constant<!is_plain_type< T >::value > > >
Cvari_view< T, require_kernel_expression_lhs_t< T > >
Cvari_view_eigen	This struct is follows the CRTP for methods common to vari_view<> and vari_value<Matrix>
Cvi_adj_functor	Functor for extracting the varis and adjoints from a matrix of var
Cvi_val_adj_functor	Functor for extracting the vari*, values, and adjoints from a matrix of var
Cvi_val_functor	Functor for extracting the varis and values from a matrix of var
Cwelford_covar_estimator
Cwelford_var_estimator
Cbase_type	Metaprogram structure to determine the base base type of a template argument
Cbase_type< T, std::enable_if_t< is_complex< T >::value > >	Template metaprogram defining the base type for values stored in a complex number
Cbase_type< T, std::enable_if_t< is_eigen< T >::value > >	Template metaprogram defining the base base type of values stored in an Eigen matrix
Cbase_type< T, std::enable_if_t< is_std_vector< T >::value > >	Specialization of base_type for vector to recursively return the inner base type
Cconditional_var_value	Conditionally construct a var_value container based on a scalar type
Cconditional_var_value< T_scalar, T_container, require_std_vector_t< T_container > >
Cerror_index
Ceval_return_type	Determines return type of calling .eval() on Eigen expression
Cis_any_var_matrix	Check if any types in a parameter pack are a var_value whose value_type is derived from Eigen::EigenBase
Cis_arena_matrix	Defines a static member named value which is defined to be true if the type is arena_matrix<T>
Cis_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>
Cis_arena_matrix_cl
Cis_autodiff	Checks if decayed type is a var or fvar
Cis_base_pointer_convertible	Checks if a type's pointer is convertible to a templated base type's pointer
Cis_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
Cis_complex	If T is a complex 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
Cis_complex< T, std::enable_if_t< internal::is_complex_impl< std::decay_t< T > >::value > >
Cis_complex_ad	If T is a complex type with an inner autodiff type (that is, an instance of std::complex<var> or std::complex<fvar<T>>) or a cv-qualified version thereof, provides the member constant value equal true; for any other type the value is false
Cis_complex_ad< T, std::enable_if_t< stan::math::conjunction< is_autodiff< base_type_t< T > >, internal::is_complex_impl< std::decay_t< T > > >::value > >
Cis_complex_arithmetic	If T is a complex type with an inner arithmetic type (that is, an instance of std::complex<Arithmetic>) or a cv-qualified version thereof, provides the member constant value equal true; for any other type the value is false
Cis_complex_arithmetic< T, std::enable_if_t< stan::math::conjunction< std::is_arithmetic< base_type_t< T > >, internal::is_complex_impl< std::decay_t< T > > >::value > >
Cis_constant	Metaprogramming struct to detect whether a given type is constant in the mathematical sense (not the C++ const sense)
Cis_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
Cis_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
Cis_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
Cis_detected
Cis_detected< T, Op, void_t< Op< T > > >	Checks whether a valid type is detected
Cis_double_or_int	Checks if decayed type is a double or integer
Cis_eigen	Check if type derives from EigenBase
Cis_eigen_array	Check if a type is derived from Eigen::ArrayBase
Cis_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
Cis_eigen_contiguous_map	Check if a type is an Eigen::Map with contiguous stride
Cis_eigen_dense_base	Checks whether type T is derived from Eigen::DenseBase
Cis_eigen_matrix_base	Checks whether type T is derived from Eigen::MatrixBase
Cis_eigen_matrix_dynamic	Checks whether type T is derived from Eigen::MatrixBase and has columns and rows not equal to 1
Cis_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
Cis_eigen_sparse_base	Checks whether type T is derived from Eigen::SparseMatrixBase
Cis_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
Cis_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
Cis_fvar< T, std::enable_if_t< internal::is_fvar_impl< std::decay_t< T > >::value > >
Cis_kernel_expression	Determines whether a type is is a valid kernel generator expression
Cis_kernel_expression_and_not_scalar	Determines whether a type is non-scalar type that is a valid kernel generator expression
Cis_kernel_expression_and_not_scalar< T, require_matrix_cl_t< T > >
Cis_kernel_expression_lhs	Determines whether a type is an assignable kernel generator expression
Cis_kernel_expression_lhs< T, require_matrix_cl_t< T > >
Cis_matrix	Check if a type is derived from Eigen::EigenBase or is a var_value whose value_type is derived from Eigen::EigenBase
Cis_matrix_cl	Checks if the decayed type of T is a matrix_cl
Cis_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
Cis_prim_or_rev_kernel_expression	Determines whether a type is either a kernel generator expression or a var containing a kernel generator expression
Cis_real	Checks if decayed type is a var, fvar, or arithmetic
Cis_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
Cis_rev_col_vector< T, require_all_t< is_var< scalar_type_t< T > >, math::disjunction< math::conjunction< is_var< T >, is_eigen_col_vector< value_type_t< T > > >, is_eigen_col_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
Cis_rev_kernel_expression	Determines whether a type is a var containing a kernel generator expression
Cis_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
Cis_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
Cis_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
Cis_rev_row_vector< T, require_all_t< is_var< scalar_type_t< T > >, math::disjunction< math::conjunction< is_var< T >, is_eigen_row_vector< value_type_t< T > > >, is_eigen_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
Cis_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
Cis_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
Cis_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
Cis_stan_scalar	Checks if decayed type is a var, fvar, or arithmetic
Cis_std_vector	Base implementation for checking if type is std vector
Cis_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
Cis_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
Cis_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
Cis_var_col_vector	Check if a type is a var_value whose value_type is derived from Eigen::EigenBase
Cis_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
Cis_var_eigen	Check if a type is a var_value whose value_type is derived from Eigen::EigenBase
Cis_var_matrix	Check if a type is a var_value whose value_type is derived from Eigen::EigenBase
Cis_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
Cis_var_row_vector	Check if a type is a var_value whose value_type is derived from Eigen::EigenBase
Cis_var_vector	Check if a type is a var_value whose value_type is derived from Eigen::EigenBase
Cis_vari	Specialization for checking if value of T minus cv qualifier and pointer is a vari
Cis_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
Cis_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
Cis_vector_like	Template metaprogram indicates whether a type is vector_like
Cis_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
Cis_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
Cmake_void
Coperation_cl_base	Non-templated base of operation_cl is needed for easy checking if something is a subclass of operation_cl
Coperation_cl_lhs_base	Non-templated base of operation_cl_lhs is needed for easy checking if something is a subclass of operation_cl_lhs
Cpartials_return_type	Template metaprogram to calculate the partial derivative type resulting from promoting all the scalar types of the template parameters
Cpartials_return_type< T >
Cpartials_type	This base implementation will contain a static member function named type equal to the type passed into it
Cpartials_type< T, require_fvar_t< T > >
Cpartials_type< T, require_var_t< T > >	Specialization of partials type returns double if input type is a double
Cplain_type	Determines plain (non expression) type associated with T
Cplain_type< T, require_all_kernel_expressions_and_none_scalar_t< T > >	Determines plain (non expression) type associated with T
Cplain_type< T, require_t< bool_constant< internal::has_eval< T >::value &&is_eigen< T >::value > > >	Determines plain (non expression) type associated with T
Cplain_type< T, require_t< bool_constant<!internal::has_eval< T >::value &&internal::has_plain_object< T >::value &&is_eigen< T >::value > > >
Cplain_type< T, require_t< stan::math::conjunction< is_var< T >, is_eigen< value_type_t< T > > > > >	Determines plain (non expression) type associated with T
Creal_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)
Creal_return< T, Ts... >
Cref_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
Cref_type_if< Condition, T, require_all_kernel_expressions_t< T > >
Cref_type_if< Condition, T, require_all_t< is_eigen< T >, bool_constant<!is_arena_matrix< T >::value > > >
Cref_type_if< Condition, T, require_arena_matrix_t< T > >
Creturn_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
Crev_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
Cscalar_lub	Defines a member type named type that is the least scalar type to which both template parameter scalar types are assignable in Stan
Cscalar_lub< std::complex< T1 >, std::complex< T2 > >
Cscalar_lub< std::complex< T1 >, T2 >
Cscalar_lub< T1, std::complex< T2 > >
Cscalar_seq_view	Scalar_seq_view provides a uniform sequence-like wrapper around either a scalar or a sequence of scalars
Cscalar_seq_view< C, require_eigen_vector_t< C > >
Cscalar_seq_view< C, require_stan_scalar_t< C > >	This specialization handles wrapping a scalar as if it were a sequence
Cscalar_seq_view< C, require_std_vector_t< C > >
Cscalar_seq_view< C, require_t< std::is_pointer< C > > >
Cscalar_seq_view< C, require_var_matrix_t< C > >
Cscalar_type	Metaprogram structure to determine the base scalar type of a template argument
Cscalar_type< T, require_all_kernel_expressions_and_none_scalar_t< T > >	Return the scalar type of an OpenCL matrix
Cscalar_type< T, std::enable_if_t< is_complex< T >::value > >	Template metaprogram defining the scalar type for values stored in a complex number
Cscalar_type< T, std::enable_if_t< is_eigen< T >::value &&!internal::has_scalar_trait< T >::value > >	Template metaprogram defining the base scalar type of values stored in an Eigen matrix
Cscalar_type< T, std::enable_if_t< is_eigen< T >::value &&internal::has_scalar_trait< T >::value > >	Template metaprogram defining the base scalar type of values stored in an Eigen matrix
Cscalar_type< T, std::enable_if_t< is_std_vector< T >::value > >	Specialization of scalar_type for vector to recursively return the inner scalar type
Cscalar_type< T, std::enable_if_t< is_var< T >::value > >	Template specialization defining the scalar type of values stored in var_value
CStdVectorBuilder	StdVectorBuilder allocates type T1 values to be used as intermediate values
Cvalue_type	Primary template class for metaprogram to compute the type of values stored in a container
Cvalue_type< T, require_all_kernel_expressions_and_none_scalar_t< T > >	Return the value type of an OpenCL matrix
Cvalue_type< T, require_t< is_vari< T > > >
Cvalue_type< T, std::enable_if_t< is_eigen< T >::value &&!internal::has_scalar_trait< T >::value > >	Template metaprogram defining the type of values stored in an Eigen matrix, vector, or row vector
Cvalue_type< T, std::enable_if_t< is_eigen< T >::value &&internal::has_scalar_trait< T >::value > >	Template metaprogram defining the type of values stored in an Eigen matrix, vector, or row vector
Cvalue_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
Cvalue_type< T, std::enable_if_t< is_var< T >::value > >
Cvalue_type< T, std::enable_if_t< std::is_pointer< T >::value > >	Specialization for pointers returns the underlying value the pointer is pointing to
Cvector_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
Cvector_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
Cvector_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
CVectorBuilder	VectorBuilder allocates type T1 values to be used as intermediate values
CVectorBuilderHelper	VectorBuilder allocates type T1 values to be used as intermediate values
CVectorBuilderHelper< T1, true, false >
CVectorBuilderHelper< T1, true, true >	Template specialization for using a vector
►Nstd	STL namespace
Ccomplex< stan::math::fvar< T > >	Specialization of the standard library complex number type for reverse-mode autodiff type stan::math::fvar<T>
Ccomplex< stan::math::var >	Specialization of the standard library complex number type for reverse-mode autodiff type stan::math::var
Citerator_traits< stan::math::fvar< T > >	Specialization of iterator traits for Stan math
Citerator_traits< stan::math::var_value< Iter > >	Specialization of iterator traits for Stan math
Cnumeric_limits< stan::math::fvar< T > >
Cnumeric_limits< stan::math::var_value< T > >	Specialization of numeric limits for var objects
Calgebra_solver_adapter	Adapt the non-variadic algebra_solver_newton and algebra_solver_powell arguemts to the variadic algebra_solver_newton_impl and algebra_solver_powell_impl interfaces
Cbool_constant
Cdouble_d	Double double - a 128 bit floating point number defined as an exact sum of 2 doubles
Cevaluator_base
CGenericNumTraits
Cintegrate_1d_adapter	Adapt the non-variadic integrate_1d arguments to the variadic integrate_1d_impl interface