| ▼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_block | |
| Ccholesky_scalar | |
| Ccommon_type | Struct which calculates type promotion given two types |
| Ccommon_type< Eigen::Matrix< T1, R, C >, Eigen::Matrix< T2, R, C > > | Struct which calculates type promotion over two types |
| Ccommon_type< std::vector< T1 >, std::vector< T2 > > | Struct which calculates type promotion over two types |
| 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 | 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_elements | Struct with static function for elementwise type promotion |
| Cpromote_elements< Eigen::Matrix< T, R, C >, Eigen::Matrix< S, R, C > > | Struct with static function for elementwise type promotion |
| Cpromote_elements< Eigen::Matrix< T, R, C >, Eigen::Matrix< T, R, C > > | Struct with static function for elementwise type promotion |
| Cpromote_elements< std::vector< T >, std::vector< S > > | Struct with static function for elementwise type promotion |
| Cpromote_elements< std::vector< T >, std::vector< T > > | Struct with static function for elementwise type promotion |
| Cpromote_elements< T, T > | Struct with static function for elementwise type promotion |
| Cpromote_scalar_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 |
| 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_seq_view | Scalar_seq_view provides a uniform sequence-like wrapper around either a scalar or a sequence of scalars |
| Cscalar_seq_view< T, T > | This specialization handles wrapping a scalar as if it were a sequence |
| 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 > | |
| Cvector_seq_view | This class provides a low-cost wrapper for situations where you either need an Eigen Vector or RowVector or a std::vector of them and you want to be agnostic between those two options |
| Cvector_seq_view< 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 |
| Cvector_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 |
| Cvector_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 |
| Cvector_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 |
| 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 > | |
| ▼Nstd | |
| Cnumeric_limits< stan::math::fvar< T > > | |
| Cnumeric_limits< stan::math::var > | Specialization of numeric limits for var objects |
