Stan Math Library  2.20.0
reverse mode automatic differentiation
Class Hierarchy
This inheritance list is sorted roughly, but not completely, alphabetically:
[detail level 123]
 Cstan::math::accumulator< T >Class to accumulate values and eventually return their sum
 Cstan::math::acos_funStructure to wrap acos() so it can be vectorized
 Cstan::math::acosh_funStructure to wrap acosh() so it can be vectorized
 Cstan::math::ad_promotable< V, T >Template traits metaprogram to determine if a variable of one template type can be promoted to a second target template type
 Cstan::math::ad_promotable< bool, double >A bool may be promoted to a double
 Cstan::math::ad_promotable< char, double >A char may be promoted to a double
 Cstan::math::ad_promotable< double, double >A double may be promoted to a double
 Cstan::math::ad_promotable< float, double >A float may be promoted to a double
 Cstan::math::ad_promotable< int, double >An int may be promoted to a double
 Cstan::math::ad_promotable< long double, double >A long double may be promoted to a double
 Cstan::math::ad_promotable< long long, double >A long long may be promoted to a double
 Cstan::math::ad_promotable< long, double >A long may be promoted to a double
 Cstan::math::ad_promotable< short, double >A short may be promoted to a double
 Cstan::math::ad_promotable< T, var >Template traits metaprogram to determine if a variable of one template type is promotable to var
 Cstan::math::ad_promotable< typename std::enable_if< std::is_arithmetic< T >::value, T >::type, T >Any type may be promoted to itself
 Cstan::math::ad_promotable< unsigned char, double >An unsigned char may be promoted to a double
 Cstan::math::ad_promotable< unsigned int, double >An unsigned int may be promoted to a double
 Cstan::math::ad_promotable< unsigned long long, double >An unsigned long long may be promoted to a double
 Cstan::math::ad_promotable< unsigned long, double >An unsigned long may be promoted to a double
 Cstan::math::ad_promotable< unsigned short, double >An unsigned short may be promoted to a double
 Cstan::math::ad_promotable< V, fvar< T > >Template traits metaprogram to determine if a variable of one template type is promotable to the base type of a second fvar template type
 Cstan::math::ad_promotable< var, var >A var type is promotable to itself
 Cstan::math::append_return_type< T1, T2 >This template metaprogram is used to compute the return type for append_array
 Cstan::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
 Cstan::math::append_return_type< int, int >This template metaprogram is used to compute the return type for append_array
 Cstan::math::append_return_type< std::vector< T1 >, std::vector< T2 > >This template metaprogram is used to compute the return type for append_array
 Cstan::math::apply_scalar_unary< F, T >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
 Cstan::math::apply_scalar_unary< F, double >Template specialization for vectorized functions applying to double arguments
 Cstan::math::apply_scalar_unary< F, fvar< T > >Template specialization to fvar for vectorizing a unary scalar function
 Cstan::math::apply_scalar_unary< F, int >Template specialization for vectorized functions applying to integer arguments
 Cstan::math::apply_scalar_unary< F, std::vector< T > >Template specialization for vectorized functions applying to standard vector containers
 Cstan::math::apply_scalar_unary< F, var >Template specialization to var for vectorizing a unary scalar function
 Cstan::math::array_builder< T >Structure for building up arrays in an expression (rather than in statements) using an argumentchaining add() method and a getter method array() to return the result
 Cstan::math::asin_funStructure to wrap asin() so it can be vectorized
 Cstan::math::asinh_funStructure to wrap asinh() so it can be vectorized
 Cstan::math::atan_funStructure to wrap atan() so it can be vectorized
 Cstan::math::atanh_funStructure to wrap atanh() so it can be vectorized
 Cstan::math::AutodiffStackSingleton< ChainableT, ChainableAllocT >This struct always provides access to the autodiff stack using the singleton pattern
 Cstan::math::AutodiffStackSingleton< ChainableT, ChainableAllocT >::AutodiffStackStorage
 Cstan::math::internal::bounded< T_y, T_low, T_high, y_is_vec >
 Cstan::math::internal::bounded< T_y, T_low, T_high, true >
 Cstan::math::internal::broadcast_array< T >
 Cstan::math::internal::broadcast_array< double >
 Cstan::math::internal::broadcast_array< Dx >
 Cstan::math::internal::broadcast_array< partials_t >
 Cstan::math::cbrt_funStructure to wrap cbrt() so it can be vectorized
 Cstan::math::ceil_funStructure to wrap ceil() so it can be vectorized
 Cstan::math::chainable_allocA 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
 Cstan::math::child_type< T >Primary template class for metaprogram to compute child type of T
 Cstan::math::child_type< T_struct< T_child > >Specialization for template classes / structs
 Cstan::math::common_type< T1, T2 >Struct which calculates type promotion given two types
 Cstan::math::common_type< Eigen::Matrix< T1, R, C >, Eigen::Matrix< T2, R, C > >Struct which calculates type promotion over two types
 Cstan::math::common_type< std::vector< T1 >, std::vector< T2 > >Struct which calculates type promotion over two types
 Cstan::math::internal::compute_dims< T >Compute the dimensionality of the given template argument
 Cstan::math::internal::compute_dims< double >Compute the dimensionality of the given template argument
 Cstan::math::internal::compute_dims< Eigen::Matrix< T, R, C > >Compute the dimensionality of the given template argument
 Cstan::math::internal::compute_dims< std::vector< T > >Compute the dimensionality of the given template argument
 Cstan::math::cos_funStructure to wrap cos() so it can be vectorized
 Cstan::math::cosh_funStructure to wrap cosh() so it can be vectorized
 Cstan::math::coupled_ode_observer< F, T1, T2, T_t0, T_ts >Observer for the coupled states
 Cstan::math::coupled_ode_system< F, T1, T2 >The coupled_ode_system represents the coupled ode system, which is the base ode and the sensitivities of the base ode (derivatives with respect to the parameters of the base ode)
 Cstan::math::coupled_ode_system< F, double, double >coupled_ode_system specialization for for known initial values and known parameters
 Cstan::math::coupled_ode_system< F, double, var >The coupled_ode_system template specialization for known initial values and unknown parameters
 Cstan::math::coupled_ode_system< F, T_initial, T_param >
 Cstan::math::coupled_ode_system< F, var, double >The coupled_ode_system template specialization for unknown initial values and known parameters
 Cstan::math::coupled_ode_system< F, var, var >The coupled_ode_system template specialization for unknown initial values and unknown parameters
 Cstan::math::cvodes_integrator< Lmm >Integrator interface for CVODES' ODE solvers (Adams & BDF methods)
 Cstan::math::cvodes_ode_data< F, T_initial, T_param >CVODES ode data holder object which is used during CVODES integration for CVODES callbacks
 Cstan::math::digamma_funStructure to wrap digamma() so it can be vectorized
 Cstan::math::internal::dot_product_store_type< T >
 Cstan::math::internal::dot_product_store_type< double >
 Cstan::math::internal::dot_product_store_type< T1 >
 Cstan::math::internal::dot_product_store_type< T2 >
 Cstan::math::internal::dot_product_store_type< var >
 Cstan::math::internal::empty_broadcast_array< T, S >
 Cstan::math::internal::empty_broadcast_array< double, Op1 >
 Cstan::math::internal::empty_broadcast_array< double, Op2 >
 Cstan::math::internal::empty_broadcast_array< double, Op3 >
 Cstan::math::internal::empty_broadcast_array< double, Op4 >
 Cstan::math::internal::empty_broadcast_array< double, Op5 >
 Cstan::math::internal::empty_broadcast_array< Dx, Op1 >
 Cstan::math::internal::empty_broadcast_array< Dx, Op2 >
 Cstan::math::internal::empty_broadcast_array< Dx, Op3 >
 Cstan::math::internal::empty_broadcast_array< Dx, Op4 >
 Cstan::math::internal::empty_broadcast_array< Dx, Op5 >
 Cstan::math::internal::empty_broadcast_array< empty_broadcast_array< ViewElt, Eigen::Matrix< Op, R, C > >, Eigen::Matrix< Op, R, C > >
 Cstan::math::internal::empty_broadcast_array< empty_broadcast_array< ViewElt, std::vector< std::vector< Op > > >, std::vector< std::vector< Op > > >
 Cstan::math::internal::empty_broadcast_array< stan::math::internal::empty_broadcast_array, Eigen::Matrix< Op, R, C > >
 Cstan::math::internal::empty_broadcast_array< ViewElt, Eigen::Matrix< Op, R, C > >
 Cstan::math::internal::empty_broadcast_array< ViewElt, Eigen::Matrix< OpElt, R, C > >
 Cstan::math::internal::empty_broadcast_array< ViewElt, Op >
 Cstan::math::internal::empty_broadcast_array< ViewElt, std::vector< std::vector< Op > > >
 Cstan::math::erf_funStructure to wrap erf() so it can be vectorized
 Cstan::math::erfc_funStructure to wrap erfc() so that it can be vectorized
 Cstan::error_index
 Cstan::math::exp2_funStructure to wrap exp2() so it can be vectorized
 Cstan::math::exp_funStructure to wrap exp() so that it can be vectorized
 Cstan::math::expm1_funStructure to wrap expm1() so that it can be vectorized
 Cstan::math::fabs_funStructure to wrap fabs() so that it can be vectorized
 Cfalse_type
 Cstan::math::internal::finite< T_y, is_vec >
 Cstan::math::internal::finite< Eigen::Matrix< T, R, C >, true >
 Cstan::math::internal::finite< T_y, true >
 Cstan::math::floor_funStructure to wrap floor() so that it can be vectorized
 Cstan::math::fvar< T >This template class represents scalars used in forward-mode automatic differentiation, which consist of values and directional derivatives of the specified template type
 CEigen::internal::general_matrix_matrix_product< Index, stan::math::var, LhsStorageOrder, ConjugateLhs, stan::math::var, RhsStorageOrder, ConjugateRhs, ColMajor >
 CEigen::internal::general_matrix_vector_product< Index, stan::math::var, ColMajor, ConjugateLhs, stan::math::var, ConjugateRhs >Override matrix-vector and matrix-matrix products to use more efficient implementation
 CEigen::internal::general_matrix_vector_product< Index, stan::math::var, RowMajor, ConjugateLhs, stan::math::var, ConjugateRhs >
 CGenericNumTraits
 Cstan::math::internal::greater< T_y, T_low, is_vec >
 Cstan::math::internal::greater< T_y, T_low, true >
 Cstan::math::internal::greater_or_equal< T_y, T_low, is_vec >
 Cstan::math::internal::greater_or_equal< T_y, T_low, true >
 Cstan::math::idas_integratorIDAS DAE integrator
 Cstan::math::idas_system< F, Tyy, Typ, Tpar >IDAS DAE system that contains informtion on residual equation functor, sensitivity residual equation functor, as well as initial conditions
 Cstan::math::opencl_kernels::in_buffer
 Cstan::math::opencl_kernels::in_out_buffer
 Cstan::math::include_summand< propto, T, T_pack >Template metaprogram to calculate whether a summand needs to be included in a proportional (log) probability calculation
 Cstan::math::include_summand< propto, T >
 Cstan::math::internal::index_comparator< ascending, C >
 Cstan::math::index_type< T >Primary template class for the metaprogram to compute the index type of a container
 Cstan::math::index_type< const T >Template class for metaprogram to compute the type of indexes used in a constant container type
 Cstan::math::index_type< Eigen::Matrix< T, R, C > >Template metaprogram defining typedef for the type of index for an Eigen matrix, vector, or row vector
 Cstan::math::index_type< std::vector< T > >Template metaprogram class to compute the type of index for a standard vector
 Cstan::math::inv_cloglog_funStructure to wrap inv_cloglog() so that it can be vectorized
 Cstan::math::inv_funStructure to wrap inv() so that it can be vectorized
 Cstan::math::inv_logit_funStructure to wrap inv_logit() so that it can be vectorized
 Cstan::math::inv_Phi_funStructure to wrap inv_Phi() so it can be vectorized
 Cstan::math::inv_sqrt_funStructure to wrap inv_sqrt() so that it can be vectorized
 Cstan::math::inv_square_funStructure to wrap inv_square() so that it can be vectorized
 Cstan::is_constant< T >Metaprogramming struct to detect whether a given type is constant in the mathematical sense (not the C++ const sense)
 Cstan::is_constant< Eigen::Block< T > >Defines a public enum named value and sets it to true if the type of the elements in the provided Eigen Block is constant, false otherwise
 Cstan::is_constant< Eigen::Matrix< T, R, C > >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
 Cstan::is_constant< std::vector< T > >Defines a public enum named value and sets it to true if the type of the elements in the provided std::vector is constant, false otherwise
 Cstan::is_fvar< T >Defines a public enum named value which is defined to be false as the primitive scalar types cannot be a stan::math::fvar type
 Cstan::is_fvar< stan::math::fvar< T > >Defines a public enum named value and sets it to true(1) when instantiated with the stan::math::fvar type
 Cstan::is_var< T >Defines a public enum named value which is defined to be false as the primitive scalar types cannot be a stan::math::var type
 Cstan::is_var< stan::math::var >Defines a public enum named value and sets it to true(1) when instantiated with the stan::math::var type
 Cstan::is_var_or_arithmetic_type< T >Defines a public enum named value which is defined to be true (1) if the type is either var or an aritmetic type and false (0) otherwise
 Cstan::is_vector< T >
 Cstan::is_vector< const T >
 Cstan::is_vector< Eigen::Block< T > >
 Cstan::is_vector< Eigen::Matrix< T, 1, Eigen::Dynamic > >
 Cstan::is_vector< Eigen::Matrix< T, Eigen::Dynamic, 1 > >
 Cstan::is_vector< std::vector< T > >
 Cstan::is_vector_like< T >Template metaprogram indicates whether a type is vector_like
 Cstan::is_vector_like< const T >Template metaprogram indicates whether a type is vector_like
 Cstan::is_vector_like< Eigen::Array< T, R, C > >Template metaprogram indicates whether a type is vector_like
 Cstan::is_vector_like< Eigen::Matrix< T, R, C > >Template metaprogram indicates whether a type is vector_like
 Cstan::is_vector_like< T * >Template metaprogram indicates whether a type is vector_like
 Cstan::math::opencl_kernels::kernel_cl< Args >Creates functor for kernels
 Cstan::math::opencl_kernels::kernel_functor< Args >Functor used for compiling kernels
 Cstan::math::opencl_kernels::kernel_functor< internal::to_const_buffer_t< Args > &... >
 Cstan::math::LDLT_factor< T, R, C >LDLT_factor is a thin wrapper on Eigen::LDLT to allow for reusing factorizations and efficient autodiff of things like log determinants and solutions to linear systems
 Cstan::math::LDLT_factor< T2, R2, C2 >
 Cstan::math::LDLT_factor< var, R, C >A template specialization of src/stan/math/matrix/LDLT_factor.hpp for var which can be used with all the *_ldlt functions
 Cstan::math::internal::less< T_y, T_high, is_vec >
 Cstan::math::internal::less< T_y, T_high, true >
 Cstan::math::internal::less_or_equal< T_y, T_high, is_vec >
 Cstan::math::internal::less_or_equal< T_y, T_high, true >
 Cstan::math::lgamma_funStructure to wrap lgamma() so that it can be vectorized
 Cstan::math::log10_funStructure to wrap log10() so it can be vectorized
 Cstan::math::log1m_exp_funStructure to wrap log1m_exp() so it can be vectorized
 Cstan::math::log1m_funStructure to wrap log1m() so it can be vectorized
 Cstan::math::log1m_inv_logit_funStructure to wrap log1m_inv_logit() so it can be vectorized
 Cstan::math::log1p_exp_funStructure to wrap log1m_exp() so that it can be vectorized
 Cstan::math::log1p_funStructure to wrap log1p() so it can be vectorized
 Cstan::math::log2_funStructure to wrap log2() so it can be vectorized
 Cstan::math::log_funStructure to wrap log() so that it can be vectorized
 Cstan::math::log_inv_logit_funStructure to wrap log_inv_logit() so it can be vectorized
 Cstan::math::logit_funStructure to wrap logit() so it can be vectorized
 Cstan::math::internal::map_rect_combine< F, T_shared_param, T_job_param >
 Cstan::math::internal::map_rect_reduce< F, T_shared_param, T_job_param >
 Cstan::math::internal::map_rect_reduce< F, double, double >
 Cstan::math::internal::map_rect_reduce< F, double, var >
 Cstan::math::internal::map_rect_reduce< F, var, double >
 Cstan::math::internal::map_rect_reduce< F, var, var >
 Cstan::math::matrix_clRepresents a matrix on the OpenCL device
 Cstan::math::matrix_exp_action_handler
 Cstan::math::nlo_functor< T, NX, NY >A structure which gets passed to Eigen's dogleg algebraic solver
 Cstan::math::nlo_functor< double >
 Cstan::math::internal::nonnegative< T_y, is_vec >
 Cstan::math::internal::nonnegative< T_y, true >
 Cstan::math::internal::not_nan< T_y, is_vec >
 Cstan::math::internal::not_nan< T_y, true >
 Cstd::numeric_limits< stan::math::fvar< T > >
 Cstd::numeric_limits< stan::math::var >Specialization of numeric limits for var objects
 Cstan::math::opencl_contextThe API to access the methods and values in opencl_context_base
 Cstan::math::opencl_context_baseThe opencl_context_base class represents an OpenCL context in the standard Meyers singleton design pattern
 Cstan::math::operands_and_partials< Op1, Op2, Op3, Op4, Op5, T_return_type >This template builds partial derivatives with respect to a set of operands
 Cstan::math::operands_and_partials< Op1, Op2, Op3, Op4, Op5, fvar< Dx > >This class builds partial derivatives with respect to a set of operands
 Cstan::math::operands_and_partials< Op1, Op2, Op3, Op4, Op5, var >This class builds partial derivatives with respect to a set of operands
 Cstan::math::internal::ops_partials_edge< ViewElt, Op >An edge holds both the operands and its associated partial derivatives
 Cstan::math::internal::ops_partials_edge< double, Eigen::Matrix< var, R, C > >
 Cstan::math::internal::ops_partials_edge< double, Op1 >
 Cstan::math::internal::ops_partials_edge< double, Op2 >
 Cstan::math::internal::ops_partials_edge< double, Op3 >
 Cstan::math::internal::ops_partials_edge< double, Op4 >
 Cstan::math::internal::ops_partials_edge< double, Op5 >
 Cstan::math::internal::ops_partials_edge< double, std::vector< Eigen::Matrix< var, R, C > > >
 Cstan::math::internal::ops_partials_edge< double, std::vector< std::vector< var > > >
 Cstan::math::internal::ops_partials_edge< double, std::vector< var > >
 Cstan::math::internal::ops_partials_edge< double, var >
 Cstan::math::internal::ops_partials_edge< Dx, Eigen::Matrix< fvar< Dx >, R, C > >
 Cstan::math::internal::ops_partials_edge< Dx, fvar< Dx > >
 Cstan::math::internal::ops_partials_edge< Dx, Op1 >
 Cstan::math::internal::ops_partials_edge< Dx, Op2 >
 Cstan::math::internal::ops_partials_edge< Dx, Op3 >
 Cstan::math::internal::ops_partials_edge< Dx, Op4 >
 Cstan::math::internal::ops_partials_edge< Dx, Op5 >
 Cstan::math::internal::ops_partials_edge< Dx, std::vector< Eigen::Matrix< fvar< Dx >, R, C > > >
 Cstan::math::internal::ops_partials_edge< Dx, std::vector< fvar< Dx > > >
 Cstan::math::internal::ops_partials_edge< Dx, std::vector< std::vector< fvar< Dx > > > >
 Cstan::math::internal::ops_partials_edge< ViewElt, Eigen::Matrix< Op, R, C > >
 Cstan::math::internal::ops_partials_edge< ViewElt, std::vector< Eigen::Matrix< Op, R, C > > >
 Cstan::math::internal::ops_partials_edge< ViewElt, std::vector< std::vector< Op > > >
 Cstan::math::internal::ordered_constrain_op
 Cstan::math::opencl_kernels::out_buffer
 Cstan::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
 Cstan::partials_return_type< T >
 Cstan::partials_type< T >
 Cstan::partials_type< stan::math::fvar< T > >
 Cstan::partials_type< stan::math::var >
 Cstan::math::pass_type< T >
 Cstan::math::pass_type< double >
 Cstan::math::pass_type< int >
 Cstan::math::Phi_approx_funStructure to wrap Phi_approx() so it can be vectorized
 Cstan::math::Phi_funStructure to wrap Phi() so it can be vectorized
 Cstan::math::internal::positive_ordered_constrain_op
 Cstan::math::promote_elements< T, S >Struct with static function for elementwise type promotion
 Cstan::math::promote_elements< Eigen::Matrix< T, R, C >, Eigen::Matrix< S, R, C > >Struct with static function for elementwise type promotion
 Cstan::math::promote_elements< Eigen::Matrix< T, R, C >, Eigen::Matrix< T, R, C > >Struct with static function for elementwise type promotion
 Cstan::math::promote_elements< std::vector< T >, std::vector< S > >Struct with static function for elementwise type promotion
 Cstan::math::promote_elements< std::vector< T >, std::vector< T > >Struct with static function for elementwise type promotion
 Cstan::math::promote_elements< T, T >Struct with static function for elementwise type promotion
 Cstan::math::promote_scalar_struct< T, S >General struct to hold static function for promoting underlying scalar types
 Cstan::math::promote_scalar_struct< T, Eigen::Matrix< S, -1, -1 > >Struct to hold static function for promoting underlying scalar types
 Cstan::math::promote_scalar_struct< T, Eigen::Matrix< S, -1, 1 > >Struct to hold static function for promoting underlying scalar types
 Cstan::math::promote_scalar_struct< T, Eigen::Matrix< S, 1, -1 > >Struct to hold static function for promoting underlying scalar types
 Cstan::math::promote_scalar_struct< T, std::vector< S > >Struct to hold static function for promoting underlying scalar types
 Cstan::math::promote_scalar_struct< T, T >Struct to hold static function for promoting underlying scalar types
 Cstan::math::promote_scalar_type< T, S >Template metaprogram to calculate a type for converting a convertible type
 Cstan::math::promote_scalar_type< T, Eigen::Matrix< S, 1, Eigen::Dynamic > >Template metaprogram to calculate a type for a row vector whose underlying scalar is converted from the second template parameter type to the first
 Cstan::math::promote_scalar_type< T, Eigen::Matrix< S, Eigen::Dynamic, 1 > >Template metaprogram to calculate a type for a vector whose underlying scalar is converted from the second template parameter type to the first
 Cstan::math::promote_scalar_type< T, Eigen::Matrix< S, Eigen::Dynamic, Eigen::Dynamic > >Template metaprogram to calculate a type for a matrix whose underlying scalar is converted from the second template parameter type to the first
 Cstan::math::promote_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
 CEigen::internal::remove_all< stan::math::vari * >Partial specialization of Eigen's remove_all struct to stop Eigen removing pointer from vari* variables
 Cstan::return_type< T, Types_pack >Template metaprogram to calculate the base scalar return type resulting from promoting all the scalar types of the template parameters
 Cstan::return_type< T >
 Cstan::math::round_funStructure to wrap round() so it can be vectorized
 CEigen::internal::scalar_product_traits< double, stan::math::fvar< T > >Scalar product traits specialization for Eigen for forward-mode autodiff variables
 CEigen::internal::scalar_product_traits< double, stan::math::var >Scalar product traits override for Eigen for automatic gradient variables
 CEigen::internal::scalar_product_traits< stan::math::fvar< T >, double >Scalar product traits specialization for Eigen for forward-mode autodiff variables
 CEigen::internal::scalar_product_traits< stan::math::var, double >Scalar product traits override for Eigen for automatic gradient variables
 Cstan::scalar_seq_view< C, T >Scalar_seq_view provides a uniform sequence-like wrapper around either a scalar or a sequence of scalars
 Cstan::scalar_seq_view< T, T >This specialization handles wrapping a scalar as if it were a sequence
 Cstan::scalar_type< T >Metaprogram structure to determine the base scalar type of a template argument
 Cstan::scalar_type< const Eigen::Matrix< T, R, C > & >Template metaprogram defining the base scalar type of values stored in a referenced const Eigen matrix
 Cstan::scalar_type< const Eigen::Matrix< T, R, C > >Template metaprogram defining the base scalar type of values stored in a const Eigen matrix
 Cstan::scalar_type< const std::vector< T > & >
 Cstan::scalar_type< const std::vector< T > >
 Cstan::scalar_type< Eigen::Block< T > >Template metaprogram defining the base scalar type of values stored in an Eigen Block
 Cstan::scalar_type< Eigen::Matrix< T, R, C > & >Template metaprogram defining the base scalar type of values stored in a referenced Eigen matrix
 Cstan::scalar_type< Eigen::Matrix< T, R, C > >Template metaprogram defining the base scalar type of values stored in an Eigen matrix
 Cstan::scalar_type< std::vector< T > & >
 Cstan::scalar_type< std::vector< T > >
 Cstan::scalar_type< T * >
 Cstan::internal::scalar_type_helper_pre< is_vec, T, T_container >
 Cstan::internal::scalar_type_helper_pre< true, T, T_container >
 Cstan::scalar_type_pre< T >Metaprogram structure to determine the type of first container of the base scalar type of a template argument
 Cstan::math::seq_view< T, S >
 Cstan::math::seq_view< double, std::vector< int > >
 Cstan::math::seq_view< T, Eigen::Matrix< S, 1, Eigen::Dynamic > >
 Cstan::math::seq_view< T, Eigen::Matrix< S, Eigen::Dynamic, 1 > >
 Cstan::math::seq_view< T, Eigen::Matrix< S, Eigen::Dynamic, Eigen::Dynamic > >
 Cstan::math::seq_view< T, std::vector< S > >
 Cstan::math::seq_view< T, std::vector< std::vector< T > > >
 Cstan::math::seq_view< T, std::vector< T > >
 CEigen::internal::significant_decimals_default_impl< stan::math::var, false >Implemented this for printing to stream
 Cstan::math::internal::simplex_constrain_op
 Cstan::math::sin_funStructure to wrap sin() so it can be vectorized
 Cstan::math::sinh_funStructure to wrap sinh() so that it can be vectorized
 Cstan::size_of_helper< T, is_vec >
 Cstan::size_of_helper< T, true >
 Cstan::math::internal::softmax_op
 Cstan::math::sqrt_funStructure to wrap sqrt() so that it can be vectorized
 Cstan::math::square_funStructure to wrap square() so that it can be vectorized
 Cstan::math::stack_allocAn instance of this class provides a memory pool through which blocks of raw memory may be allocated and then collected simultaneously
 Cstan::StdVectorBuilder< used, T1, T2, T3, T4, T5, T6, T7 >StdVectorBuilder allocates type T1 values to be used as intermediate values
 Cstan::math::store_type< T >
 Cstan::math::store_type< double >
 Cstan::math::store_type< Eigen::Matrix< S, 1, Eigen::Dynamic > >
 Cstan::math::store_type< Eigen::Matrix< S, Eigen::Dynamic, 1 > >
 Cstan::math::store_type< Eigen::Matrix< S, Eigen::Dynamic, Eigen::Dynamic > >
 Cstan::math::store_type< int >
 Cstan::math::store_type< S >
 Cstan::math::store_type< std::vector< int > >
 Cstan::math::store_type< std::vector< S > >
 Cstan::math::store_type< std::vector< std::vector< T > > >
 Cstan::math::store_type< std::vector< T > >
 Cstan::math::system_functor< F, T0, T1, x_is_iv >A functor that allows us to treat either x or y as the independent variable
 Cstan::math::tan_funStructure to wrap tan() so that it can be vectorized
 Cstan::math::tanh_funStructure to wrap tanh() so that it can be vectorized
 Cstan::math::tgamma_funStructure to wrap tgamma() so that it can be vectorized
 Cstan::math::opencl_kernels::internal::to_buffer< T >Meta template struct for changing read/write buffer argument types to cl::Buffer types
 Cstan::math::opencl_kernels::internal::to_buffer< in_buffer >
 Cstan::math::opencl_kernels::internal::to_buffer< in_out_buffer >
 Cstan::math::opencl_kernels::internal::to_buffer< out_buffer >
 Cstan::math::opencl_kernels::internal::to_matrix_cl< T >Meta template struct for changing cl::Buffer argument types to matrix_cl
 Cstan::math::opencl_kernels::internal::to_matrix_cl< cl::Buffer >
 Cstan::math::opencl_kernels::internal::to_matrix_cl< in_buffer >Meta template struct for changing read and write buffer argument types to matrix_cl
 Cstan::math::opencl_kernels::internal::to_matrix_cl< in_out_buffer >
 Cstan::math::opencl_kernels::internal::to_matrix_cl< out_buffer >
 Cstan::math::trigamma_funStructure to wrap trigamma() so it can be vectorized
 Ctrue_type
 Cstan::math::trunc_funStructure to wrap trunc() so it can be vectorized
 Cstan::math::opencl_context_base::tuning_struct
 Ctype
 Cstan::math::value_type< T >Primary template class for metaprogram to compute the type of values stored in a container
 Cstan::math::value_type< const T >Template class for metaprogram to compute the type of values stored in a constant container
 Cstan::math::value_type< Eigen::Matrix< T, R, C > >Template metaprogram defining the type of values stored in an Eigen matrix, vector, or row vector
 Cstan::math::value_type< std::vector< T > >Template metaprogram class to compute the type of values stored in a standard vector
 Cstan::math::varIndependent (input) and dependent (output) variables for gradients
 Cstan::math::variThe variable implementation base class
 Cstan::vector_seq_view< 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
 Cstan::vector_seq_view< Eigen::Matrix< S, 1, Eigen::Dynamic > >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
 Cstan::vector_seq_view< Eigen::Matrix< S, Eigen::Dynamic, 1 > >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
 Cstan::vector_seq_view< std::vector< Eigen::Matrix< S, 1, Eigen::Dynamic > > >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
 Cstan::vector_seq_view< std::vector< Eigen::Matrix< S, Eigen::Dynamic, 1 > > >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
 Cstan::VectorBuilder< used, T1, T2, T3, T4, T5, T6, T7 >VectorBuilder allocates type T1 values to be used as intermediate values
 Cstan::VectorBuilderHelper< T1, used, is_vec >VectorBuilder allocates type T1 values to be used as intermediate values
 Cstan::VectorBuilderHelper< T1, true, false >
 Cstan::VectorBuilderHelper< T1, true, true >Template specialization for using a vector
 Cstan::VectorBuilderHelper< T1, used, contains_std_vector< T2, T3, T4, T5, T6, T7 >::value >
 Cstan::VectorBuilderHelper< T1, used, contains_vector< T2, T3, T4, T5, T6, T7 >::value >
 Cstan::math::welford_covar_estimator
 Cstan::math::welford_var_estimator

     [ Stan Home Page ] © 2011–2018, Stan Development Team.