![]() |
Stan Math Library
2.15.0
reverse mode automatic differentiation
|
Cstan::math::accumulator< T > | Class to accumulate values and eventually return their sum |
Cstan::math::acos_fun | Structure to wrap acos() so it can be vectorized |
Cstan::math::acosh_fun | Structure to wrap acosh() so it can be vectorized |
Cstan::math::ad_promotable< V, T > | Template traits metaprogram to determine if a variable of one template type can be promoted to a second target template type |
Cstan::math::ad_promotable< bool, double > | A blool may be promoted to a double |
Cstan::math::ad_promotable< char, double > | A char may be promoted to a double |
Cstan::math::ad_promotable< double, double > | A double may be promoted to a double |
Cstan::math::ad_promotable< float, double > | A float may be promoted to a double |
Cstan::math::ad_promotable< int, double > | An int may be promoted to a double |
Cstan::math::ad_promotable< long double, double > | A long double may be promoted to a double |
Cstan::math::ad_promotable< long, double > | A long may be promoted to a double |
Cstan::math::ad_promotable< short, double > | A short may be promoted to a double |
Cstan::math::ad_promotable< T, T > | Any type may be promoted to itself |
Cstan::math::ad_promotable< T, var > | |
Cstan::math::ad_promotable< unsigned char, double > | An unsigned char may be promoted to a double |
Cstan::math::ad_promotable< unsigned int, double > | An unsigned int may be promoted to a double |
Cstan::math::ad_promotable< unsigned long, double > | An unsigned long may be promoted to a double |
Cstan::math::ad_promotable< unsigned short, double > | An unsigned short may be promoted to a double |
Cstan::math::ad_promotable< V, fvar< T > > | |
Cstan::math::ad_promotable< var, var > | |
Cstan::math::apply_scalar_unary< F, T > | 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 |
Cstan::math::apply_scalar_unary< F, double > | Template specialization for vectorized functions applying to double arguments |
Cstan::math::apply_scalar_unary< F, fvar< T > > | Template specialization to fvar for vectorizing a unary scalar function |
Cstan::math::apply_scalar_unary< F, int > | Template specialization for vectorized functions applying to integer arguments |
Cstan::math::apply_scalar_unary< F, std::vector< T > > | Template specialization for vectorized functions applying to standard vector containers |
Cstan::math::apply_scalar_unary< F, var > | Template specialization to var for vectorizing a unary scalar function |
Cstan::math::array_builder< T > | 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 |
Cstan::math::asin_fun | Structure to wrap asin() so it can be vectorized |
Cstan::math::asinh_fun | Structure to wrap asinh() so it can be vectorized |
Cstan::math::atan_fun | Structure to wrap atan() so it can be vectorized |
Cstan::math::atanh_fun | Structure to wrap atanh() so it can be vectorized |
Cstan::math::AutodiffStackStorage< ChainableT, ChainableAllocT > | |
Cstan::math::detail::bounded< T_y, T_low, T_high, y_is_vec > | |
Cstan::math::detail::bounded< T_y, T_low, T_high, true > | |
Cstan::math::cbrt_fun | Structure to wrap cbrt() so it can be vectorized |
Cstan::math::ceil_fun | Structure to wrap ceil() so it can be vectorized |
►Cstan::math::chainable_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 |
Cstan::math::child_type< T > | Primary template class for metaprogram to compute child type of T |
Cstan::math::child_type< T_struct< T_child > > | Specialization for template classes / structs |
Cstan::math::common_type< T1, T2 > | Struct which calculates type promotion given two types |
Cstan::math::common_type< Eigen::Matrix< T1, R, C >, Eigen::Matrix< T2, R, C > > | Struct which calculates type promotion over two types |
Cstan::math::common_type< std::vector< T1 >, std::vector< T2 > > | Struct which calculates type promotion over two types |
Cstan::math::container_view< T1, T2 > | Primary template class for container view of array y with same structure as T1 and size as x |
Cstan::math::container_view< dummy, T2 > | Dummy type specialization, used in conjunction with struct dummy as described above |
Cstan::math::container_view< Eigen::Matrix< T1, R, C >, Eigen::Matrix< T2, R, C > > | Template specialization for Eigen::Map view of array with scalar type T2 with size inferred from input Eigen::Matrix |
Cstan::math::container_view< Eigen::Matrix< T1, R, C >, T2 > | Template specialization for scalar view of array y with scalar type T2 |
Cstan::math::container_view< std::vector< Eigen::Matrix< T1, R, C > >, Eigen::Matrix< T2, R, C > > | Template specialization for matrix view of array y with scalar type T2 with shape equal to x |
Cstan::math::container_view< std::vector< T1 >, T2 > | Template specialization for scalar view of array y with scalar type T2 with proper indexing inferred from input vector x of scalar type T1 |
Cstan::contains_fvar< T1, T2, T3, T4, T5, T6 > | Metaprogram to calculate the base scalar return type resulting from promoting all the scalar types of the template parameters |
Cstan::contains_nonconstant_struct< T1, T2, T3, T4, T5, T6 > | |
Cstan::contains_vector< T1, T2, T3, T4, T5, T6 > | |
Cstan::math::cos_fun | Structure to wrap cos() so it can be vectorized |
Cstan::math::cosh_fun | Structure to wrap cosh() so it can be vectorized |
Cstan::math::coupled_ode_observer | Observer for the coupled states |
Cstan::math::coupled_ode_system< F, T1, T2 > | Base template class for a coupled ordinary differential equation system, which adds sensitivities to the base system |
Cstan::math::coupled_ode_system< F, double, double > | The coupled ode system for known initial values and known parameters |
Cstan::math::coupled_ode_system< F, double, var > | The coupled ODE system for known initial values and unknown parameters |
Cstan::math::coupled_ode_system< F, var, double > | The coupled ODE system for unknown initial values and known parameters |
Cstan::math::coupled_ode_system< F, var, stan::math::var > | The coupled ode system for unknown intial values and unknown parameters |
Cstan::math::cvodes_ode_data< F, T_initial, T_param > | CVODES ode data holder object which is used during CVODES integration for CVODES callbacks |
Cstan::math::digamma_fun | Structure to wrap digamma() so it can be vectorized |
Cstan::math::dummy | Empty struct for use in boost::condtional<is_constant_struct<T1>::value, T1, dummy>::type as false condtion for safe indexing |
Cstan::math::erf_fun | Structure to wrap erf() so it can be vectorized |
Cstan::math::erfc_fun | Structure to wrap erfc() so that it can be vectorized |
Cstan::error_index | |
Cstan::math::exp2_fun | Structure to wrap exp2() so it can be vectorized |
Cstan::math::exp_fun | Structure to wrap exp() so that it can be vectorized |
Cstan::math::expm1_fun | Structure to wrap expm1() so that it can be vectorized |
Cstan::math::fabs_fun | Structure to wrap fabs() so that it can be vectorized |
Cstan::math::floor_fun | Structure to wrap floor() so that it can be vectorized |
Cstan::math::fvar< T > | |
CEigen::internal::general_matrix_matrix_product< Index, stan::math::var, LhsStorageOrder, ConjugateLhs, stan::math::var, RhsStorageOrder, ConjugateRhs, ColMajor > | |
CEigen::internal::general_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 |
CEigen::internal::general_matrix_vector_product< Index, stan::math::var, RowMajor, ConjugateLhs, stan::math::var, ConjugateRhs > | |
►CGenericNumTraits | |
Cstan::math::include_summand< propto, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 > | Template metaprogram to calculate whether a summand needs to be included in a proportional (log) probability calculation |
Cstan::math::index_type< T > | Primary template class for the metaprogram to compute the index type of a container |
Cstan::math::index_type< const T > | Template class for metaprogram to compute the type of indexes used in a constant container type |
Cstan::math::index_type< Eigen::Matrix< T, R, C > > | Template metaprogram defining typedef for the type of index for an Eigen matrix, vector, or row vector |
Cstan::math::index_type< std::vector< T > > | Template metaprogram class to compute the type of index for a standard vector |
Cstan::math::inv_cloglog_fun | Structure to wrap inv_cloglog() so that it can be vectorized |
Cstan::math::inv_fun | Structure to wrap inv() so that it can be vectorized |
Cstan::math::inv_logit_fun | Structure to wrap inv_logit() so that it can be vectorized |
Cstan::math::inv_Phi_fun | Structure to wrap inv_Phi() so it can be vectorized |
Cstan::math::inv_sqrt_fun | Structure to wrap inv_sqrt() so that it can be vectorized |
Cstan::math::inv_square_fun | Structure to wrap inv_square() so that it can be vectorized |
Cstan::is_constant< T > | Metaprogramming struct to detect whether a given type is constant in the mathematical sense (not the C++ const sense) |
Cstan::is_constant_struct< T > | Metaprogram to determine if a type has a base scalar type that can be assigned to type double |
Cstan::is_constant_struct< Eigen::Block< T > > | |
Cstan::is_constant_struct< Eigen::Matrix< T, R, C > > | |
Cstan::is_constant_struct< std::vector< T > > | |
Cstan::is_fvar< T > | |
Cstan::is_fvar< stan::math::fvar< T > > | |
Cstan::is_var< T > | |
Cstan::is_var< stan::math::var > | |
Cstan::is_var_or_arithmetic< T1, T2, T3, T4, T5, T6 > | |
Cstan::is_vector< T > | |
Cstan::is_vector< const T > | |
Cstan::is_vector< Eigen::Block< T > > | |
Cstan::is_vector< Eigen::Matrix< T, 1, Eigen::Dynamic > > | |
Cstan::is_vector< Eigen::Matrix< T, Eigen::Dynamic, 1 > > | |
Cstan::is_vector< std::vector< T > > | |
Cstan::is_vector_like< T > | Template metaprogram indicates whether a type is vector_like |
Cstan::is_vector_like< const T > | Template metaprogram indicates whether a type is vector_like |
Cstan::is_vector_like< Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > > | Template metaprogram indicates whether a type is vector_like |
Cstan::is_vector_like< T * > | Template metaprogram indicates whether a type is vector_like |
Cstan::math::LDLT_factor< T, R, C > | LDLT_factor is a thin wrapper on Eigen::LDLT to allow for reusing factorizations and efficient autodiff of things like log determinants and solutions to linear systems |
Cstan::math::LDLT_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 |
Cstan::math::lgamma_fun | Structure to wrap lgamma() so that it can be vectorized |
Cstan::math::log10_fun | Structure to wrap log10() so it can be vectorized |
Cstan::math::log1m_exp_fun | Structure to wrap log1m_exp() so it can be vectorized |
Cstan::math::log1m_fun | Structure to wrap log1m() so it can be vectorized |
Cstan::math::log1m_inv_logit_fun | Structure to wrap log1m_inv_logit() so it can be vectorized |
Cstan::math::log1p_exp_fun | Structure to wrap log1m_exp() so that it can be vectorized |
Cstan::math::log1p_fun | Structure to wrap log1p() so it can be vectorized |
Cstan::math::log2_fun | Structure to wrap log2() so it can be vectorized |
Cstan::math::log_fun | Structure to wrap log() so that it can be vectorized |
Cstan::math::log_inv_logit_fun | Structure to wrap log_inv_logit() so it can be vectorized |
Cstan::math::logit_fun | Structure to wrap logit() so it can be vectorized |
Cstd::numeric_limits< stan::math::fvar< T > > | |
Cstd::numeric_limits< stan::math::var > | Specialization of numeric limits for var objects |
Cstan::math::ode_system< F > | Internal representation of an ODE model object which provides convenient Jacobian functions to obtain gradients wrt to states and parameters |
Cstan::math::OperandsAndPartials< T1, T2, T3, T4, T5, T6, T_return_type > | This class builds partial derivatives with respect to a set of operands |
Cstan::math::OperandsAndPartials< T1, T2, T3, T4, T5, T6, fvar< T_partials_return > > | This class builds partial derivatives with respect to a set of operands |
Cstan::math::OperandsAndPartials< T1, T2, T3, T4, T5, T6, stan::math::var > | This class builds partial derivatives with respect to a set of operands |
Cstan::partials_return_type< T1, T2, T3, T4, T5, T6 > | |
Cstan::partials_type< T > | |
Cstan::partials_type< stan::math::fvar< T > > | |
Cstan::partials_type< stan::math::var > | |
Cstan::math::pass_type< T > | |
Cstan::math::pass_type< double > | |
Cstan::math::pass_type< int > | |
Cstan::math::Phi_approx_fun | Structure to wrap Phi_approx() so it can be vectorized |
Cstan::math::Phi_fun | Structure to wrap Phi() so it can be vectorized |
Cstan::math::promote_elements< T, S > | Struct with static function for elementwise type promotion |
Cstan::math::promote_elements< Eigen::Matrix< T, R, C >, Eigen::Matrix< S, R, C > > | Struct with static function for elementwise type promotion |
Cstan::math::promote_elements< Eigen::Matrix< T, R, C >, Eigen::Matrix< T, R, C > > | Struct with static function for elementwise type promotion |
Cstan::math::promote_elements< std::vector< T >, std::vector< S > > | Struct with static function for elementwise type promotion |
Cstan::math::promote_elements< std::vector< T >, std::vector< T > > | Struct with static function for elementwise type promotion |
Cstan::math::promote_elements< T, T > | Struct with static function for elementwise type promotion |
Cstan::math::promote_scalar_struct< T, S > | General struct to hold static function for promoting underlying scalar types |
Cstan::math::promote_scalar_struct< T, Eigen::Matrix< S, -1, -1 > > | Struct to hold static function for promoting underlying scalar types |
Cstan::math::promote_scalar_struct< T, Eigen::Matrix< S, -1, 1 > > | Struct to hold static function for promoting underlying scalar types |
Cstan::math::promote_scalar_struct< T, Eigen::Matrix< S, 1, -1 > > | Struct to hold static function for promoting underlying scalar types |
Cstan::math::promote_scalar_struct< T, std::vector< S > > | Struct to hold static function for promoting underlying scalar types |
Cstan::math::promote_scalar_struct< T, T > | Struct to hold static function for promoting underlying scalar types |
Cstan::math::promote_scalar_type< T, S > | Template metaprogram to calculate a type for converting a convertible type |
Cstan::math::promote_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 |
Cstan::math::promote_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 |
Cstan::math::promote_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 |
Cstan::math::promote_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 |
Cstan::return_type< T1, T2, T3, T4, T5, T6 > | Metaprogram to calculate the base scalar return type resulting from promoting all the scalar types of the template parameters |
Cstan::math::round_fun | Structure to wrap round() so it can be vectorized |
CEigen::internal::scalar_product_traits< double, stan::math::var > | Scalar product traits override for Eigen for automatic gradient variables |
CEigen::internal::scalar_product_traits< stan::math::var, double > | Scalar product traits override for Eigen for automatic gradient variables |
Cstan::scalar_seq_view< C, T > | Scalar_seq_view provides a uniform sequence-like wrapper around either a scalar or a sequence of scalars |
Cstan::scalar_seq_view< T, T > | This specialization handles wrapping a scalar as if it were a sequence |
Cstan::scalar_type< T > | Metaprogram structure to determine the base scalar type of a template argument |
Cstan::scalar_type< Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > > | |
Cstan::scalar_type< T * > | |
Cstan::scalar_type_pre< T > | Metaprogram structure to determine the type of first container of the base scalar type of a template argument |
Cstan::math::seq_view< T, S > | |
Cstan::math::seq_view< double, std::vector< int > > | |
Cstan::math::seq_view< T, Eigen::Matrix< S, 1, Eigen::Dynamic > > | |
Cstan::math::seq_view< T, Eigen::Matrix< S, Eigen::Dynamic, 1 > > | |
Cstan::math::seq_view< T, Eigen::Matrix< S, Eigen::Dynamic, Eigen::Dynamic > > | |
Cstan::math::seq_view< T, std::vector< S > > | |
Cstan::math::seq_view< T, std::vector< std::vector< T > > > | |
Cstan::math::seq_view< T, std::vector< T > > | |
CEigen::internal::significant_decimals_default_impl< stan::math::fvar< T >, false > | Implemented this for printing to stream |
CEigen::internal::significant_decimals_default_impl< stan::math::var, false > | Implemented this for printing to stream |
Cstan::math::sin_fun | Structure to wrap sin() so it can be vectorized |
Cstan::math::sinh_fun | Structure to wrap sinh() so that it can be vectorized |
Cstan::size_of_helper< T, is_vec > | |
Cstan::size_of_helper< T, true > | |
Cstan::math::sqrt_fun | Structure to wrap sqrt() so that it can be vectorized |
Cstan::math::square_fun | Structure to wrap square() so that it can be vectorized |
Cstan::math::stack_alloc | An instance of this class provides a memory pool through which blocks of raw memory may be allocated and then collected simultaneously |
Cstan::math::store_type< T > | |
Cstan::math::store_type< double > | |
Cstan::math::store_type< Eigen::Matrix< S, 1, Eigen::Dynamic > > | |
Cstan::math::store_type< Eigen::Matrix< S, Eigen::Dynamic, 1 > > | |
Cstan::math::store_type< Eigen::Matrix< S, Eigen::Dynamic, Eigen::Dynamic > > | |
Cstan::math::store_type< int > | |
Cstan::math::store_type< S > | |
Cstan::math::store_type< std::vector< int > > | |
Cstan::math::store_type< std::vector< S > > | |
Cstan::math::store_type< std::vector< std::vector< T > > > | |
Cstan::math::store_type< std::vector< T > > | |
Cstan::math::tan_fun | Structure to wrap tan() so that it can be vectorized |
Cstan::math::tanh_fun | Structure to wrap tanh() so that it can be vectorized |
Cstan::math::tgamma_fun | Structure to wrap tgamma() so that it can be vectorized |
Cstan::math::trigamma_fun | Structure to wrap trigamma() so it can be vectorized |
Cstan::math::trunc_fun | Structure to wrap trunc() so it can be vectorized |
Cstan::math::value_type< T > | Primary template class for metaprogram to compute the type of values stored in a container |
Cstan::math::value_type< const T > | Template class for metaprogram to compute the type of values stored in a constant container |
Cstan::math::value_type< Eigen::Matrix< T, R, C > > | Template metaprogram defining the type of values stored in an Eigen matrix, vector, or row vector |
Cstan::math::value_type< std::vector< T > > | Template metaprogram class to compute the type of values stored in a standard vector |
Cstan::math::var | Independent (input) and dependent (output) variables for gradients |
►Cstan::math::vari | The variable implementation base class |
Cstan::vector_seq_view< 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 |
Cstan::vector_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 |
Cstan::vector_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 |
Cstan::vector_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 |
Cstan::vector_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 |
Cstan::VectorBuilder< used, T1, T2, T3, T4, T5, T6, T7 > | VectorBuilder allocates type T1 values to be used as intermediate values |
Cstan::VectorBuilderHelper< T1, used, is_vec > | VectorBuilder allocates type T1 values to be used as intermediate values |
Cstan::VectorBuilderHelper< T1, true, false > | |
Cstan::VectorBuilderHelper< T1, true, true > | Template specialization for using a vector |
Cstan::VectorBuilderHelper< T1, used, stan::contains_vector< T2, T3, T4, T5, T6, T7 >::value > | |
Cstan::VectorView< T, is_array, throw_if_accessed > | VectorView is a template expression that is constructed with a container or scalar, which it then allows to be used as an array using operator[] |
Cstan::VectorView< const Eigen::Matrix< T, R, C >, true, false > | |
Cstan::VectorView< const std::vector< T >, true, false > | |
Cstan::VectorView< double, stan::is_vector< T1 >::value, stan::is_constant_struct< T1 >::value > | |
Cstan::VectorView< double, stan::is_vector< T2 >::value, stan::is_constant_struct< T2 >::value > | |
Cstan::VectorView< double, stan::is_vector< T3 >::value, stan::is_constant_struct< T3 >::value > | |
Cstan::VectorView< double, stan::is_vector< T4 >::value, stan::is_constant_struct< T4 >::value > | |
Cstan::VectorView< double, stan::is_vector< T5 >::value, stan::is_constant_struct< T5 >::value > | |
Cstan::VectorView< double, stan::is_vector< T6 >::value, stan::is_constant_struct< T6 >::value > | |
Cstan::VectorView< Eigen::Matrix< T, R, C >, true, false > | |
Cstan::VectorView< std::vector< T >, true, false > | |
Cstan::VectorView< T, false, false > | |
Cstan::VectorView< T, is_array, true > | |
Cstan::VectorView< T, true, false > | |
Cstan::VectorView< T_partials_return, stan::is_vector< T1 >::value, stan::is_constant_struct< T1 >::value > | |
Cstan::VectorView< T_partials_return, stan::is_vector< T2 >::value, stan::is_constant_struct< T2 >::value > | |
Cstan::VectorView< T_partials_return, stan::is_vector< T3 >::value, stan::is_constant_struct< T3 >::value > | |
Cstan::VectorView< T_partials_return, stan::is_vector< T4 >::value, stan::is_constant_struct< T4 >::value > | |
Cstan::VectorView< T_partials_return, stan::is_vector< T5 >::value, stan::is_constant_struct< T5 >::value > | |
Cstan::VectorView< T_partials_return, stan::is_vector< T6 >::value, stan::is_constant_struct< T6 >::value > | |
Cstan::VectorView< T_return_type, false, true > | |
Cstan::math::welford_covar_estimator | |
Cstan::math::welford_var_estimator |