| ▼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 |
