 |
Stan Math Library
5.0.0
Automatic Differentiation
|
|
|
Stan Math Library
5.0.0
Automatic Differentiation
|
|
| ►NEigen | (Expert) Numerical traits for algorithmic differentiation variables |
| ►Ninternal | (Expert) Product traits for algorithmic differentiation variables |
| Cevaluator< stan::math::Holder< ArgType, Ptrs... > > | |
| Cfunctor_has_linear_access< stan::math::read_fvar_functor< EigFvar, EigOut > > | Enable linear access of inputs when using read_fvar |
| Cfunctor_has_linear_access< stan::math::val_adj_functor< EigVar, EigDbl > > | Enable linear access of inputs when using read_val_adj |
| Cfunctor_has_linear_access< stan::math::vi_adj_functor< EigVar, EigVari > > | Enable linear access of inputs when using read_vi_adj |
| Cfunctor_has_linear_access< stan::math::vi_val_adj_functor< EigVar, EigVari, EigDbl > > | Enable linear access of inputs when using read_vi_val_adj |
| Cfunctor_has_linear_access< stan::math::vi_val_functor< EigVar, EigVari > > | Enable linear access of inputs when using read_vi_val |
| Cgeneral_matrix_matrix_product< Index, stan::math::var, LhsStorageOrder, ConjugateLhs, stan::math::var, RhsStorageOrder, ConjugateRhs, ColMajor, ResInnerStride > | |
| Cgeneral_matrix_vector_product< Index, stan::math::var, LhsMapper, ColMajor, ConjugateLhs, stan::math::var, RhsMapper, ConjugateRhs, Version > | Specialization of matrix-vector products for reverse-mode autodiff variables |
| Cgeneral_matrix_vector_product< Index, stan::math::var, LhsMapper, RowMajor, ConjugateLhs, stan::math::var, RhsMapper, ConjugateRhs, Version > | |
| Cremove_all< stan::math::vari * > | Partial specialization of Eigen's remove_all struct to stop Eigen removing pointer from vari* variables |
| Ctraits< stan::math::arena_matrix< T > > | |
| Ctraits< stan::math::Holder< ArgType, Ptrs... > > | |
| Ctraits< stan::math::pinned_matrix< T > > | |
| 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 |
| CScalarBinaryOpTraits< double, int, BinaryOp > | Traits specialization for Eigen binary operations for double and int arguments |
| CScalarBinaryOpTraits< double, stan::math::fvar< T >, BinaryOp > | Traits specialization for Eigen binary operations for double and autodiff arguments |
| CScalarBinaryOpTraits< double, stan::math::var, BinaryOp > | Traits specialization for Eigen binary operations for double and reverse-mode autodiff arguments |
| CScalarBinaryOpTraits< double, std::complex< stan::math::fvar< T > >, BinaryOp > | Traits specialization for Eigen binary operations for double and complex autodiff arguments |
| CScalarBinaryOpTraits< double, std::complex< stan::math::var >, BinaryOp > | Traits specialization for Eigen binary operations for double and complex autodiff arguments |
| CScalarBinaryOpTraits< int, double, BinaryOp > | Traits specialization for Eigen binary operations for int and double arguments |
| CScalarBinaryOpTraits< int, stan::math::fvar< T >, BinaryOp > | Traits specialization for Eigen binary operations for int and autodiff arguments |
| CScalarBinaryOpTraits< int, stan::math::var, BinaryOp > | Traits specialization for Eigen binary operations for int and reverse-mode autodiff arguments |
| CScalarBinaryOpTraits< int, std::complex< double >, BinaryOp > | Traits specialization for Eigen binary operations for int and complex double arguments |
| CScalarBinaryOpTraits< int, std::complex< stan::math::fvar< T > >, BinaryOp > | Traits specialization for Eigen binary operations for int and complex autodiff arguments |
| CScalarBinaryOpTraits< int, std::complex< stan::math::var >, BinaryOp > | Traits specialization for Eigen binary operations for int and complex autodiff arguments |
| CScalarBinaryOpTraits< stan::math::fvar< T >, double, BinaryOp > | Traits specialization for Eigen binary operations for autodiff and double arguments |
| CScalarBinaryOpTraits< stan::math::fvar< T >, int, BinaryOp > | Traits specialization for Eigen binary operations for autodiff and int arguments |
| CScalarBinaryOpTraits< stan::math::fvar< T >, std::complex< double >, BinaryOp > | Traits specialization for Eigen binary operations for autodiff and complex double arguments |
| CScalarBinaryOpTraits< stan::math::var, double, BinaryOp > | Traits specialization for Eigen binary operations for reverse-mode autodiff and double arguments |
| CScalarBinaryOpTraits< stan::math::var, int, BinaryOp > | Traits specialization for Eigen binary operations for reverse-mode autodiff and int arguments |
| CScalarBinaryOpTraits< stan::math::var, stan::math::var, BinaryOp > | Traits specialization for Eigen binary operations for reverse-mode autodiff arguments |
| CScalarBinaryOpTraits< stan::math::var, std::complex< double >, BinaryOp > | Traits specialization for Eigen binary operations for autodiff and complex double arguments |
| CScalarBinaryOpTraits< stan::math::var, std::complex< stan::math::var >, BinaryOp > | |
| CScalarBinaryOpTraits< std::complex< double >, int, BinaryOp > | Traits specialization for Eigen binary operations for complex double and int arguments |
| CScalarBinaryOpTraits< std::complex< double >, stan::math::fvar< T >, BinaryOp > | Traits specialization for Eigen binary operations for complex double and autodiff arguments |
| CScalarBinaryOpTraits< std::complex< double >, stan::math::var, BinaryOp > | Traits specialization for Eigen binary operations for complex double and autodiff arguments |
| CScalarBinaryOpTraits< std::complex< double >, std::complex< stan::math::fvar< T > >, BinaryOp > | Traits specialization for Eigen binary operations for complex double and complex autodiff arguments |
| CScalarBinaryOpTraits< std::complex< double >, std::complex< stan::math::var >, BinaryOp > | Traits specialization for Eigen binary operations for complex double and complex autodiff arguments |
| CScalarBinaryOpTraits< std::complex< stan::math::fvar< T > >, double, BinaryOp > | Traits specialization for Eigen binary operations for complex autodiff and double arguments |
| CScalarBinaryOpTraits< std::complex< stan::math::fvar< T > >, int, BinaryOp > | Traits specialization for Eigen binary operations for complex autodiff and int arguments |
| CScalarBinaryOpTraits< std::complex< stan::math::fvar< T > >, std::complex< double >, BinaryOp > | Traits specialization for Eigen binary operations for complex autodiff and complex double arguments |
| CScalarBinaryOpTraits< std::complex< stan::math::var >, double, BinaryOp > | Traits specialization for Eigen binary operations for complex autodiff and double arguments |
| CScalarBinaryOpTraits< std::complex< stan::math::var >, int, BinaryOp > | Traits specialization for Eigen binary operations for complex autodiff and int arguments |
| CScalarBinaryOpTraits< std::complex< stan::math::var >, stan::math::var, BinaryOp > | |
| CScalarBinaryOpTraits< std::complex< stan::math::var >, std::complex< double >, BinaryOp > | Traits specialization for Eigen binary operations for complex autodiff and complex double arguments |
| CScalarBinaryOpTraits< std::complex< stan::math::var >, std::complex< stan::math::var >, BinaryOp > | |
| ►Nstan | The lgamma implementation in stan-math is based on either the reentrant safe lgamma_r implementation from C or the boost::math::lgamma implementation |
| ►Ninternal | |
| Carena_type_impl | |
| Carena_type_impl< stan::math::matrix_cl< T > > | |
| Carena_type_impl< std::vector< T, Alloc > > | |
| Carena_type_impl< T, require_all_t< is_kernel_expression_and_not_scalar< T >, bool_constant<!is_matrix_cl< T >::value >, bool_constant<!is_arena_matrix_cl< T >::value > > > | |
| Carena_type_impl< T, require_all_t< std::is_trivially_destructible< T >, bool_constant<!is_eigen< T >::value > > > | |
| Carena_type_impl< T, require_eigen_t< T >, std::enable_if_t< T::RowsAtCompileTime !=Eigen::Dynamic &&T::ColsAtCompileTime !=Eigen::Dynamic > > | |
| Carena_type_impl< T, require_eigen_t< T >, std::enable_if_t< T::RowsAtCompileTime==Eigen::Dynamic||T::ColsAtCompileTime==Eigen::Dynamic > > | |
| Carena_type_impl< T, require_t< std::is_base_of< stan::math::chainable_alloc, T > > > | |
| Chas_eval | |
| Chas_eval< T, void_t< decltype(std::declval< std::decay_t< T > & >().eval())> > | |
| Chas_internal_trait | |
| Chas_internal_trait< T, std::void_t< Eigen::internal::traits< std::decay_t< T > > > > | |
| Chas_plain_object | |
| Chas_plain_object< T, void_t< typename std::decay_t< T >::PlainObject > > | |
| Chas_scalar_trait | |
| Chas_scalar_trait< T, std::void_t< typename std::decay_t< T >::Scalar > > | |
| Cis_arena_matrix_cl_impl | |
| Cis_arena_matrix_cl_impl< math::arena_matrix_cl< T > > | |
| Cis_arena_matrix_impl | |
| Cis_arena_matrix_impl< math::arena_matrix< T > > | |
| Cis_col_vector_impl | Underlying implementation for detecting if a Matrix is a column vector |
| Cis_col_vector_impl< T, false > | Specialization for when type is not a vector |
| Cis_complex_impl | Provides a member constant value which is equal to true if T is an instance of std::complex and false otherwise |
| Cis_complex_impl< std::complex< Ts... > > | |
| Cis_dense_dynamic_impl | |
| Cis_dense_dynamic_impl< T, require_t< is_eigen_dense_dynamic< std::decay_t< T > > > > | |
| Cis_dense_dynamic_impl< T, require_t< is_var< T > > > | |
| Cis_eigen_col_vector_impl | Underlying implementation for detecting if an Eigen Matrix is a column vector |
| Cis_eigen_col_vector_impl< T, false > | Specialization for when type is not an eigen vector |
| Cis_eigen_contiguous_map_impl | |
| Cis_eigen_contiguous_map_impl< Eigen::Map< T, Opts, Eigen::Stride< 0, 0 > > > | |
| Cis_eigen_matrix_dynamic_impl | Underlying implimenation to check if an Eigen matrix has rows or cols not equal to 1 |
| Cis_eigen_matrix_dynamic_impl< T, false > | |
| Cis_eigen_matrix_dynamic_impl< T, true > | |
| Cis_eigen_row_vector_impl | Underlying implementation for detecting if an Eigen Matrix is a row vector |
| Cis_eigen_row_vector_impl< T, false > | Specialization for when type is not an eigen vector |
| Cis_fvar_impl | |
| Cis_fvar_impl< math::fvar< T > > | |
| Cis_row_vector_impl | Underlying implementation for detecting if a Matrix is a row vector |
| Cis_row_vector_impl< T, false > | Specialization for when type is not an vector |
| Cis_std_vector_impl | This underlying implementation is used when the type is not an std vector |
| Cis_std_vector_impl< std::vector< Args... > > | This specialization implementation has a static member named value when the template type is an std vector |
| Cis_trivial_kg_expression | |
| Cis_trivial_kg_expression< double > | |
| Cis_trivial_kg_expression< int > | |
| Cis_trivial_kg_expression< math::as_column_vector_or_scalar_< T > > | |
| Cis_trivial_kg_expression< math::block_< T > > | |
| Cis_trivial_kg_expression< math::broadcast_< T, Colwise, Rowwise > > | |
| Cis_trivial_kg_expression< math::calc_if_< false, T > > | |
| Cis_trivial_kg_expression< math::calc_if_< true, T > > | |
| Cis_trivial_kg_expression< math::col_index > | |
| Cis_trivial_kg_expression< math::constant_< T > > | |
| Cis_trivial_kg_expression< math::holder_cl_< T > > | |
| Cis_trivial_kg_expression< math::load_< T > > | |
| Cis_trivial_kg_expression< math::matrix_cl< T > > | |
| Cis_trivial_kg_expression< math::optional_broadcast_< T, Colwise, Rowwise > > | |
| Cis_trivial_kg_expression< math::row_index > | |
| Cis_trivial_kg_expression< math::scalar_< T > > | |
| Cis_var_impl | |
| Cis_var_impl< math::var_value< T > > | |
| Cis_vari_impl | |
| Cis_vari_impl< math::vari_value< T > > | |
| Cis_vari_impl< math::vari_view< T > > | |
| Creturn_type_impl | |
| Creturn_type_impl< std::tuple< T... >, Ts... > | |
| Creturn_type_impl< T, Ts... > | |
| ►Nmath | Matrices and templated mathematical functions |
| ►Ninternal | A comparator that works for any container type that has the brackets operator |
| Carena_matrix_cl_impl | |
| Cassignment_op_str | |
| Cassignment_op_str< T, void_t< decltype(T::assignment_op)> > | |
| Cassignment_op_str_impl | |
| Cassignment_op_str_impl< assign_op_cl::divide_equals > | |
| Cassignment_op_str_impl< assign_op_cl::equals > | |
| Cassignment_op_str_impl< assign_op_cl::minus_equals > | |
| Cassignment_op_str_impl< assign_op_cl::multiply_equals > | |
| Cassignment_op_str_impl< assign_op_cl::plus_equals > | |
| Cbounded | |
| Cbounded< T_y, T_low, T_high, true > | |
| CBox | Compute the integral of the function to be integrated (integrand) from a to b for more than one dimensions |
| Cbroadcast_array | |
| Ccallback_vari | |
| Cchange_eigen_options_impl | Change the options of an Eigen matrix or array |
| Cchange_eigen_options_impl< Mat, NewOptions, require_eigen_array_t< Mat > > | |
| Cchange_eigen_options_impl< Mat, NewOptions, require_eigen_matrix_base_t< Mat > > | |
| Cchange_eigen_options_impl< var_value< Mat >, NewOptions, require_eigen_array_t< Mat > > | |
| Cchange_eigen_options_impl< var_value< Mat >, NewOptions, require_eigen_matrix_base_t< Mat > > | |
| Ccolwise_reduction_base | |
| Ccsr_adjoint | vari for csr_matrix_times_vector |
| Cdouble_d | |
| Cempty_broadcast_array | |
| Cempty_broadcast_array< ViewElt, T, require_eigen_t< T > > | |
| Cequal_profile_key | |
| Cfdim_dv_vari | |
| Cfdim_vd_vari | |
| Cfdim_vv_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 | |
| Chash_profile_key | |
| Cinc_beta_vvv_vari | |
| Cindex_comparator | |
| Cintegrate_ode_std_vector_interface_adapter | Wrap a functor designed for use with integrate_ode_bdf, integrate_ode_rk45, and integrate_ode_adams to use with the new ode_bdf/ode_rk45 interfaces |
| Cis_colwise_reduction_impl | |
| Cis_colwise_reduction_impl< calc_if_< true, T > > | |
| Cis_reduction_2d_impl | |
| Cis_reduction_2d_impl< calc_if_< true, T > > | |
| Cis_scalar_check_impl | |
| Cis_scalar_check_impl< check_cl_< scalar_< T > > > | |
| Cis_tuple_impl | |
| Cis_tuple_impl< std::tuple< Types... > > | |
| Cis_without_output_impl | |
| Cis_without_output_impl< calc_if_< false, T > > | |
| CIser | Apply an error check to a container, signal failure with false |
| Clambert_w0_fun | Structure to wrap lambert_w0() so it can be vectorized |
| Clambert_wm1_fun | Structure to wrap lambert_wm1() so it can be vectorized |
| Clbeta_dv_vari | |
| Clbeta_vd_vari | |
| Clbeta_vv_vari | |
| Clmgamma_dv_vari | |
| Clmultiply_dv_vari | |
| Clmultiply_vd_vari | |
| Clmultiply_vv_vari | |
| 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_vd_vari | |
| Clog_sum_exp_vv_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 > | |
| Cmatvec_mul_opt | Implementation of an optimization for usage of rowwise reduction in matrix-vector multiplication |
| Cmatvec_mul_opt< elt_multiply_< Mat, broadcast_< VecT, true, false > > > | |
| 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 | |
| Cmodified_bessel_first_kind_dv_vari | |
| Cmodified_bessel_second_kind_dv_vari | |
| Cmpi_parallel_call_cache | Container for locally cached data which is essentially implemented as singleton |
| Cmrrr_task | |
| ►Cmulti_result_kernel_internal | |
| Cinner | |
| ►Cmulti_result_kernel_internal<-1, T_results... > | |
| Cinner | |
| Cmultiply_log_dv_vari | |
| Cmultiply_log_vd_vari | |
| Cmultiply_log_vv_vari | |
| Cmultiply_vd_vari | |
| Cmultiply_vv_vari | |
| Cnonexisting_adjoint | |
| Copencl_code_impl | |
| Cops_partials_edge | An edge holds both the operands and its associated partial derivatives |
| Cops_partials_edge< double, Op, require_eigen_st< is_var, Op > > | |
| 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, std::vector< var_value< Op > >, require_eigen_t< Op > > | |
| Cops_partials_edge< double, var > | |
| Cops_partials_edge< double, var_value< Op >, require_eigen_t< Op > > | |
| Cops_partials_edge< double, var_value< Op >, require_kernel_expression_lhs_t< Op > > | |
| Cops_partials_edge< Dx, std::vector< Eigen::Matrix< fvar< Dx >, R, C > > > | |
| Cops_partials_edge< Dx, std::vector< std::vector< fvar< Dx > > > > | |
| Cops_partials_edge< Dx, ViewElt, require_eigen_vt< is_fvar, ViewElt > > | |
| Cops_partials_edge< InnerType, T, require_fvar_t< T > > | |
| Cops_partials_edge< InnerType, T, require_std_vector_vt< is_fvar, T > > | |
| Cops_partials_edge< ViewElt, Op, require_st_arithmetic< Op > > | Class representing an edge with an inner type of double |
| Cpartials_propagator | |
| Cpartials_propagator< ReturnType, require_arithmetic_t< ReturnType >, Ops... > | This template builds partial derivatives with respect to a set of operands |
| Cpartials_propagator< ReturnType, require_fvar_t< ReturnType >, Ops... > | This class builds partial derivatives with respect to a set of operands |
| Cpartials_propagator< ReturnType, require_var_t< ReturnType >, Ops... > | This class builds partial derivatives with respect to a set of operands |
| Cquad_form_vari | |
| Cquad_form_vari_alloc | |
| Creduce_sum_impl | Reduce_sum_impl implementation for any autodiff type |
| ►Creduce_sum_impl< ReduceFunction, require_arithmetic_t< ReturnType >, ReturnType, Vec, Args... > | Specialization of reduce_sum_impl for arithmetic types |
| Crecursive_reducer | This struct is used by the TBB to accumulate partial sums over consecutive ranges of the input |
| ►Creduce_sum_impl< ReduceFunction, require_var_t< ReturnType >, ReturnType, Vec, Args... > | Var specialization of reduce_sum_impl |
| Crecursive_reducer | This struct is used by the TBB to accumulate partial sums over consecutive ranges of the input |
| Cscoped_args_tuple | |
| Creduction_2d_base | |
| Creverse_pass_callback_vari | |
| Crising_factorial_vd_vari | |
| Csquared_distance_vd_vari | |
| Csquared_distance_vv_vari | |
| Ctrace_gen_quad_form_vari | |
| Ctrace_gen_quad_form_vari_alloc | |
| Ctrace_quad_form_vari | |
| Ctrace_quad_form_vari_alloc | |
| ►Nopencl_kernels | |
| ►Ninternal | |
| Cto_buffer | Kernel_executor_opencl |
| Cto_buffer< in_buffer > | |
| Cto_buffer< in_out_buffer > | |
| Cto_buffer< out_buffer > | |
| Ccumulative_sum | Struct containing cumulative_sum kernels, grouped by scalar type |
| Ccumulative_sum< double, T > | |
| Ccumulative_sum< int, T > | |
| Cin_buffer | An in_buffer signifies a cl::Buffer argument used as input |
| Cin_out_buffer | An in_out_buffer signifies a cl::Buffer argument used as both input and output |
| Ckernel_cl | Creates functor for kernels |
| Cout_buffer | An out_buffer signifies a cl::Buffer argument used as output |
| Csort_asc | Struct containing sort_asc kernels, grouped by scalar type |
| Csort_asc< double, T > | |
| Csort_asc< int, T > | |
| Csort_desc | Struct containing sort_desc kernels, grouped by scalar type |
| Csort_desc< double, T > | |
| Csort_desc< int, T > | |
| Cabs_fun | Return elementwise absolute value of the specified real-valued container |
| Caccumulator | Class to accumulate values and eventually return their sum |
| Caccumulator< T, require_fvar_t< T > > | Class to accumulate values and eventually return their sum |
| Caccumulator< T, require_var_t< T > > | Class to accumulate values and eventually return their sum |
| Cacos_ | |
| Cacos_fun | Structure to wrap acos() so it can be vectorized |
| Cacosh_ | |
| Cacosh_fun | Structure to wrap acosh() so it can be vectorized |
| Cad_promotable | If the type From can be converted to To using implicit conversions, or both From and To are possibly cv-qualified void), provides the member constant value equal to true |
| Cad_tape_observer | TBB observer object which is a callback hook called whenever the TBB scheduler adds a new thread to the TBB managed threadpool |
| Caddition_ | |
| Caddition_operator_ | |
| Cadjoint_results_cl | Represents results that are adjoints of vars in kernel generrator expressions |
| Cappend_col_ | Represents appending of cols in kernel generator expressions |
| 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 |
| Cappend_row_ | Represents appending of rows in kernel generator expressions |
| 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, fvar< T > > | Template specialization to fvar for vectorizing a unary scalar function |
| Capply_scalar_unary< F, std::vector< T > > | Template specialization for vectorized functions applying to standard vector containers |
| Capply_scalar_unary< F, T, require_complex_t< T > > | Template specialization for vectorized functions applying to complex arguments |
| Capply_scalar_unary< F, T, require_eigen_t< T > > | Template specialization for vectorized functions applying to Eigen matrix arguments |
| Capply_scalar_unary< F, T, require_floating_point_t< T > > | Template specialization for vectorized functions applying to double arguments |
| Capply_scalar_unary< F, T, require_integral_t< T > > | Template specialization for vectorized functions applying to integer arguments |
| Capply_scalar_unary< F, T, require_var_matrix_t< T > > | |
| Capply_scalar_unary< F, var > | Template specialization to var for vectorizing a unary scalar function |
| Capply_vector_unary | |
| Capply_vector_unary< T, require_eigen_t< T > > | Base template class for vectorization of unary vector functions defined by applying a functor to a standard library vector, Eigen dense matrix expression template, or container of these |
| Capply_vector_unary< T, require_std_vector_vt< is_container_or_var_matrix, T > > | Specialization for use with nested containers (std::vectors) |
| Capply_vector_unary< T, require_std_vector_vt< is_stan_scalar, T > > | Specialization for use with (non-nested) std::vectors |
| Capply_vector_unary< T, require_var_matrix_t< T > > | Specialization for use with var_value<T> types where T inherits from EigenBase |
| Carena_allocator | Std library compatible allocator that uses AD stack |
| Carena_matrix | Equivalent to Eigen::Matrix, except that the data is stored on AD stack |
| Carena_matrix< MatrixType, require_eigen_dense_base_t< MatrixType > > | |
| Carena_matrix< MatrixType, require_eigen_sparse_base_t< MatrixType > > | |
| Carena_matrix_cl | A variant of matrix_cl that schedules its destructor to be called, so it can be used on the AD stack |
| Carray_builder | Structure for building up arrays in an expression (rather than in statements) using an argument-chaining add() method and a getter method array() to return the result |
| Cas_column_vector_or_scalar_ | Represents as_column_vector_or_scalar of a row or column vector in kernel generator expressions |
| Casin_ | |
| Casin_fun | Structure to wrap asin() so it can be vectorized |
| Casinh_ | |
| Casinh_fun | Structure to wrap asinh() so it can be vectorized |
| Catan_ | |
| Catan_fun | Structure to wrap atan() so it can be vectorized |
| Catanh_ | |
| 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 | |
| Cbeta_ | |
| Cbinary_operation | Represents a binary operation in kernel generator expressions |
| Cbinomial_coefficient_log_ | |
| Cblock_ | Represents submatrix block in kernel generator expressions |
| Cbroadcast_ | Represents a broadcasting operation in kernel generator expressions |
| Ccalc_if_ | Represents a calc_if in kernel generator expressions |
| Ccast_ | Represents a typecast os scalar in kernel generator expressions |
| Ccbrt_ | |
| Ccbrt_fun | Structure to wrap cbrt() so it can be vectorized |
| Cceil_ | |
| 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 |
| Cchainable_object | chainable_object hold another object is useful for connecting the lifetime of a specific object to the chainable stack |
| Ccheck_cl_ | Represents a check in kernel generator expressions |
| Ccol_index | Represents operation that determines column index |
| Ccolwise_max_ | Represents column wise max - reduction in kernel generator expressions |
| Ccolwise_min_ | Represents column wise min - reduction in kernel generator expressions |
| Ccolwise_prod_ | Represents column wise product - reduction in kernel generator expressions |
| Ccolwise_reduction | Represents a column wise reduction in kernel generator expressions |
| Ccolwise_sum_ | Represents column wise sum - reduction in kernel generator expressions |
| Ccomplex_base | Base class for complex numbers |
| Cconjunction | Extends std::true_type when instantiated with zero or more template parameters, all of which extend the std::true_type |
| Cconjunction< T, Ts... > | |
| Cconstant_ | Represents a matrix of single repeated value in kernel generator expressions |
| Ccopysign_ | |
| Ccos_ | |
| Ccos_fun | Structure to wrap cos() so it can be vectorized |
| Ccosh_ | |
| Ccosh_fun | Structure to wrap cosh() so it can be vectorized |
| Ccoupled_ode_system | |
| Ccoupled_ode_system_impl | |
| Ccoupled_ode_system_impl< false, F, T_y0, Args... > | The coupled_ode_system_impl template specialization when the state or parameters are autodiff types |
| Ccoupled_ode_system_impl< true, F, T_y0, Args... > | The coupled_ode_system_impl for arithmetic arguments reduces to the regular ode system (there are no sensitivities) |
| 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_integrator_adjoint_vari | Integrator interface for CVODES' adjoint ODE solvers (Adams & BDF methods) |
| Ccvodes_solver | Since the CVODES solver manages memory with malloc calls, these resources must be freed using a destructor call (which is not being called for the vari class) |
| Cdae_system | IDAS DAE system that contains information on residual equation functor, sensitivity residual equation functor, as well as initial conditions |
| Cdeserializer | A class to store a sequence of values which can be deserialized back into structured objects such as scalars, vectors, and matrices |
| Cdiagonal_ | Represents diagonal of a matrix (as column vector) in kernel generator expressions |
| Cdigamma_ | |
| 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... > | |
| Celt_divide_ | |
| Celt_function_cl | Represents an element-wise function in kernel generator expressions |
| Celt_modulo_ | |
| Celt_multiply_ | |
| Cequals_ | |
| Cerf_ | |
| Cerf_fun | Structure to wrap erf() so it can be vectorized |
| Cerfc_ | |
| Cerfc_fun | Structure to wrap the erfc() so that it can be vectorized |
| Cexp2_ | |
| Cexp2_fun | Structure to wrap exp2() so it can be vectorized |
| Cexp_ | |
| Cexp_fun | Structure to wrap exp() so that it can be vectorized |
| Cexpm1_ | |
| Cexpm1_fun | Structure to wrap expm1() so that it can be vectorized |
| Cexpressions_cl | Represents multiple expressions that will be calculated in same kernel |
| Cfabs_ | |
| Cfabs_fun | Structure to wrap fabs() so that it can be vectorized |
| Cfdim_ | |
| CFixedPointADJac | Calculate Jacobian Jxy(Jacobian of unknown x w.r.t |
| CFixedPointSolver | Fixed point solver for problem of form |
| CFixedPointSolver< KinsolFixedPointEnv< F >, fp_jac_type > | Specialization for fixed point solver when using KINSOL |
| Cfloor_ | |
| Cfloor_fun | Structure to wrap floor() so that it can be vectorized |
| Cfmax_ | |
| Cfmin_ | |
| Cfmod_ | |
| 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 | |
| Cgreater_than_ | |
| Cgreater_than_or_equal_ | |
| CHolder | A no-op Eigen operation |
| Cholder_cl_ | Represents a no-op in kernel generator expressions |
| Chybrj_functor_solver | A functor with the required operators to call Eigen's algebraic solver |
| Chypot_ | |
| Cidas_integrator | IDAS DAE integrator |
| Cidas_service | For each type of Ode(with different rhs functor F and senstivity parameters), we allocate mem and workspace for idas |
| Cinclude_summand | Template metaprogram to calculate whether a summand needs to be included in a proportional (log) probability calculation |
| Cinclude_summand< propto, T > | true if a term with the specified propto value and subterm types should be included in a proportionality calculation |
| Cindex_type | Primary template class for the metaprogram to compute the index type of a container |
| Cindex_type< T, require_eigen_t< T > > | Template metaprogram defining typedef for the type of index for an Eigen matrix, vector, or row vector |
| Cindex_type< T, require_std_vector_t< T > > | Template metaprogram class to compute the type of index for a standard vector |
| Cindex_type< T, std::enable_if_t< std::is_pointer< T >::value > > | Specialization of index_type for pointers |
| Cindexing_ | Represents indexing of a matrix with two matrices of indices |
| Cinv_cloglog_fun | Structure to wrap inv_cloglog() so that it can be vectorized |
| Cinv_erfc_fun | Structure to wrap the inv_erfc() function so that it can be vectorized |
| Cinv_fun | Structure to wrap 1.0 / x so that it can be vectorized |
| Cinv_logit_ | |
| Cinv_logit_fun | Structure to wrap inv_logit() so that it can be vectorized |
| Cinv_Phi_ | |
| Cinv_Phi_fun | Structure to wrap inv_Phi() so it can be vectorized |
| Cinv_sqrt_fun | Structure to wrap 1 / sqrt(x) so that it can be vectorized |
| Cinv_square_ | |
| Cis_tuple | |
| Cisfinite_ | |
| Cisinf_ | |
| Cisnan_ | |
| Ckernel_parts | Parts of an OpenCL kernel, generated by an expression |
| Ckinsol_system_data | KINSOL algebraic system data holder |
| CKinsolFixedPointEnv | KINSOL algebraic system data holder that handles construction & destruction of SUNDIALS data, as well as auxiliary data that will be used for functor evaluation |
| Clbeta_ | |
| Cldexp_ | |
| CLDLT_factor | LDLT_factor is a structure that holds a matrix of type T and the LDLT of its values |
| CLDLT_factor< T, require_eigen_matrix_dynamic_vt< is_var, T > > | An LDLT_factor of an Eigen::Matrix<var, Eigen::Dynamic, Eigen::Dynamic> with alloc_in_arena = True holds a copy of the input matrix and the LDLT of its values, with all member variable allocations are done in the arena |
| CLDLT_factor< T, require_var_matrix_t< T > > | An LDLT_factor of a var_value<Eigen::MatrixXd> holds a copy of the input var_value and the LDLT of its values |
| CLDLT_factor< T, std::enable_if_t< bool_constant< is_eigen_matrix_dynamic< T >::value &&!is_var< scalar_type_t< T > >::value >::value > > | An LDLT_factor is a structure that holds a matrix of type T and the LDLT of its values |
| Cless_than_ | |
| Cless_than_or_equal_ | |
| Clgamma_ | |
| Clgamma_fun | Structure to wrap lgamma() so that it can be vectorized |
| Clmultiply_ | |
| Cload_ | Represents an access to a matrix_cl in kernel generator expressions |
| Clog10_ | |
| Clog10_fun | Structure to wrap log10() so it can be vectorized |
| Clog1m_ | |
| Clog1m_exp_ | |
| 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_ | |
| Clog1m_inv_logit_fun | Structure to wrap log1m_inv_logit() so it can be vectorized |
| Clog1p_ | |
| Clog1p_exp_ | |
| Clog1p_exp_fun | Structure to wrap log1p_exp() so that it can be vectorized |
| Clog1p_fun | Structure to wrap log1p() so it can be vectorized |
| Clog2_ | |
| Clog2_fun | Structure to wrap log2() so it can be vectorized |
| Clog_ | |
| Clog_diff_exp_ | |
| Clog_fun | Structure to wrap log() so that it can be vectorized |
| Clog_inv_logit_ | |
| Clog_inv_logit_diff_ | |
| Clog_inv_logit_fun | Structure to wrap log_inv_logit() so it can be vectorized |
| Clogical_and_ | |
| Clogical_negation_ | Represents a logical negation in kernel generator expressions |
| Clogical_or_ | |
| Clogit_ | |
| Clogit_fun | Structure to wrap logit() so it can be vectorized |
| Cmatrix_cl | Represents an arithmetic matrix on the OpenCL device |
| Cmatrix_cl_base | Non-templated base class for matrix_cl simplifies checking if something is matrix_cl |
| Cmatrix_exp_action_handler | The implementation of the work by Awad H |
| Cmax_2d_ | Represents two dimensional max - reduction in kernel generator expressions |
| Cmax_op | Operation for max reduction |
| Cmin_2d_ | Represents two dimensional min - reduction in kernel generator expressions |
| Cmin_op | Operation for min reduction |
| Cmpi_cluster | MPI cluster holds MPI resources and must be initialized only once in any MPI program |
| Cmpi_command | A MPI command object is used to execute code on worker nodes |
| Cmpi_distributed_apply | MPI command template which calls the static method distributed_apply of the given class F |
| Cmpi_is_in_use | Exception thrown whenever the MPI resource is busy |
| Cmpi_parallel_call | The MPI parallel call class manages the distributed evaluation of a collection of tasks following the map - reduce - combine pattern |
| Cmpi_stop_listen | Exception used to stop workers nodes from further listening to commands send from the root |
| Cmpi_stop_worker | MPI command used to stop childs nodes from listening for further commands |
| Cmultiply_log_ | |
| Cname_generator | Unique name generator for variables used in generated kernels |
| Cnested_rev_autodiff | A class following the RAII idiom to start and recover nested autodiff scopes |
| Cnlo_functor | A structure which gets passed to Eigen's dogleg algebraic solver |
| Cnot_equals_ | |
| 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_code_ | Represents custom code in kernel generator expressions |
| Copencl_code_output | Represents output variable of custom code in kernel generator expressions |
| 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, Op6, Op7, Op8, fvar< Dx > > | This class builds partial derivatives with respect to a set of operands |
| Coperands_and_partials< Op1, Op2, Op3, Op4, Op5, Op6, Op7, Op8, var > | This class builds partial derivatives with respect to a set of operands |
| Coperation_cl | Base for all kernel generator operations |
| Coperation_cl_lhs | Base for all kernel generator operations that can be used on left hand side of an expression |
| Coptional_broadcast_ | Represents an optional broadcasting operation in kernel generator expressions |
| Cpass_type | |
| Cpass_type< double > | |
| Cpass_type< int > | |
| CPhi_ | |
| CPhi_approx_ | |
| CPhi_approx_fun | Structure to wrap Phi_approx() so it can be vectorized |
| CPhi_fun | Structure to wrap Phi() so it can be vectorized |
| Cpinned_matrix | Equivalent to Eigen::Matrix, except that the data is stored in (hopefully pinned) memory, allocated by OpenCL driver |
| Cpow_ | |
| Cprecomp_vv_vari | |
| Cprecomp_vvv_vari | |
| Cprecomputed_gradients_vari_template | A variable implementation taking a sequence of operands and partial derivatives with respect to the operands |
| Cprod_2d_ | Represents two dimensional product - reduction in kernel generator expressions |
| Cprod_op | Operation for product reduction |
| Cprofile | Profiles C++ lines where the object is in scope |
| Cprofile_info | Class used for storing profiling information |
| 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_type | Template metaprogram to calculate a type for converting a convertible type |
| Cpromote_scalar_type< std::tuple< PromotionScalars... >, std::tuple< UnPromotedTypes... > > | |
| Cpromote_scalar_type< T, S, require_all_t< is_var< T >, is_var< S >, is_eigen< value_type_t< S > > > > | Specialization for var_value when the type to convert to is a var_value |
| Cpromote_scalar_type< T, S, require_all_t< std::is_arithmetic< T >, is_var< S >, is_eigen< value_type_t< S > > > > | Specialization for var_value when the type to convert to is arithmetic |
| Cpromote_scalar_type< T, S, require_eigen_dense_base_t< S > > | Template metaprogram to calculate a type for a matrix, vector, row vector or Eigen::Array whose underlying scalar is converted from the second template parameter type to the first |
| Cpromote_scalar_type< T, S, require_eigen_sparse_base_t< S > > | |
| 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 |
| Cread_fvar_functor | Functor for extracting the values and tangents from a matrix of fvar |
| Creduction_2d | Represents a two dimensional reduction in kernel generator expressions |
| Cref_type_for_opencl | Determines appropriate type for assigning expression of given type to, so that the resulting type has directly accessible contiguous colum-major data, which is needed to copy to OpenCL device for construction of matrix_cl |
| Cref_type_for_opencl< T, require_arena_matrix_t< T > > | |
| Cref_type_for_opencl< T, require_not_eigen_t< T > > | |
| Cresults_cl | Represents results that will be calculated in same kernel |
| Cround_ | |
| Cround_fun | Structure to wrap round() so it can be vectorized |
| Crow_index | Represents operation that determines row index |
| Crowwise_max_ | Represents rowwise max reduction in kernel generator expressions |
| Crowwise_min_ | Represents rowwise min reduction in kernel generator expressions |
| Crowwise_prod_ | Represents rowwise product reduction in kernel generator expressions |
| Crowwise_reduction | Represents a rowwise reduction in kernel generator expressions |
| Crowwise_sum_ | Represents rowwise sum reduction in kernel generator expressions |
| Crsqrt_ | |
| Cscalar_ | Represents a scalar in kernel generator expressions |
| ►CScopedChainableStack | The AD tape of reverse mode AD is by default stored globally within the process (or thread) |
| Cactivate_scope | |
| Cselect_ | Represents a selection operation in kernel generator expressions |
| 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 > > | |
| Cserializer | A structure to serialize structures to an internal stored sequence of scalars |
| Csign_fun | Structure to wrap sign() so it can be vectorized |
| Csin_ | |
| Csin_fun | Structure to wrap sin() so it can be vectorized |
| Csinh_ | |
| Csinh_fun | Structure to wrap sinh() so that it can be vectorized |
| Csqrt_ | |
| Csqrt_fun | Structure to wrap sqrt() so that it can be vectorized |
| Csquare_ | |
| 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 |
| Cstd_normal_log_qf_fun | Structure to wrap std_normal_log_qf() so it can be vectorized |
| Cstep_fun | Structure to wrap step() so it can be vectorized |
| 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 autodiff memory stack |
| Csubtraction_ | |
| Csubtraction_operator_ | |
| Csum_2d_ | Represents two dimensional sum - reduction in kernel generator expressions |
| Csum_op | Operation for sum reduction |
| Ctan_ | |
| Ctan_fun | Structure to wrap tan() so that it can be vectorized |
| Ctanh_ | |
| Ctanh_fun | Structure to wrap tanh() so that it can be vectorized |
| Ctgamma_ | |
| Ctgamma_fun | Structure to wrap tgamma() so that it can be vectorized |
| Cto_int_fun | Return elementwise integer value of the specified real-valued container |
| Ctranspose_ | Represents a transpose in kernel generator expressions |
| Ctrigamma_ | |
| Ctrigamma_fun | Structure to wrap trigamma() so it can be vectorized |
| Ctrunc_ | |
| Ctrunc_fun | Structure to wrap trunc() so it can be vectorized |
| Cunary_minus_ | Represents an unary minus operation in kernel generator expressions |
| Cunary_operation_cl | Represents a unary operation in kernel generator expressions |
| Cunsafe_chainable_object | unsafe_chainable_object hold another object and is useful for connecting the lifetime of a specific object to the chainable stack |
| Cval_adj_functor | Functor for extracting the values and adjoints from a matrix of var or vari |
| Cvar_value | |
| Cvar_value< T, internal::require_matrix_var_value< T > > | Independent (input) and dependent (output) variables for gradients |
| Cvar_value< T, require_floating_point_t< T > > | Independent (input) and dependent (output) variables for gradients |
| Cvari_base | Abstract base class that all vari_value and it's derived classes inherit |
| Cvari_cl_base | |
| Cvari_value | |
| Cvari_value< T, require_all_t< is_plain_type< T >, is_eigen_dense_base< T > > > | The variable implementation for Eigen dense matrix types |
| Cvari_value< T, require_eigen_sparse_base_t< T > > | The variable implementation for Eigen sparse matrix types |
| Cvari_value< T, require_matrix_cl_t< T > > | The variable implementation for matrix_cl |
| Cvari_value< T, require_t< std::is_floating_point< T > > > | The variable implementation for floating point types |
| Cvari_view | A vari_view is used to read from a slice of a vari_value with an inner eigen type |
| Cvari_view< T, require_all_t< is_eigen< T >, bool_constant<!is_plain_type< T >::value > > > | |
| Cvari_view< T, require_kernel_expression_lhs_t< T > > | |
| Cvari_view_eigen | This struct is follows the CRTP for methods common to vari_view<> and vari_value<Matrix> |
| Cvi_adj_functor | Functor for extracting the varis and adjoints from a matrix of var |
| Cvi_val_adj_functor | Functor for extracting the vari*, values, and adjoints from a matrix of var |
| Cvi_val_functor | Functor for extracting the varis and values from a matrix of var |
| Cwelford_covar_estimator | |
| Cwelford_var_estimator | |
| Cbase_type | Metaprogram structure to determine the base base type of a template argument |
| Cbase_type< T, std::enable_if_t< is_complex< T >::value > > | Template metaprogram defining the base type for values stored in a complex number |
| Cbase_type< T, std::enable_if_t< is_eigen< T >::value > > | Template metaprogram defining the base base type of values stored in an Eigen matrix |
| Cbase_type< T, std::enable_if_t< is_std_vector< T >::value > > | Specialization of base_type for vector to recursively return the inner base type |
| Cconditional_var_value | Conditionally construct a var_value container based on a scalar type |
| Cconditional_var_value< T_scalar, T_container, require_std_vector_t< T_container > > | |
| Cerror_index | |
| Ceval_return_type | Determines return type of calling |
| Cis_any_var_matrix | Check if any types in a parameter pack are a var_value whose value_type is derived from Eigen::EigenBase |
| Cis_arena_matrix | Defines a static member named value which is defined to be true if the type is arena_matrix<T> |
| Cis_arena_matrix< T, require_t< internal::is_arena_matrix_impl< std::decay_t< T > > > > | Defines a static member named value which is defined to be true if the type is arena_matrix<T> |
| Cis_arena_matrix_cl | |
| Cis_autodiff | Checks if decayed type is a var or fvar |
| Cis_base_pointer_convertible | Checks if a type's pointer is convertible to a templated base type's pointer |
| Cis_col_vector | If the input type T has a static comple time constant type ColsAtCompileTime equal to 1 this has a static member with a value of true |
| Cis_complex | If T is a complex type (that is, an instance of std::complex) or a cv-qualified version thereof, provides the member constant value equal true; for any other type the value is false |
| Cis_complex< T, std::enable_if_t< internal::is_complex_impl< std::decay_t< T > >::value > > | |
| Cis_complex_ad | If T is a complex type with an inner autodiff type (that is, an instance of std::complex<var> or std::complex<fvar<T>>) or a cv-qualified version thereof, provides the member constant value equal true; for any other type the value is false |
| Cis_complex_ad< T, std::enable_if_t< stan::math::conjunction< is_autodiff< base_type_t< T > >, internal::is_complex_impl< std::decay_t< T > > >::value > > | |
| Cis_complex_arithmetic | If T is a complex type with an inner arithmetic type (that is, an instance of std::complex<Arithmetic>) or a cv-qualified version thereof, provides the member constant value equal true; for any other type the value is false |
| Cis_complex_arithmetic< T, std::enable_if_t< stan::math::conjunction< std::is_arithmetic< base_type_t< T > >, internal::is_complex_impl< std::decay_t< T > > >::value > > | |
| Cis_constant | Metaprogramming struct to detect whether a given type is constant in the mathematical sense (not the C++ const sense) |
| Cis_constant< T, require_all_kernel_expressions_and_none_scalar_t< T > > | Defines a static member named value and sets it to true if the type of the elements in the provided matrix_cl is constant, false otherwise |
| Cis_constant< T, require_eigen_t< T > > | 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< T, require_std_vector_t< T > > | Defines a static member named value and sets it to true if the type of the elements in the provided std::vector is constant, false otherwise |
| Cis_detected | |
| Cis_detected< T, Op, void_t< Op< T > > > | Checks whether a valid type is detected |
| Cis_double_or_int | Checks if decayed type is a double or integer |
| Cis_eigen | Check if type derives from EigenBase |
| Cis_eigen_array | Check if a type is derived from Eigen::ArrayBase |
| Cis_eigen_col_vector | If the input type T is an eigen matrix with 1 row at compile time this has a static member with a value of true |
| Cis_eigen_contiguous_map | Check if a type is an Eigen::Map with contiguous stride |
| Cis_eigen_dense_base | Checks whether type T is derived from Eigen::DenseBase |
| Cis_eigen_matrix_base | Checks whether type T is derived from Eigen::MatrixBase |
| Cis_eigen_matrix_dynamic | Checks whether type T is derived from Eigen::MatrixBase and has columns and rows not equal to 1 |
| Cis_eigen_row_vector | If the input type T is an eigen matrix with 1 column at compile time this has a static member with a value of true |
| Cis_eigen_sparse_base | Checks whether type T is derived from Eigen::SparseMatrixBase |
| Cis_eigen_vector | If the input type T is an eigen matrix with 1 column or 1 row at compile time this has a static member with a value of true |
| Cis_fvar | Defines a static member function type which is defined to be false as the primitive scalar types cannot be a stan::math::fvar type |
| Cis_fvar< T, std::enable_if_t< internal::is_fvar_impl< std::decay_t< T > >::value > > | |
| Cis_kernel_expression | Determines whether a type is is a valid kernel generator expression |
| Cis_kernel_expression_and_not_scalar | Determines whether a type is non-scalar type that is a valid kernel generator expression |
| Cis_kernel_expression_and_not_scalar< T, require_matrix_cl_t< T > > | |
| Cis_kernel_expression_lhs | Determines whether a type is an assignable kernel generator expression |
| Cis_kernel_expression_lhs< T, require_matrix_cl_t< T > > | |
| Cis_matrix | Check if a type is derived from Eigen::EigenBase or is a var_value whose value_type is derived from Eigen::EigenBase |
| Cis_matrix_cl | Checks if the decayed type of T is a matrix_cl |
| Cis_nonscalar_prim_or_rev_kernel_expression | Determines whether a type is either a non-scalar kernel generator expression or a var containing a non-scalar kernel generator expression |
| Cis_prim_or_rev_kernel_expression | Determines whether a type is either a kernel generator expression or a var containing a kernel generator expression |
| Cis_real | Checks if decayed type is a var, fvar, or arithmetic |
| Cis_rev_col_vector | Defines a static member named value which is defined to be true if the type is either derived from Eigen::EigenBase with a Scalar type of var_value<double> or a var_value<T> where T is derived from Eigen::EigenBase |
| Cis_rev_col_vector< T, require_all_t< is_var< scalar_type_t< T > >, math::disjunction< is_eigen_col_vector< T >, is_eigen_col_vector< value_type_t< T > > > > > | Defines a static member named value which is defined to be true if the type is either a type derived from Eigen::EigenBase with a Scalar type of var_value<double> or a var_value<T> where T is derived from Eigen::EigenBase |
| Cis_rev_kernel_expression | Determines whether a type is a var containing a kernel generator expression |
| Cis_rev_matrix | Defines a static member named value which is defined to be true if the type is either a type derived from Eigen::EigenBase with a Scalar type of var_value<double> or a var_value<T> where T is derived from Eigen::EigenBase |
| Cis_rev_matrix< T, require_all_t< is_var< scalar_type_t< T > >, math::disjunction< math::conjunction< is_var< T >, is_eigen< value_type_t< T > > >, is_eigen< T > > > > | Defines a static member named value which is defined to be true if the type is either a type derived from Eigen::EigenBase with a Scalar type of var_value<double> or a var_value<T> where T is derived from Eigen::EigenBase |
| Cis_rev_row_vector | Defines a static member named value which is defined to be true if the type is either a type derived from Eigen::EigenBase with a Scalar type of var_value<double> or a var_value<T> where T is derived from Eigen::EigenBase |
| Cis_rev_row_vector< T, require_all_t< is_var< scalar_type_t< T > >, math::disjunction< is_eigen_row_vector< T >, is_eigen_row_vector< value_type_t< T > > > > > | Defines a static member named value which is defined to be true if the type is either a type derived from Eigen::EigenBase with a Scalar type of var_value<double> or a var_value<T> where T is derived from Eigen::EigenBase |
| Cis_rev_vector | Defines a static member named value which is defined to be true if the type is either a type derived from Eigen::EigenBase with a Scalar type of var_value<double> or a var_value<T> where T is derived from Eigen::EigenBase |
| Cis_rev_vector< T, require_any_t< is_rev_col_vector< T >, is_rev_row_vector< T > > > | Defines a static member named value which is defined to be true if the type is either a type derived from Eigen::EigenBase with a Scalar type of var_value<double> or a var_value<T> where T is derived from Eigen::EigenBase |
| Cis_row_vector | If the input type T has a static comple time constant type RowsAtCompileTime equal to 1 this has a static member with a value of true |
| Cis_stan_scalar | Checks if decayed type is a var, fvar, or arithmetic |
| Cis_std_vector | Base implementation for checking if type is std vector |
| Cis_std_vector< T, std::enable_if_t< internal::is_std_vector_impl< std::decay_t< T > >::value > > | Checks if the decayed type of T is a standard vector |
| Cis_var | Defines a static member named value which is defined to be false as the primitive scalar types cannot be a stan::math::var type |
| Cis_var< T, std::enable_if_t< internal::is_var_impl< std::decay_t< T > >::value > > | Specialization for checking if value of T minus cv qualifier is a var_value |
| Cis_var_col_vector | Check if a type is a var_value whose value_type is derived from Eigen::EigenBase |
| Cis_var_dense_dynamic | Check if a type is a var_value whose value_type is derived from Eigen::EigenBase and has dynamic rows and columns |
| Cis_var_eigen | Check if a type is a var_value whose value_type is derived from Eigen::EigenBase |
| Cis_var_matrix | Check if a type is a var_value whose value_type is derived from Eigen::EigenBase |
| Cis_var_or_arithmetic_type | Defines a static member value which is defined to be true (1) if the unqualified cv of type T or its underlying type (if a container) is either var or an arithmetic type, and false (0) otherwise |
| Cis_var_row_vector | Check if a type is a var_value whose value_type is derived from Eigen::EigenBase |
| Cis_var_vector | Check if a type is a var_value whose value_type is derived from Eigen::EigenBase |
| Cis_vari | Specialization for checking if value of T minus cv qualifier and pointer is a vari |
| Cis_vari< T, require_t< internal::is_vari_impl< std::decay_t< T > > > > | Specialization for checking if value of T minus cv qualifier and pointer is a vari_value |
| Cis_vector | If the input type T is either an eigen matrix with 1 column or 1 row at compile time or a standard vector, this has a static member with a value of true |
| Cis_vector_like | Template metaprogram indicates whether a type is vector_like |
| Cis_vt_complex | If the value_type of the type T is of type std::complex or a cv-qualified version thereof, provides the member constant value equal true; for any other type the value is false |
| Cis_vt_not_complex | If the value_type of the type T is not of type std::complex or a cv-qualified version thereof, provides the member constant value equal true; for any other type the value is false |
| Cmake_void | |
| Coperation_cl_base | Non-templated base of operation_cl is needed for easy checking if something is a subclass of operation_cl |
| Coperation_cl_lhs_base | Non-templated base of operation_cl_lhs is needed for easy checking if something is a subclass of operation_cl_lhs |
| 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 | This base implementation will contain a static member function named type equal to the type passed into it |
| Cpartials_type< T, require_fvar_t< T > > | |
| Cpartials_type< T, require_var_t< T > > | Specialization of partials type returns double if input type is a double |
| Cplain_type | Determines plain (non expression) type associated with T |
| Cplain_type< T, require_all_kernel_expressions_and_none_scalar_t< T > > | Determines plain (non expression) type associated with T |
| Cplain_type< T, require_t< bool_constant< internal::has_eval< T >::value &&is_eigen< T >::value > > > | Determines plain (non expression) type associated with T |
| Cplain_type< T, require_t< bool_constant<!internal::has_eval< T >::value &&internal::has_plain_object< T >::value &&is_eigen< T >::value > > > | |
| Cplain_type< T, require_t< stan::math::conjunction< is_var< T >, is_eigen< value_type_t< T > > > > > | Determines plain (non expression) type associated with T |
| Creal_return | Provides a member type alias named type, the value of which is the least type under Stan's assignability relation that can be assigned a double and all of the base types of the specified arguments after removing qualifiers (const and volatile) and decaying (lvalue to rvalue by removing references) and array to pointer) |
| Creal_return< T, Ts... > | |
| Cref_type_if | If the condition is true determines appropriate type for assigning expression of given type to, to evaluate expensive expressions, but not make a copy if T involves no calculations |
| Cref_type_if< Condition, T, require_all_kernel_expressions_t< T > > | |
| Cref_type_if< Condition, T, require_all_t< is_eigen< T >, bool_constant<!is_arena_matrix< T >::value > > > | |
| Cref_type_if< Condition, T, require_arena_matrix_t< T > > | |
| Creturn_type | Template metaprogram to calculate the base scalar return type resulting from promoting all the scalar types of the template parameters to the least type to which all the base types of the arguments are assignable |
| Crev_matrix_type | Determines a return type for a function that accepts given inputs and wants to return a matrix (or vector or row vector) with given compile time number of rows and columns |
| Cscalar_lub | Defines a member type named type that is the least scalar type to which both template parameter scalar types are assignable in Stan |
| Cscalar_lub< std::complex< T1 >, std::complex< T2 > > | |
| Cscalar_lub< std::complex< T1 >, T2 > | |
| Cscalar_lub< T1, std::complex< T2 > > | |
| Cscalar_seq_view | Scalar_seq_view provides a uniform sequence-like wrapper around either a scalar or a sequence of scalars |
| Cscalar_seq_view< C, require_eigen_vector_t< C > > | |
| Cscalar_seq_view< C, require_stan_scalar_t< C > > | This specialization handles wrapping a scalar as if it were a sequence |
| Cscalar_seq_view< C, require_std_vector_t< C > > | |
| Cscalar_seq_view< C, require_t< std::is_pointer< C > > > | |
| Cscalar_seq_view< C, require_var_matrix_t< C > > | |
| Cscalar_type | Metaprogram structure to determine the base scalar type of a template argument |
| Cscalar_type< T, require_all_kernel_expressions_and_none_scalar_t< T > > | Return the scalar type of an OpenCL matrix |
| Cscalar_type< T, std::enable_if_t< is_complex< T >::value > > | Template metaprogram defining the scalar type for values stored in a complex number |
| Cscalar_type< T, std::enable_if_t< is_eigen< T >::value &&!internal::has_scalar_trait< T >::value > > | Template metaprogram defining the base scalar type of values stored in an Eigen matrix |
| Cscalar_type< T, std::enable_if_t< is_eigen< T >::value &&internal::has_scalar_trait< T >::value > > | Template metaprogram defining the base scalar type of values stored in an Eigen matrix |
| Cscalar_type< T, std::enable_if_t< is_std_vector< T >::value > > | Specialization of scalar_type for vector to recursively return the inner scalar type |
| Cscalar_type< T, std::enable_if_t< is_var< T >::value > > | Template specialization defining the scalar type of values stored in var_value |
| CStdVectorBuilder | StdVectorBuilder allocates type T1 values to be used as intermediate values |
| Cvalue_type | Primary template class for metaprogram to compute the type of values stored in a container |
| Cvalue_type< T, require_all_kernel_expressions_and_none_scalar_t< T > > | Return the value type of an OpenCL matrix |
| Cvalue_type< T, require_t< is_vari< T > > > | |
| Cvalue_type< T, std::enable_if_t< is_eigen< T >::value &&!internal::has_scalar_trait< T >::value > > | Template metaprogram defining the type of values stored in an Eigen matrix, vector, or row vector |
| Cvalue_type< T, std::enable_if_t< is_eigen< T >::value &&internal::has_scalar_trait< T >::value > > | Template metaprogram defining the type of values stored in an Eigen matrix, vector, or row vector |
| Cvalue_type< T, std::enable_if_t< is_std_vector< T >::value > > | Template metaprogram class to compute the type of values stored in a standard vector |
| Cvalue_type< T, std::enable_if_t< is_var< T >::value > > | |
| Cvalue_type< T, std::enable_if_t< std::is_pointer< T >::value > > | Specialization for pointers returns the underlying value the pointer is pointing to |
| 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< T, require_matrix_t< T > > | This class provides a low-cost wrapper for situations where you either need an Eigen Vector or RowVector or a std::vector of them and you want to be agnostic between those two options |
| Cvector_seq_view< T, require_std_vector_vt< internal::is_matrix_or_std_vector, T > > | This class provides a low-cost wrapper for situations where you either need an Eigen Vector or RowVector or a std::vector of them and you want to be agnostic between those two options |
| 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 | STL namespace |
| Ccomplex< stan::math::fvar< T > > | Specialization of the standard library complex number type for reverse-mode autodiff type stan::math::fvar<T> |
| Ccomplex< stan::math::var > | Specialization of the standard library complex number type for reverse-mode autodiff type stan::math::var |
| Citerator_traits< stan::math::fvar< T > > | Specialization of iterator traits for Stan math |
| Citerator_traits< stan::math::var_value< Iter > > | Specialization of iterator traits for Stan math |
| Cnumeric_limits< stan::math::fvar< T > > | |
| Cnumeric_limits< stan::math::var_value< T > > | Specialization of numeric limits for var objects |
| Calgebra_solver_adapter | Adapt the non-variadic algebra_solver_newton and algebra_solver_powell arguemts to the variadic algebra_solver_newton_impl and algebra_solver_powell_impl interfaces |
| Cbool_constant | |
| Cdouble_d | Double double - a 128 bit floating point number defined as an exact sum of 2 doubles |
| Cevaluator_base | |
| CGenericNumTraits | |
| Cintegrate_1d_adapter | Adapt the non-variadic integrate_1d arguments to the variadic integrate_1d_impl interface |