▼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 > | |
Cremove_all< stan::math::vari * > | Partial specialization of Eigen's remove_all struct to stop Eigen removing pointer from vari* variables |
Cscalar_product_traits< double, stan::math::fvar< T > > | Scalar product traits specialization for Eigen for forward-mode autodiff variables |
Cscalar_product_traits< double, stan::math::var > | Scalar product traits override for Eigen for automatic gradient variables |
Cscalar_product_traits< stan::math::fvar< T >, double > | Scalar product traits specialization for Eigen for forward-mode autodiff variables |
Cscalar_product_traits< stan::math::var, double > | Scalar product traits override for Eigen for automatic gradient variables |
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 | |
►Ninternal | |
Cscalar_type_helper_pre | |
Cscalar_type_helper_pre< true, T, T_container > | |
►Nmath | Matrices and templated mathematical functions |
►Ninternal | |
Cacos_vari | |
Cacosh_vari | |
Cadd_vd_vari | |
Cadd_vv_vari | |
Casin_vari | |
Casinh_vari | |
Catan2_dv_vari | |
Catan2_vd_vari | |
Catan2_vv_vari | |
Catan_vari | |
Catanh_vari | |
Cbessel_first_kind_dv_vari | |
Cbessel_second_kind_dv_vari | |
Cbeta_dv_vari | |
Cbeta_vd_vari | |
Cbeta_vv_vari | |
Cbinary_log_loss_0_vari | |
Cbinary_log_loss_1_vari | |
Cbounded | |
Cbounded< T_y, T_low, T_high, true > | |
Cbroadcast_array | |
Ccbrt_vari | |
Cceil_vari | |
Ccompute_dims | Compute the dimensionality of the given template argument |
Ccompute_dims< double > | Compute the dimensionality of the given template argument |
Ccompute_dims< Eigen::Matrix< T, R, C > > | Compute the dimensionality of the given template argument |
Ccompute_dims< std::vector< T > > | Compute the dimensionality of the given template argument |
Ccos_vari | |
Ccosh_vari | |
Cdecrement_vari | |
Cdeterminant_vari | |
Cdigamma_vari | |
Cdivide_dv_vari | |
Cdivide_vd_vari | |
Cdivide_vv_vari | |
Cdot_product_store_type | |
Cdot_product_store_type< double > | |
Cdot_product_store_type< var > | |
Cdot_product_vari | |
Cdot_self_vari | |
Cempty_broadcast_array | |
Cempty_broadcast_array< ViewElt, Eigen::Matrix< OpElt, R, C > > | |
Cerf_vari | |
Cerfc_vari | |
Cexp2_vari | |
Cexp_vari | |
Cexpm1_vari | |
Cfalling_factorial_vd_vari | |
Cfdim_dv_vari | |
Cfdim_vd_vari | |
Cfdim_vv_vari | |
Cfinite | |
Cfinite< Eigen::Matrix< T, R, C >, true > | |
Cfinite< T_y, true > | |
Cfloor_vari | |
Cfma_ddv_vari | |
Cfma_vdd_vari | |
Cfma_vdv_vari | |
Cfma_vvd_vari | |
Cfma_vvv_vari | |
Cfmod_dv_vari | |
Cfmod_vd_vari | |
Cfmod_vv_vari | |
Cgamma_p_dv_vari | |
Cgamma_p_vd_vari | |
Cgamma_p_vv_vari | |
Cgamma_q_dv_vari | |
Cgamma_q_vd_vari | |
Cgamma_q_vv_vari | |
Cgreater | |
Cgreater< T_y, T_low, true > | |
Cgreater_or_equal | |
Cgreater_or_equal< T_y, T_low, true > | |
Chypot_vd_vari | |
Chypot_vv_vari | |
Cibeta_ddv_vari | |
Cibeta_dvd_vari | |
Cibeta_dvv_vari | |
Cibeta_vdd_vari | |
Cibeta_vdv_vari | |
Cibeta_vvd_vari | |
Cibeta_vvv_vari | |
Cinc_beta_vvv_vari | |
Cincrement_vari | |
Cindex_comparator | |
Cinv_cloglog_vari | |
Cinv_logit_vari | |
Cinv_Phi_vari | |
Cinv_sqrt_vari | |
Cinv_square_vari | |
Cinv_vari | |
Clbeta_dv_vari | |
Clbeta_vd_vari | |
Clbeta_vv_vari | |
Cless | |
Cless< T_y, T_high, true > | |
Cless_or_equal | |
Cless_or_equal< T_y, T_high, true > | |
Clgamma_vari | |
Clmgamma_dv_vari | |
Clog10_vari | |
Clog1m_exp_v_vari | |
Clog1m_vari | |
Clog1p_exp_v_vari | |
Clog1p_vari | |
Clog2_vari | |
Clog_det_ldlt_vari | 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 |
Clog_diff_exp_dv_vari | |
Clog_diff_exp_vd_vari | |
Clog_diff_exp_vv_vari | |
Clog_falling_factorial_dv_vari | |
Clog_falling_factorial_vd_vari | |
Clog_falling_factorial_vv_vari | |
Clog_inv_logit_diff_dv_vari | |
Clog_inv_logit_diff_vd_vari | |
Clog_inv_logit_diff_vv_vari | |
Clog_rising_factorial_dv_vari | |
Clog_rising_factorial_vd_vari | |
Clog_rising_factorial_vv_vari | |
Clog_softmax_elt_vari | |
Clog_sum_exp_dv_vari | |
Clog_sum_exp_matrix_vari | |
Clog_sum_exp_vd_vari | |
Clog_sum_exp_vector_vari | |
Clog_sum_exp_vv_vari | |
Clog_vari | |
Cmap_rect_combine | |
Cmap_rect_reduce | |
Cmap_rect_reduce< F, double, double > | |
Cmap_rect_reduce< F, double, var > | |
Cmap_rect_reduce< F, var, double > | |
Cmap_rect_reduce< F, var, var > | |
Cmdivide_left_dv_vari | |
Cmdivide_left_ldlt_alloc | |
Cmdivide_left_ldlt_dv_vari | The vari for mdivide_left_ldlt(A, b) which handles the chain() call for all elements of the result |
Cmdivide_left_ldlt_vd_vari | The vari for mdivide_left_ldlt(A, b) which handles the chain() call for all elements of the result |
Cmdivide_left_ldlt_vv_vari | The vari for mdivide_left_ldlt(A, b) which handles the chain() call for all elements of the result |
Cmdivide_left_spd_alloc | |
Cmdivide_left_spd_dv_vari | |
Cmdivide_left_spd_vd_vari | |
Cmdivide_left_spd_vv_vari | |
Cmdivide_left_tri_dv_vari | |
Cmdivide_left_tri_vd_vari | |
Cmdivide_left_tri_vv_vari | |
Cmdivide_left_vd_vari | |
Cmdivide_left_vv_vari | |
Cmodified_bessel_first_kind_dv_vari | |
Cmodified_bessel_second_kind_dv_vari | |
Cmultiply_log_dv_vari | |
Cmultiply_log_vd_vari | |
Cmultiply_log_vv_vari | |
Cmultiply_vd_vari | |
Cmultiply_vv_vari | |
Cneg_vari | |
Cnonnegative | |
Cnonnegative< T_y, true > | |
Cnot_nan | |
Cnot_nan< T_y, true > | |
Cops_partials_edge | An edge holds both the operands and its associated partial derivatives |
Cops_partials_edge< double, Eigen::Matrix< var, R, C > > | |
Cops_partials_edge< double, std::vector< Eigen::Matrix< var, R, C > > > | |
Cops_partials_edge< double, std::vector< std::vector< var > > > | |
Cops_partials_edge< double, std::vector< var > > | |
Cops_partials_edge< double, var > | |
Cops_partials_edge< Dx, Eigen::Matrix< fvar< Dx >, R, C > > | |
Cops_partials_edge< Dx, fvar< Dx > > | |
Cops_partials_edge< Dx, std::vector< Eigen::Matrix< fvar< Dx >, R, C > > > | |
Cops_partials_edge< Dx, std::vector< fvar< Dx > > > | |
Cops_partials_edge< Dx, std::vector< std::vector< fvar< Dx > > > > | |
Cops_partials_edge< ViewElt, Eigen::Matrix< Op, R, C > > | |
Cops_partials_edge< ViewElt, std::vector< Eigen::Matrix< Op, R, C > > > | |
Cops_partials_edge< ViewElt, std::vector< std::vector< Op > > > | |
Cordered_constrain_op | |
Cowens_t_dv_vari | |
Cowens_t_vd_vari | |
Cowens_t_vv_vari | |
CPhi_vari | |
Cpositive_ordered_constrain_op | |
Cpow_dv_vari | |
Cpow_vd_vari | |
Cpow_vv_vari | |
Cquad_form_vari | |
Cquad_form_vari_alloc | |
Crising_factorial_vd_vari | |
Cround_vari | |
Csimplex_constrain_op | |
Csin_vari | |
Csinh_vari | |
Csoftmax_op | |
Csqrt_vari | |
Csquare_vari | |
Csquared_distance_vd_vari | |
Csquared_distance_vv_vari | |
Csubtract_dv_vari | |
Csubtract_vd_vari | |
Csubtract_vv_vari | |
Ctan_vari | |
Ctanh_vari | |
Ctgamma_vari | |
Ctrace_gen_quad_form_vari | |
Ctrace_gen_quad_form_vari_alloc | |
Ctrace_inv_quad_form_ldlt_impl | |
Ctrace_inv_quad_form_ldlt_vari | |
Ctrace_quad_form_vari | |
Ctrace_quad_form_vari_alloc | |
Ctrunc_vari | |
Cunit_vector_elt_vari | |
►Nopencl_kernels | |
►Ninternal | |
Cto_buffer | Meta template struct for changing read/write buffer argument types to cl::Buffer types |
Cto_buffer< in_buffer > | |
Cto_buffer< in_out_buffer > | |
Cto_buffer< out_buffer > | |
Cto_matrix_cl | Meta template struct for changing cl::Buffer argument types to matrix_cl |
Cto_matrix_cl< cl::Buffer > | |
Cto_matrix_cl< in_buffer > | Meta template struct for changing read and write buffer argument types to matrix_cl |
Cto_matrix_cl< in_out_buffer > | |
Cto_matrix_cl< out_buffer > | |
Cin_buffer | |
Cin_out_buffer | |
Ckernel_cl | Creates functor for kernels |
Ckernel_functor | Functor used for compiling kernels |
Cout_buffer | |
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 bool 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 long, double > | A long long 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, var > | Template traits metaprogram to determine if a variable of one template type is promotable to var |
Cad_promotable< typename std::enable_if< std::is_arithmetic< T >::value, T >::type, T > | Any type may be promoted to itself |
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 long, double > | An unsigned long long 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 > > | Template traits metaprogram to determine if a variable of one template type is promotable to the base type of a second fvar template type |
Cad_promotable< var, var > | A var type is promotable to itself |
Cadj_jac_vari | Adj_jac_vari interfaces a user supplied functor with the reverse mode autodiff |
Calgebra_solver_vari | The vari class for the algebraic solver |
Cappend_return_type | This template metaprogram is used to compute the return type for append_array |
Cappend_return_type< Eigen::Matrix< T1, R, C >, Eigen::Matrix< T2, R, C > > | This template metaprogram is used to compute the return type for append_array |
Cappend_return_type< int, int > | This template metaprogram is used to compute the return type for append_array |
Cappend_return_type< std::vector< T1 >, std::vector< T2 > > | This template metaprogram is used to compute the return type for append_array |
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 |
►CAutodiffStackSingleton | This struct always provides access to the autodiff stack using the singleton pattern |
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_opencl | |
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 |
Cconjunction | Extends std::true_type when instantiated with zero or more template parameters, all of which extend the std::true_type |
Cconjunction< T, Ts... > | |
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 | 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) |
Ccoupled_ode_system< F, double, double > | coupled_ode_system specialization for for known initial values and known parameters |
Ccoupled_ode_system< F, double, var > | The coupled_ode_system template specialization for known initial values and unknown parameters |
Ccoupled_ode_system< F, var, double > | The coupled_ode_system template specialization for unknown initial values and known parameters |
Ccoupled_ode_system< F, var, var > | The coupled_ode_system template specialization for unknown initial values and unknown parameters |
Ccov_exp_quad_vari | |
Ccov_exp_quad_vari< T_x, double, T_l > | |
Ccvodes_integrator | Integrator interface for CVODES' ODE solvers (Adams & BDF methods) |
Ccvodes_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 |
Cdisjunction | Extends std::false_type when instantiated with zero or more template parameters, all of which extend the std::false_type |
Cdisjunction< Cond, Conds... > | |
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 | This template class represents scalars used in forward-mode automatic differentiation, which consist of values and directional derivatives of the specified template type |
Cgevv_vvv_vari | |
Cgp_exp_quad_cov_vari | This is a subclass of the vari class for precomputed gradients of gp_exp_quad_cov |
Cgp_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 |
Cgp_periodic_cov_vari | This is a subclass of the vari class for precomputed gradients of gp_periodic_cov |
Cgp_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 |
Chybrj_functor_solver | A functor with the required operators to call Eigen's algebraic solver |
Cidas_forward_system | IDAS DAE system with forward sensitivity calculation |
Cidas_integrator | IDAS DAE integrator |
Cidas_system | IDAS DAE system that contains informtion on residual equation functor, sensitivity residual equation functor, as well as initial conditions |
Cinclude_summand | Template metaprogram to calculate whether a summand needs to be included in a proportional (log) probability calculation |
Cinclude_summand< propto, T > | |
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 |
Cmatrix_cl | Represents a matrix on the OpenCL device |
Cmatrix_exp_action_handler | |
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 |
Cnlo_functor | A structure which gets passed to Eigen's dogleg algebraic solver |
Cop_ddv_vari | |
Cop_dv_vari | |
Cop_dvd_vari | |
Cop_dvv_vari | |
Cop_matrix_vari | |
Cop_v_vari | |
Cop_vd_vari | |
Cop_vdd_vari | |
Cop_vdv_vari | |
Cop_vector_vari | |
Cop_vv_vari | |
Cop_vvd_vari | |
Cop_vvv_vari | |
Copencl_context | The API to access the methods and values in opencl_context_base |
►Copencl_context_base | The opencl_context_base class represents an OpenCL context in the standard Meyers singleton design pattern |
Ctuning_struct | |
Coperands_and_partials | This template builds partial derivatives with respect to a set of operands |
Coperands_and_partials< Op1, Op2, Op3, Op4, Op5, fvar< Dx > > | This class builds partial derivatives with respect to a set of operands |
Coperands_and_partials< Op1, Op2, Op3, Op4, Op5, 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 |
Csystem_functor | A functor that allows us to treat either x or y as the independent variable |
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_std_vector | Extends std::false_type as a std::vector type cannot be a scalar primitive type |
Ccontains_std_vector< std::vector< T >, Ts... > | Extends std::true_type when instantiated with at least 1 template parameter of type std::vector<T> |
Ccontains_std_vector< T, Ts... > | |
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< 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 |
Cis_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 |
Cis_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 |
Cis_fvar | Defines a public enum named value which is defined to be false as the primitive scalar types cannot be a stan::math::fvar type |
Cis_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 |
Cis_var | Defines a public enum named value which is defined to be false as the primitive scalar types cannot be a stan::math::var type |
Cis_var< stan::math::var > | Defines a public enum named value and sets it to true(1) when instantiated with the stan::math::var type |
Cis_var_or_arithmetic_type | 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 |
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::Array< T, R, C > > | Template metaprogram indicates whether a type is vector_like |
Cis_vector_like< Eigen::Matrix< T, R, C > > | 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 | Template metaprogram to calculate the partial derivative type resulting from promoting all the scalar types of the template parameters |
Cpartials_return_type< T > | |
Cpartials_type | |
Cpartials_type< stan::math::fvar< T > > | |
Cpartials_type< stan::math::var > | |
Creturn_type | Template metaprogram to calculate the base scalar return type resulting from promoting all the scalar types of the template parameters |
Creturn_type< T > | |
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< const Eigen::Matrix< T, R, C > & > | Template metaprogram defining the base scalar type of values stored in a referenced const Eigen matrix |
Cscalar_type< const Eigen::Matrix< T, R, C > > | Template metaprogram defining the base scalar type of values stored in a const Eigen matrix |
Cscalar_type< const std::vector< T > & > | |
Cscalar_type< const std::vector< T > > | |
Cscalar_type< Eigen::Block< T > > | Template metaprogram defining the base scalar type of values stored in an Eigen Block |
Cscalar_type< Eigen::Matrix< T, R, C > & > | Template metaprogram defining the base scalar type of values stored in a referenced Eigen matrix |
Cscalar_type< Eigen::Matrix< T, R, C > > | Template metaprogram defining the base scalar type of values stored in an Eigen matrix |
Cscalar_type< std::vector< T > & > | |
Cscalar_type< std::vector< T > > | |
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 > | |
CStdVectorBuilder | StdVectorBuilder allocates type T1 values to be used as intermediate values |
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 |
▼Nstd | |
Cnumeric_limits< stan::math::fvar< T > > | |
Cnumeric_limits< stan::math::var > | Specialization of numeric limits for var objects |