▼Nboost | Reimplementing boost functionality |
▼NEigen | (Expert) Numerical traits for algorithmic differentiation variables |
►Ninternal | (Expert) Product traits for algorithmic differentiation variables |
Cgeneral_matrix_matrix_product< Index, stan::math::var, LhsStorageOrder, ConjugateLhs, stan::math::var, RhsStorageOrder, ConjugateRhs, ColMajor > | |
Cgeneral_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 |
Cgeneral_matrix_vector_product< Index, stan::math::var, RowMajor, ConjugateLhs, stan::math::var, ConjugateRhs > | |
Cscalar_product_traits< double, stan::math::var > | Scalar product traits override for Eigen for automatic gradient variables |
Cscalar_product_traits< stan::math::var, double > | Scalar product traits override for Eigen for automatic gradient variables |
Csignificant_decimals_default_impl< stan::math::fvar< T >, false > | Implemented this for printing to stream |
Csignificant_decimals_default_impl< stan::math::var, false > | Implemented this for printing to stream |
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 |
▼Nstan | |
►Nmath | Matrices and templated mathematical functions |
►Ndetail | |
Cbounded | |
Cbounded< T_y, T_low, T_high, true > | |
Caccumulator | Class to accumulate values and eventually return their sum |
Cacos_fun | Structure to wrap acos() so it can be vectorized |
Cacosh_fun | Structure to wrap acosh() so it can be vectorized |
Cad_promotable | Template traits metaprogram to determine if a variable of one template type can be promoted to a second target template type |
Cad_promotable< bool, double > | A blool may be promoted to a double |
Cad_promotable< char, double > | A char may be promoted to a double |
Cad_promotable< double, double > | A double may be promoted to a double |
Cad_promotable< float, double > | A float may be promoted to a double |
Cad_promotable< int, double > | An int may be promoted to a double |
Cad_promotable< long double, double > | A long double may be promoted to a double |
Cad_promotable< long, double > | A long may be promoted to a double |
Cad_promotable< short, double > | A short may be promoted to a double |
Cad_promotable< T, T > | Any type may be promoted to itself |
Cad_promotable< T, var > | |
Cad_promotable< unsigned char, double > | An unsigned char may be promoted to a double |
Cad_promotable< unsigned int, double > | An unsigned int may be promoted to a double |
Cad_promotable< unsigned long, double > | An unsigned long may be promoted to a double |
Cad_promotable< unsigned short, double > | An unsigned short may be promoted to a double |
Cad_promotable< V, fvar< T > > | |
Cad_promotable< var, var > | |
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, double > | Template specialization for vectorized functions applying to double arguments |
Capply_scalar_unary< F, fvar< T > > | Template specialization to fvar for vectorizing a unary scalar function |
Capply_scalar_unary< F, int > | Template specialization for vectorized functions applying to integer arguments |
Capply_scalar_unary< F, std::vector< T > > | Template specialization for vectorized functions applying to standard vector containers |
Capply_scalar_unary< F, var > | Template specialization to var for vectorizing a unary scalar function |
Carray_builder | 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 |
Casin_fun | Structure to wrap asin() so it can be vectorized |
Casinh_fun | Structure to wrap asinh() so it can be vectorized |
Catan_fun | Structure to wrap atan() so it can be vectorized |
Catanh_fun | Structure to wrap atanh() so it can be vectorized |
CAutodiffStackStorage | |
Ccbrt_fun | Structure to wrap cbrt() so it can be vectorized |
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 |
Cchild_type | Primary template class for metaprogram to compute child type of T |
Cchild_type< T_struct< T_child > > | Specialization for template classes / structs |
Ccholesky_decompose_v_vari | |
Ccommon_type | |
Ccommon_type< Eigen::Matrix< T1, R, C >, Eigen::Matrix< T2, R, C > > | |
Ccommon_type< std::vector< T1 >, std::vector< T2 > > | |
Ccontainer_view | Primary template class for container view of array y with same structure as T1 and size as x |
Ccontainer_view< dummy, T2 > | Dummy type specialization, used in conjunction with struct dummy as described above |
Ccontainer_view< Eigen::Matrix< T1, R, C >, Eigen::Matrix< T2, R, C > > | Template specialization for Eigen::Map view of array with scalar type T2 with size inferred from input Eigen::Matrix |
Ccontainer_view< Eigen::Matrix< T1, R, C >, T2 > | Template specialization for scalar view of array y with scalar type T2 |
Ccontainer_view< std::vector< Eigen::Matrix< T1, R, C > >, Eigen::Matrix< T2, R, C > > | Template specialization for matrix view of array y with scalar type T2 with shape equal to x |
Ccontainer_view< std::vector< T1 >, T2 > | Template specialization for scalar view of array y with scalar type T2 with proper indexing inferred from input vector x of scalar type T1 |
Ccos_fun | Structure to wrap cos() so it can be vectorized |
Ccosh_fun | Structure to wrap cosh() so it can be vectorized |
Ccoupled_ode_observer | Observer for the coupled states |
Ccoupled_ode_system | Base template class for a coupled ordinary differential equation system, which adds sensitivities to the base system |
Ccoupled_ode_system< F, double, double > | The coupled ode system for known initial values and known parameters |
Ccoupled_ode_system< F, double, var > | The coupled ODE system for known initial values and unknown parameters |
Ccoupled_ode_system< F, var, double > | The coupled ODE system for unknown initial values and known parameters |
Ccoupled_ode_system< F, var, stan::math::var > | The coupled ode system for unknown intial values and unknown parameters |
Ccov_exp_quad_vari | This is a subclass of the vari class for precomputed gradients of cov_exp_quad |
Ccov_exp_quad_vari< T_x, double, T_l > | This is a subclass of the vari class for precomputed gradients of cov_exp_quad |
Ccvodes_ode_data | CVODES ode data holder object which is used during CVODES integration for CVODES callbacks |
Cdigamma_fun | Structure to wrap digamma() so it can be vectorized |
Cdummy | Empty struct for use in boost::condtional<is_constant_struct<T1>::value, T1, dummy>::type as false condtion for safe indexing |
Cerf_fun | Structure to wrap erf() so it can be vectorized |
Cerfc_fun | Structure to wrap erfc() so that it can be vectorized |
Cexp2_fun | Structure to wrap exp2() so it can be vectorized |
Cexp_fun | Structure to wrap exp() so that it can be vectorized |
Cexpm1_fun | Structure to wrap expm1() so that it can be vectorized |
Cfabs_fun | Structure to wrap fabs() so that it can be vectorized |
Cfloor_fun | Structure to wrap floor() so that it can be vectorized |
Cfvar | |
Cgevv_vvv_vari | |
Cinclude_summand | Template metaprogram to calculate whether a summand needs to be included in a proportional (log) probability calculation |
Cindex_type | Primary template class for the metaprogram to compute the index type of a container |
Cindex_type< const T > | Template class for metaprogram to compute the type of indexes used in a constant container type |
Cindex_type< Eigen::Matrix< T, R, C > > | Template metaprogram defining typedef for the type of index for an Eigen matrix, vector, or row vector |
Cindex_type< std::vector< T > > | Template metaprogram class to compute the type of index for a standard vector |
Cinv_cloglog_fun | Structure to wrap inv_cloglog() so that it can be vectorized |
Cinv_fun | Structure to wrap inv() so that it can be vectorized |
Cinv_logit_fun | Structure to wrap inv_logit() so that it can be vectorized |
Cinv_Phi_fun | Structure to wrap inv_Phi() so it can be vectorized |
Cinv_sqrt_fun | Structure to wrap inv_sqrt() so that it can be vectorized |
Cinv_square_fun | Structure to wrap inv_square() so that it can be vectorized |
CLDLT_alloc | 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 |
CLDLT_factor | |
CLDLT_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 |
CLDLT_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 |
Clgamma_fun | Structure to wrap lgamma() so that it can be vectorized |
Clog10_fun | Structure to wrap log10() so it can be vectorized |
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_fun | Structure to wrap log1m_inv_logit() so it can be vectorized |
Clog1p_exp_fun | Structure to wrap log1m_exp() so that it can be vectorized |
Clog1p_fun | Structure to wrap log1p() so it can be vectorized |
Clog2_fun | Structure to wrap log2() so it can be vectorized |
Clog_fun | Structure to wrap log() so that it can be vectorized |
Clog_inv_logit_fun | Structure to wrap log_inv_logit() so it can be vectorized |
Clogit_fun | Structure to wrap logit() so it can be vectorized |
Cmultiply_mat_vari | 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 |
Cmultiply_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 |
Cmultiply_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 |
Cmultiply_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 |
Cmultiply_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 |
Cmultiply_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 |
Code_system | Internal representation of an ODE model object which provides convenient Jacobian functions to obtain gradients wrt to states and parameters |
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 | |
COperandsAndPartials | This class builds partial derivatives with respect to a set of operands |
COperandsAndPartials< T1, T2, T3, T4, T5, T6, fvar< T_partials_return > > | This class builds partial derivatives with respect to a set of operands |
COperandsAndPartials< T1, T2, T3, T4, T5, T6, stan::math::var > | This class builds partial derivatives with respect to a set of operands |
Cpass_type | |
Cpass_type< double > | |
Cpass_type< int > | |
CPhi_approx_fun | Structure to wrap Phi_approx() so it can be vectorized |
CPhi_fun | Structure to wrap Phi() so it can be vectorized |
Cprecomp_v_vari | |
Cprecomp_vv_vari | |
Cprecomp_vvv_vari | |
Cprecomputed_gradients_vari | A variable implementation taking a sequence of operands and partial derivatives with respect to the operands |
Cpromote_scalar_struct | General struct to hold static function for promoting underlying scalar types |
Cpromote_scalar_struct< T, Eigen::Matrix< S, -1, -1 > > | Struct to hold static function for promoting underlying scalar types |
Cpromote_scalar_struct< T, Eigen::Matrix< S, -1, 1 > > | Struct to hold static function for promoting underlying scalar types |
Cpromote_scalar_struct< T, Eigen::Matrix< S, 1, -1 > > | Struct to hold static function for promoting underlying scalar types |
Cpromote_scalar_struct< T, std::vector< S > > | Struct to hold static function for promoting underlying scalar types |
Cpromote_scalar_struct< T, T > | Struct to hold static function for promoting underlying scalar types |
Cpromote_scalar_type | Template metaprogram to calculate a type for converting a convertible type |
Cpromote_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 |
Cpromote_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 |
Cpromote_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 |
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 |
Cpromoter | |
Cpromoter< Eigen::Matrix< F, R, C >, Eigen::Matrix< T, R, C > > | |
Cpromoter< Eigen::Matrix< T, R, C >, Eigen::Matrix< T, R, C > > | |
Cpromoter< std::vector< F >, std::vector< T > > | |
Cpromoter< std::vector< T >, std::vector< T > > | |
Cpromoter< T, T > | |
Cround_fun | Structure to wrap round() so it can be vectorized |
Cscal_squared_distance_dv_vari | |
Cscal_squared_distance_vd_vari | |
Cscal_squared_distance_vv_vari | |
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 > > | |
Csin_fun | Structure to wrap sin() so it can be vectorized |
Csinh_fun | Structure to wrap sinh() so that it can be vectorized |
Csqrt_fun | Structure to wrap sqrt() so that it can be vectorized |
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 |
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 auto-diff memory stack |
Csum_eigen_v_vari | Class for representing sums with constructors for Eigen |
Csum_v_vari | Class for sums of variables constructed with standard vectors |
Ctan_fun | Structure to wrap tan() so that it can be vectorized |
Ctanh_fun | Structure to wrap tanh() so that it can be vectorized |
Ctgamma_fun | Structure to wrap tgamma() so that it can be vectorized |
Ctrigamma_fun | Structure to wrap trigamma() so it can be vectorized |
Ctrunc_fun | Structure to wrap trunc() so it can be vectorized |
Cvalue_type | Primary template class for metaprogram to compute the type of values stored in a container |
Cvalue_type< const T > | Template class for metaprogram to compute the type of values stored in a constant container |
Cvalue_type< Eigen::Matrix< T, R, C > > | Template metaprogram defining the type of values stored in an Eigen matrix, vector, or row vector |
Cvalue_type< std::vector< T > > | Template metaprogram class to compute the type of values stored in a standard vector |
Cvar | Independent (input) and dependent (output) variables for gradients |
Cvari | The variable implementation base class |
Cwelford_covar_estimator | |
Cwelford_var_estimator | |
Ccontains_fvar | Metaprogram to calculate the base scalar return type resulting from promoting all the scalar types of the template parameters |
Ccontains_nonconstant_struct | |
Ccontains_vector | |
Cerror_index | |
Cis_constant | Metaprogramming struct to detect whether a given type is constant in the mathematical sense (not the C++ const sense) |
Cis_constant_struct | Metaprogram to determine if a type has a base scalar type that can be assigned to type double |
Cis_constant_struct< Eigen::Block< T > > | |
Cis_constant_struct< Eigen::Matrix< T, R, C > > | |
Cis_constant_struct< std::vector< T > > | |
Cis_fvar | |
Cis_fvar< stan::math::fvar< T > > | |
Cis_var | |
Cis_var< stan::math::var > | |
Cis_var_or_arithmetic | |
Cis_vector | |
Cis_vector< const T > | |
Cis_vector< Eigen::Block< T > > | |
Cis_vector< Eigen::Matrix< T, 1, Eigen::Dynamic > > | |
Cis_vector< Eigen::Matrix< T, Eigen::Dynamic, 1 > > | |
Cis_vector< std::vector< T > > | |
Cis_vector_like | Template metaprogram indicates whether a type is vector_like |
Cis_vector_like< const T > | Template metaprogram indicates whether a type is vector_like |
Cis_vector_like< Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > > | Template metaprogram indicates whether a type is vector_like |
Cis_vector_like< T * > | Template metaprogram indicates whether a type is vector_like |
Cpartials_return_type | |
Cpartials_type | |
Cpartials_type< stan::math::fvar< T > > | |
Cpartials_type< stan::math::var > | |
Creturn_type | Metaprogram to calculate the base scalar return type resulting from promoting all the scalar types of the template parameters |
Cscalar_type | Metaprogram structure to determine the base scalar type of a template argument |
Cscalar_type< Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > > | |
Cscalar_type< T * > | |
Cscalar_type_pre | Metaprogram structure to determine the type of first container of the base scalar type of a template argument |
Csize_of_helper | |
Csize_of_helper< T, true > | |
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 |
CVectorView | VectorView is a template expression that is constructed with a container or scalar, which it then allows to be used as an array using operator[] |
CVectorView< const Eigen::Matrix< T, R, C >, true, false > | |
CVectorView< const std::vector< T >, true, false > | |
CVectorView< Eigen::Matrix< T, R, C >, true, false > | |
CVectorView< std::vector< T >, true, false > | |
CVectorView< T, false, false > | |
CVectorView< T, is_array, true > | |
CVectorView< T, true, false > | |
CVectorViewMvt | VectorViewMvt is a template expression that wraps either an Eigen::Matrix or a std::vector<Eigen::Matrix> and allows the template expression to be used as an array using operator[] |
CVectorViewMvt< const T, is_array, throw_if_accessed > | VectorViewMvt with const correctness |
▼Nstd | |
Cnumeric_limits< stan::math::fvar< T > > | |
Cnumeric_limits< stan::math::var > | Specialization of numeric limits for var objects |