Cstan::math::accumulator< T > | Class to accumulate values and eventually return their sum |
Cstan::math::acos_fun | Structure to wrap acos() so it can be vectorized |
Cstan::math::acosh_fun | Structure 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_fun | Structure to wrap asin() so it can be vectorized |
Cstan::math::asinh_fun | Structure to wrap asinh() so it can be vectorized |
Cstan::math::atan_fun | Structure to wrap atan() so it can be vectorized |
Cstan::math::atanh_fun | Structure 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_fun | Structure to wrap cbrt() so it can be vectorized |
Cstan::math::ceil_fun | Structure to wrap ceil() so it can be vectorized |
►Cstan::math::chainable_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 |
Cstan::math::LDLT_alloc< R1, C1 > | |
Cstan::math::internal::mdivide_left_ldlt_alloc< R1, C1, R2, C2 > | |
Cstan::math::internal::mdivide_left_spd_alloc< R1, C1, R2, C2 > | |
Cstan::math::internal::quad_form_vari_alloc< Ta, Ra, Ca, Tb, Rb, Cb > | |
Cstan::math::internal::trace_gen_quad_form_vari_alloc< Td, Rd, Cd, Ta, Ra, Ca, Tb, Rb, Cb > | |
Cstan::math::internal::trace_inv_quad_form_ldlt_impl< T2, R2, C2, T3, R3, C3 > | |
Cstan::math::internal::trace_quad_form_vari_alloc< Ta, Ra, Ca, Tb, Rb, Cb > | |
Cstan::math::LDLT_alloc< R, C > | This object stores the actual (double typed) LDLT factorization of an Eigen::Matrix<var> along with pointers to its vari's which allow the *ldlt_ functions to save memory |
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_fun | Structure to wrap cos() so it can be vectorized |
Cstan::math::cosh_fun | Structure 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_fun | Structure 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_fun | Structure to wrap erf() so it can be vectorized |
Cstan::math::erfc_fun | Structure to wrap erfc() so that it can be vectorized |
Cstan::error_index | |
Cstan::math::exp2_fun | Structure to wrap exp2() so it can be vectorized |
Cstan::math::exp_fun | Structure to wrap exp() so that it can be vectorized |
Cstan::math::expm1_fun | Structure to wrap expm1() so that it can be vectorized |
Cstan::math::fabs_fun | Structure to wrap fabs() so that it can be vectorized |
►Cfalse_type | |
►Cstan::contains_std_vector< Ts... > | |
Cstan::contains_std_vector< T, Ts... > | |
Cstan::contains_std_vector< Ts > | Extends std::false_type as a std::vector type cannot be a scalar primitive type |
Cstan::math::disjunction< Conds > | Extends std::false_type when instantiated with zero or more template parameters, all of which extend the std::false_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_fun | Structure 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 | |
CEigen::NumTraits< stan::math::fvar< T > > | Numerical traits template override for Eigen for automatic gradient variables |
CEigen::NumTraits< stan::math::var > | Numerical traits template override for Eigen for automatic gradient variables |
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_integrator | IDAS 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::idas_forward_system< F, Tyy, Typ, Tpar > | IDAS DAE system with forward sensitivity calculation |
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_fun | Structure to wrap inv_cloglog() so that it can be vectorized |
Cstan::math::inv_fun | Structure to wrap inv() so that it can be vectorized |
Cstan::math::inv_logit_fun | Structure to wrap inv_logit() so that it can be vectorized |
Cstan::math::inv_Phi_fun | Structure to wrap inv_Phi() so it can be vectorized |
Cstan::math::inv_sqrt_fun | Structure to wrap inv_sqrt() so that it can be vectorized |
Cstan::math::inv_square_fun | Structure 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_fun | Structure to wrap lgamma() so that it can be vectorized |
Cstan::math::log10_fun | Structure to wrap log10() so it can be vectorized |
Cstan::math::log1m_exp_fun | Structure to wrap log1m_exp() so it can be vectorized |
Cstan::math::log1m_fun | Structure to wrap log1m() so it can be vectorized |
Cstan::math::log1m_inv_logit_fun | Structure to wrap log1m_inv_logit() so it can be vectorized |
Cstan::math::log1p_exp_fun | Structure to wrap log1m_exp() so that it can be vectorized |
Cstan::math::log1p_fun | Structure to wrap log1p() so it can be vectorized |
Cstan::math::log2_fun | Structure to wrap log2() so it can be vectorized |
Cstan::math::log_fun | Structure to wrap log() so that it can be vectorized |
Cstan::math::log_inv_logit_fun | Structure to wrap log_inv_logit() so it can be vectorized |
Cstan::math::logit_fun | Structure 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_cl | Represents 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::hybrj_functor_solver< S, F, T0, T1 > | A functor with the required operators to call Eigen's algebraic solver |
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_context | The API to access the methods and values in opencl_context_base |
Cstan::math::opencl_context_base | The 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_fun | Structure to wrap Phi_approx() so it can be vectorized |
Cstan::math::Phi_fun | Structure 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_fun | Structure 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_fun | Structure to wrap sin() so it can be vectorized |
Cstan::math::sinh_fun | Structure 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_fun | Structure to wrap sqrt() so that it can be vectorized |
Cstan::math::square_fun | Structure to wrap square() so that it can be vectorized |
Cstan::math::stack_alloc | An 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_fun | Structure to wrap tan() so that it can be vectorized |
Cstan::math::tanh_fun | Structure to wrap tanh() so that it can be vectorized |
Cstan::math::tgamma_fun | Structure 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_fun | Structure to wrap trigamma() so it can be vectorized |
►Ctrue_type | |
Cstan::contains_std_vector< std::vector< T >, Ts... > | Extends std::true_type when instantiated with at least 1 template parameter of type std::vector<T> |
Cstan::math::conjunction< T > | Extends std::true_type when instantiated with zero or more template parameters, all of which extend the std::true_type |
Cstan::math::trunc_fun | Structure to wrap trunc() so it can be vectorized |
Cstan::math::opencl_context_base::tuning_struct | |
►Ctype | |
Cstan::math::conjunction< T, Ts... > | |
Cstan::math::disjunction< Cond, Conds... > | |
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::var | Independent (input) and dependent (output) variables for gradients |
►Cstan::math::vari | The variable implementation base class |
Cstan::math::adj_jac_vari< F, Targs > | Adj_jac_vari interfaces a user supplied functor with the reverse mode autodiff |
Cstan::math::algebra_solver_vari< Fs, F, T, Fx > | The vari class for the algebraic solver |
Cstan::math::cholesky_block | |
Cstan::math::cholesky_opencl | |
Cstan::math::cholesky_scalar | |
Cstan::math::cov_exp_quad_vari< T_x, T_sigma, T_l > | |
Cstan::math::cov_exp_quad_vari< T_x, double, T_l > | |
Cstan::math::gevv_vvv_vari | |
Cstan::math::gp_exp_quad_cov_vari< T_x, T_sigma, T_l > | This is a subclass of the vari class for precomputed gradients of gp_exp_quad_cov |
Cstan::math::gp_exp_quad_cov_vari< T_x, double, T_l > | This is a subclass of the vari class for precomputed gradients of gp_exp_quad_cov |
Cstan::math::gp_periodic_cov_vari< T_x, T_sigma, T_l, T_p > | This is a subclass of the vari class for precomputed gradients of gp_periodic_cov |
Cstan::math::gp_periodic_cov_vari< T_x, double, T_l, T_p > | This is a subclass of the vari class for precomputed gradients of gp_periodic_cov |
Cstan::math::internal::determinant_vari< R, C > | |
Cstan::math::internal::dot_product_vari< T1, T2 > | |
Cstan::math::internal::dot_self_vari | |
Cstan::math::internal::log_det_ldlt_vari< R, C > | Returns the log det of the matrix whose LDLT factorization is given See The Matrix Cookbook's chapter on Derivatives of a Determinant In this case, it is just the inverse of the underlying matrix |
Cstan::math::internal::log_softmax_elt_vari | |
Cstan::math::internal::mdivide_left_dv_vari< R1, C1, R2, C2 > | |
Cstan::math::internal::mdivide_left_ldlt_dv_vari< R1, C1, R2, C2 > | The vari for mdivide_left_ldlt(A, b) which handles the chain() call for all elements of the result |
Cstan::math::internal::mdivide_left_ldlt_vd_vari< R1, C1, R2, C2 > | The vari for mdivide_left_ldlt(A, b) which handles the chain() call for all elements of the result |
Cstan::math::internal::mdivide_left_ldlt_vv_vari< R1, C1, R2, C2 > | The vari for mdivide_left_ldlt(A, b) which handles the chain() call for all elements of the result |
Cstan::math::internal::mdivide_left_spd_dv_vari< R1, C1, R2, C2 > | |
Cstan::math::internal::mdivide_left_spd_vd_vari< R1, C1, R2, C2 > | |
Cstan::math::internal::mdivide_left_spd_vv_vari< R1, C1, R2, C2 > | |
Cstan::math::internal::mdivide_left_tri_dv_vari< TriView, R1, C1, R2, C2 > | |
Cstan::math::internal::mdivide_left_tri_vd_vari< TriView, R1, C1, R2, C2 > | |
Cstan::math::internal::mdivide_left_tri_vv_vari< TriView, R1, C1, R2, C2 > | |
Cstan::math::internal::mdivide_left_vd_vari< R1, C1, R2, C2 > | |
Cstan::math::internal::mdivide_left_vv_vari< R1, C1, R2, C2 > | |
Cstan::math::internal::quad_form_vari< Ta, Ra, Ca, Tb, Rb, Cb > | |
Cstan::math::internal::squared_distance_vd_vari | |
Cstan::math::internal::squared_distance_vv_vari | |
Cstan::math::internal::trace_gen_quad_form_vari< Td, Rd, Cd, Ta, Ra, Ca, Tb, Rb, Cb > | |
Cstan::math::internal::trace_inv_quad_form_ldlt_vari< T2, R2, C2, T3, R3, C3 > | |
Cstan::math::internal::trace_quad_form_vari< Ta, Ra, Ca, Tb, Rb, Cb > | |
Cstan::math::internal::unit_vector_elt_vari | |
Cstan::math::multiply_mat_vari< Ta, Ra, Ca, Tb, Cb > | This is a subclass of the vari class for matrix multiplication A * B where A is N by M and B is M by K |
Cstan::math::multiply_mat_vari< double, 1, Ca, Tb, 1 > | This is a subclass of the vari class for matrix multiplication A * B where A is a double row vector of length M and B is a vector of length M |
Cstan::math::multiply_mat_vari< double, Ra, Ca, Tb, Cb > | This is a subclass of the vari class for matrix multiplication A * B where A is an N by M matrix of double and B is M by K |
Cstan::math::multiply_mat_vari< Ta, 1, Ca, double, 1 > | This is a subclass of the vari class for matrix multiplication A * B where A is a row vector of length M and B is a vector of length M of doubles |
Cstan::math::multiply_mat_vari< Ta, 1, Ca, Tb, 1 > | This is a subclass of the vari class for matrix multiplication A * B where A is 1 by M and B is M by 1 |
Cstan::math::multiply_mat_vari< Ta, Ra, Ca, double, Cb > | This is a subclass of the vari class for matrix multiplication A * B where A is N by M and B is an M by K matrix of doubles |
►Cstan::math::op_ddv_vari | |
Cstan::math::internal::fma_ddv_vari | |
Cstan::math::internal::ibeta_ddv_vari | |
►Cstan::math::op_dv_vari | |
Cstan::math::internal::atan2_dv_vari | |
Cstan::math::internal::bessel_first_kind_dv_vari | |
Cstan::math::internal::bessel_second_kind_dv_vari | |
Cstan::math::internal::beta_dv_vari | |
Cstan::math::internal::divide_dv_vari | |
Cstan::math::internal::fdim_dv_vari | |
Cstan::math::internal::fmod_dv_vari | |
Cstan::math::internal::gamma_p_dv_vari | |
Cstan::math::internal::gamma_q_dv_vari | |
Cstan::math::internal::lbeta_dv_vari | |
Cstan::math::internal::lmgamma_dv_vari | |
Cstan::math::internal::log_diff_exp_dv_vari | |
Cstan::math::internal::log_falling_factorial_dv_vari | |
Cstan::math::internal::log_inv_logit_diff_dv_vari | |
Cstan::math::internal::log_rising_factorial_dv_vari | |
Cstan::math::internal::log_sum_exp_dv_vari | |
Cstan::math::internal::modified_bessel_first_kind_dv_vari | |
Cstan::math::internal::modified_bessel_second_kind_dv_vari | |
Cstan::math::internal::multiply_log_dv_vari | |
Cstan::math::internal::owens_t_dv_vari | |
Cstan::math::internal::pow_dv_vari | |
Cstan::math::internal::subtract_dv_vari | |
Cstan::math::scal_squared_distance_dv_vari | |
►Cstan::math::op_dvd_vari | |
Cstan::math::internal::ibeta_dvd_vari | |
►Cstan::math::op_dvv_vari | |
Cstan::math::internal::ibeta_dvv_vari | |
►Cstan::math::op_matrix_vari | |
Cstan::math::internal::log_sum_exp_matrix_vari | |
►Cstan::math::op_v_vari | |
Cstan::math::internal::acos_vari | |
Cstan::math::internal::acosh_vari | |
Cstan::math::internal::asin_vari | |
Cstan::math::internal::asinh_vari | |
Cstan::math::internal::atan_vari | |
Cstan::math::internal::atanh_vari | |
Cstan::math::internal::binary_log_loss_0_vari | |
Cstan::math::internal::binary_log_loss_1_vari | |
Cstan::math::internal::cbrt_vari | |
Cstan::math::internal::ceil_vari | |
Cstan::math::internal::cos_vari | |
Cstan::math::internal::cosh_vari | |
Cstan::math::internal::decrement_vari | |
Cstan::math::internal::digamma_vari | |
Cstan::math::internal::erf_vari | |
Cstan::math::internal::erfc_vari | |
Cstan::math::internal::exp2_vari | |
Cstan::math::internal::exp_vari | |
Cstan::math::internal::expm1_vari | |
Cstan::math::internal::floor_vari | |
Cstan::math::internal::hypot_vd_vari | |
Cstan::math::internal::increment_vari | |
Cstan::math::internal::inv_cloglog_vari | |
Cstan::math::internal::inv_logit_vari | |
Cstan::math::internal::inv_Phi_vari | |
Cstan::math::internal::inv_sqrt_vari | |
Cstan::math::internal::inv_square_vari | |
Cstan::math::internal::inv_vari | |
Cstan::math::internal::lgamma_vari | |
Cstan::math::internal::log10_vari | |
Cstan::math::internal::log1m_exp_v_vari | |
Cstan::math::internal::log1m_vari | |
Cstan::math::internal::log1p_exp_v_vari | |
Cstan::math::internal::log1p_vari | |
Cstan::math::internal::log2_vari | |
Cstan::math::internal::log_vari | |
Cstan::math::internal::neg_vari | |
Cstan::math::internal::Phi_vari | |
Cstan::math::internal::round_vari | |
Cstan::math::internal::sin_vari | |
Cstan::math::internal::sinh_vari | |
Cstan::math::internal::sqrt_vari | |
Cstan::math::internal::square_vari | |
Cstan::math::internal::tan_vari | |
Cstan::math::internal::tanh_vari | |
Cstan::math::internal::tgamma_vari | |
Cstan::math::internal::trunc_vari | |
Cstan::math::precomp_v_vari | |
►Cstan::math::op_vd_vari | |
Cstan::math::internal::add_vd_vari | |
Cstan::math::internal::atan2_vd_vari | |
Cstan::math::internal::beta_vd_vari | |
Cstan::math::internal::divide_vd_vari | |
Cstan::math::internal::falling_factorial_vd_vari | |
Cstan::math::internal::fdim_vd_vari | |
Cstan::math::internal::fmod_vd_vari | |
Cstan::math::internal::gamma_p_vd_vari | |
Cstan::math::internal::gamma_q_vd_vari | |
Cstan::math::internal::lbeta_vd_vari | |
Cstan::math::internal::log_diff_exp_vd_vari | |
Cstan::math::internal::log_falling_factorial_vd_vari | |
Cstan::math::internal::log_inv_logit_diff_vd_vari | |
Cstan::math::internal::log_rising_factorial_vd_vari | |
Cstan::math::internal::log_sum_exp_vd_vari | |
Cstan::math::internal::multiply_log_vd_vari | |
Cstan::math::internal::multiply_vd_vari | |
Cstan::math::internal::owens_t_vd_vari | |
Cstan::math::internal::pow_vd_vari | |
Cstan::math::internal::rising_factorial_vd_vari | |
Cstan::math::internal::subtract_vd_vari | |
Cstan::math::scal_squared_distance_vd_vari | |
►Cstan::math::op_vdd_vari | |
Cstan::math::internal::fma_vdd_vari | |
Cstan::math::internal::ibeta_vdd_vari | |
►Cstan::math::op_vdv_vari | |
Cstan::math::internal::fma_vdv_vari | |
Cstan::math::internal::ibeta_vdv_vari | |
►Cstan::math::op_vector_vari | |
Cstan::math::internal::log_sum_exp_vector_vari | |
►Cstan::math::op_vv_vari | |
Cstan::math::internal::add_vv_vari | |
Cstan::math::internal::atan2_vv_vari | |
Cstan::math::internal::beta_vv_vari | |
Cstan::math::internal::divide_vv_vari | |
Cstan::math::internal::fdim_vv_vari | |
Cstan::math::internal::fmod_vv_vari | |
Cstan::math::internal::gamma_p_vv_vari | |
Cstan::math::internal::gamma_q_vv_vari | |
Cstan::math::internal::hypot_vv_vari | |
Cstan::math::internal::lbeta_vv_vari | |
Cstan::math::internal::log_diff_exp_vv_vari | |
Cstan::math::internal::log_falling_factorial_vv_vari | |
Cstan::math::internal::log_inv_logit_diff_vv_vari | |
Cstan::math::internal::log_rising_factorial_vv_vari | |
Cstan::math::internal::log_sum_exp_vv_vari | |
Cstan::math::internal::multiply_log_vv_vari | |
Cstan::math::internal::multiply_vv_vari | |
Cstan::math::internal::owens_t_vv_vari | |
Cstan::math::internal::pow_vv_vari | |
Cstan::math::internal::subtract_vv_vari | |
Cstan::math::precomp_vv_vari | |
Cstan::math::scal_squared_distance_vv_vari | |
►Cstan::math::op_vvd_vari | |
Cstan::math::internal::fma_vvd_vari | |
Cstan::math::internal::ibeta_vvd_vari | |
►Cstan::math::op_vvv_vari | |
Cstan::math::internal::fma_vvv_vari | |
Cstan::math::internal::ibeta_vvv_vari | |
Cstan::math::internal::inc_beta_vvv_vari | |
Cstan::math::precomp_vvv_vari | |
Cstan::math::precomputed_gradients_vari | A variable implementation taking a sequence of operands and partial derivatives with respect to the operands |
Cstan::math::stored_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 auto-diff memory stack |
►Cstan::math::sum_v_vari | Class for sums of variables constructed with standard vectors |
Cstan::math::sum_eigen_v_vari | Class for representing sums with constructors for Eigen |
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 | |