| Stan Math Library 2.12.0 reverse mode automatic differentiation

- Main Page
- Modules
- Namespaces
- Classes
- Files

- Class List
- Class Index
- Class Hierarchy
- Class Members

Class List
Here are the classes, structs, unions and interfaces with brief descriptions:
[detail level 1 2 3 4]

▼N boost | Reimplementing boost functionality
▼N Eigen | (Expert) Numerical traits for algorithmic differentiation variables
►N internal | (Expert) Product traits for algorithmic differentiation variables
C general_matrix_matrix_product< Index, stan::math::var, LhsStorageOrder, ConjugateLhs, stan::math::var, RhsStorageOrder, ConjugateRhs, ColMajor > |
C general_matrix_vector_product< Index, stan::math::var, RowMajor, ConjugateLhs, stan::math::var, ConjugateRhs > |
C 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
C scalar_product_traits< double, stan::math::var > | Scalar product traits override for Eigen for automatic gradient variables
C scalar_product_traits< stan::math::var, double > | Scalar product traits override for Eigen for automatic gradient variables
C significant_decimals_default_impl< stan::math::fvar< T >, false > | Implemented this for printing to stream
C significant_decimals_default_impl< stan::math::var, false > | Implemented this for printing to stream
C NumTraits< stan::math::fvar< T > > | Numerical traits template override for Eigen for automatic gradient variables
C NumTraits< stan::math::var > | Numerical traits template override for Eigen for automatic gradient variables
▼N stan |
►N math | Matrices and templated mathematical functions
►N detail |
C bounded |
C bounded< T_y, T_low, T_high, true > |
C abs_fun | Structure to wrap abs() so it can be vectorized
C accumulator | Class to accumulate values and eventually return their sum
C acos_fun | Structure to wrap acos() so it can be vectorized
C apply_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
C apply_scalar_unary< F, double > | Template specialization for vectorized functions applying to double arguments
C apply_scalar_unary< F, fvar< T > > | Template specialization to fvar for vectorizing a unary scalar function
C apply_scalar_unary< F, int > | Template specialization for vectorized functions applying to integer arguments
C apply_scalar_unary< F, std::vector< T > > | Template specialization for vectorized functions applying to standard vector containers
C apply_scalar_unary< F, var > | Template specialization to var for vectorizing a unary scalar function
C array_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
C asin_fun | Structure to wrap asin() so it can be vectorized
C asinh_fun | Structure to wrap asinh() so it can be vectorized
C atan_fun | Structure to wrap atan() so it can be vectorized
C AutodiffStackStorage |
C cbrt_fun | Structure to wrap cbrt() so it can be vectorized
C ceil_fun | Structure to wrap ceil() so it can be vectorized
C 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
C child_type | Primary template class for metaprogram to compute child type of T
C child_type< T_struct< T_child > > | Specialization for template classes / structs
C cholesky_decompose_v_vari |
C common_type |
C common_type< Eigen::Matrix< T1, R, C >, Eigen::Matrix< T2, R, C > > |
C common_type< std::vector< T1 >, std::vector< T2 > > |
C container_view | Primary template class for container view of array y with same structure as T1 and size as x
C container_view< dummy, T2 > | Dummy type specialization, used in conjunction with struct dummy as described above
C 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
C container_view< Eigen::Matrix< T1, R, C >, T2 > | Template specialization for scalar view of array y with scalar type T2
C 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
C 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
C cos_fun | Structure to wrap cos() so it can be vectorized
C cosh_fun | Structure to wrap cosh() so it can be vectorized
C coupled_ode_observer | Observer for the coupled states
C coupled_ode_system | Base template class for a coupled ordinary differential equation system, which adds sensitivities to the base system
C coupled_ode_system< F, double, double > | The coupled ode system for known initial values and known parameters
C coupled_ode_system< F, double, var > | The coupled ODE system for known initial values and unknown parameters
C coupled_ode_system< F, var, double > | The coupled ODE system for unknown initial values and known parameters
C coupled_ode_system< F, var, stan::math::var > | The coupled ode system for unknown intial values and unknown parameters
C cvodes_ode_data | CVODES ode data holder object which is used during CVODES integration for CVODES callbacks
C digamma_fun | Structure to wrap digamma() so it can be vectorized
C dummy | Empty struct for use in boost::condtional<is_constant_struct<T1>::value, T1, dummy>::type as false condtion for safe indexing
C erf_fun | Structure to wrap erf() so it can be vectorized
C erfc_fun | Structure to wrap erfc() so that it can be vectorized
C exp_fun | Structure to wrap `exp()` so that it can be vectorized
C expm1_fun | Structure to wrap expm1() so that it can be vectorized
C fabs_fun | Structure to wrap fabs() so that it can be vectorized
C floor_fun | Structure to wrap floor() so that it can be vectorized
C fvar |
C gevv_vvv_vari |
C include_summand | Template metaprogram to calculate whether a summand needs to be included in a proportional (log) probability calculation
C index_type | Primary template class for the metaprogram to compute the index type of a container
C index_type< const T > | Template class for metaprogram to compute the type of indexes used in a constant container type
C index_type< Eigen::Matrix< T, R, C > > | Template metaprogram defining typedef for the type of index for an Eigen matrix, vector, or row vector
C index_type< std::vector< T > > | Template metaprogram class to compute the type of index for a standard vector
C inv_cloglog_fun | Structure to wrap inv_cloglog() so that it can be vectorized
C inv_fun | Structure to wrap inv() so that it can be vectorized
C inv_logit_fun | Structure to wrap inv_logit() so that it can be vectorized
C inv_Phi_fun | Structure to wrap inv_Phi() so it can be vectorized
C inv_sqrt_fun | Structure to wrap inv_sqrt() so that it can be vectorized
C inv_square_fun | Structure to wrap inv_square() so that it can be vectorized
C LDLT_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
C LDLT_factor |
C 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
C 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
C lgamma_fun | Structure to wrap lgamma() so that it can be vectorized
C log10_fun | Structure to wrap log10() so it can be vectorized
C log1m_exp_fun | Structure to wrap log1m_exp() so it can be vectorized
C log1m_fun | Structure to wrap log1m() so it can be vectorized
C log1p_exp_fun | Structure to wrap log1m_exp() so that it can be vectorized
C log_fun | Structure to wrap log() so that it can be vectorized
C multiply_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
C multiply_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
C multiply_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
C multiply_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
C multiply_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
C multiply_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
C ode_system | Internal representation of an ODE model object which provides convenient Jacobian functions to obtain gradients wrt to states and parameters
C op_ddv_vari |
C op_dv_vari |
C op_dvd_vari |
C op_dvv_vari |
C op_matrix_vari |
C op_v_vari |
C op_vd_vari |
C op_vdd_vari |
C op_vdv_vari |
C op_vector_vari |
C op_vv_vari |
C op_vvd_vari |
C op_vvv_vari |
C OperandsAndPartials | This class builds partial derivatives with respect to a set of operands
C OperandsAndPartials< T1, T2, T3, T4, T5, T6, fvar< T_partials_return > > | This class builds partial derivatives with respect to a set of operands
C OperandsAndPartials< T1, T2, T3, T4, T5, T6, stan::math::var > | This class builds partial derivatives with respect to a set of operands
C pass_type |
C pass_type< double > |
C pass_type< int > |
C Phi_fun | Structure to wrap Phi() so it can be vectorized
C precomp_v_vari |
C precomp_vv_vari |
C precomp_vvv_vari |
C precomputed_gradients_vari | A variable implementation taking a sequence of operands and partial derivatives with respect to the operands
C promote_scalar_struct | General struct to hold static function for promoting underlying scalar types
C promote_scalar_struct< T, Eigen::Matrix< S, 1,-1 > > | Struct to hold static function for promoting underlying scalar types
C promote_scalar_struct< T, Eigen::Matrix< S,-1, 1 > > | Struct to hold static function for promoting underlying scalar types
C promote_scalar_struct< T, Eigen::Matrix< S,-1,-1 > > | Struct to hold static function for promoting underlying scalar types
C promote_scalar_struct< T, std::vector< S > > | Struct to hold static function for promoting underlying scalar types
C promote_scalar_struct< T, T > | Struct to hold static function for promoting underlying scalar types
C promote_scalar_type | Template metaprogram to calculate a type for converting a convertible type
C 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
C 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
C 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
C 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
C promoter |
C promoter< Eigen::Matrix< F, R, C >, Eigen::Matrix< T, R, C > > |
C promoter< Eigen::Matrix< T, R, C >, Eigen::Matrix< T, R, C > > |
C promoter< std::vector< F >, std::vector< T > > |
C promoter< std::vector< T >, std::vector< T > > |
C promoter< T, T > |
C round_fun | Structure to wrap round() so it can be vectorized
C scal_squared_distance_dv_vari |
C scal_squared_distance_vd_vari |
C scal_squared_distance_vv_vari |
C seq_view |
C seq_view< double, std::vector< int > > |
C seq_view< T, Eigen::Matrix< S, 1, Eigen::Dynamic > > |
C seq_view< T, Eigen::Matrix< S, Eigen::Dynamic, 1 > > |
C seq_view< T, Eigen::Matrix< S, Eigen::Dynamic, Eigen::Dynamic > > |
C seq_view< T, std::vector< S > > |
C seq_view< T, std::vector< std::vector< T > > > |
C seq_view< T, std::vector< T > > |
C sin_fun | Structure to wrap sin() so it can be vectorized
C sinh_fun | Structure to wrap sinh() so that it can be vectorized
C sqrt_fun | Structure to wrap sqrt() so that it can be vectorized
C square_fun | Structure to wrap square() so that it can be vectorized
C stack_alloc | An instance of this class provides a memory pool through which blocks of raw memory may be allocated and then collected simultaneously
C store_type |
C store_type< double > |
C store_type< int > |
C stored_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
C sum_eigen_v_vari | Class for representing sums with constructors for Eigen
C sum_v_vari | Class for sums of variables constructed with standard vectors
C tan_fun | Structure to wrap tan() so that it can be vectorized
C tanh_fun | Structure to wrap tanh() so that it can be vectorized
C tgamma_fun | Structure to wrap tgamma() so that it can be vectorized
C value_type | Primary template class for metaprogram to compute the type of values stored in a container
C value_type< const T > | Template class for metaprogram to compute the type of values stored in a constant container
C value_type< Eigen::Matrix< T, R, C > > | Template metaprogram defining the type of values stored in an Eigen matrix, vector, or row vector
C value_type< std::vector< T > > | Template metaprogram class to compute the type of values stored in a standard vector
C var | Independent (input) and dependent (output) variables for gradients
C vari | The variable implementation base class
C welford_covar_estimator |
C welford_var_estimator |
C contains_fvar | Metaprogram to calculate the base scalar return type resulting from promoting all the scalar types of the template parameters
C contains_nonconstant_struct |
C contains_vector |
C error_index |
C is_constant | Metaprogramming struct to detect whether a given type is constant in the mathematical sense (not the C++ `const` sense)
C is_constant_struct | Metaprogram to determine if a type has a base scalar type that can be assigned to type double
C is_constant_struct< Eigen::Block< T > > |
C is_constant_struct< Eigen::Matrix< T, R, C > > |
C is_constant_struct< std::vector< T > > |
C is_fvar |
C is_fvar< stan::math::fvar< T > > |
C is_var |
C is_var< stan::math::var > |
C is_var_or_arithmetic |
C is_vector |
C is_vector< const T > |
C is_vector< Eigen::Block< T > > |
C is_vector< Eigen::Matrix< T, 1, Eigen::Dynamic > > |
C is_vector< Eigen::Matrix< T, Eigen::Dynamic, 1 > > |
C is_vector< std::vector< T > > |
C is_vector_like | Template metaprogram indicates whether a type is vector_like
C is_vector_like< const T > | Template metaprogram indicates whether a type is vector_like
C is_vector_like< Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > > | Template metaprogram indicates whether a type is vector_like
C is_vector_like< T * > | Template metaprogram indicates whether a type is vector_like
C partials_return_type |
C partials_type |
C partials_type< stan::math::fvar< T > > |
C partials_type< stan::math::var > |
C return_type | Metaprogram to calculate the base scalar return type resulting from promoting all the scalar types of the template parameters
C scalar_type | Metaprogram structure to determine the base scalar type of a template argument
C scalar_type< Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > > |
C scalar_type< T * > |
C scalar_type_pre | Metaprogram structure to determine the type of first container of the base scalar type of a template argument
C size_of_helper |
C size_of_helper< T, true > |
C VectorBuilder | VectorBuilder allocates type T1 values to be used as intermediate values
C VectorBuilderHelper | VectorBuilder allocates type T1 values to be used as intermediate values
C VectorBuilderHelper< T1, true, false > |
C VectorBuilderHelper< T1, true, true > | Template specialization for using a vector
C VectorView | 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[]`
C VectorView< const Eigen::Matrix< T, R, C >, true, false > |
C VectorView< const std::vector< T >, true, false > |
C VectorView< Eigen::Matrix< T, R, C >, true, false > |
C VectorView< std::vector< T >, true, false > |
C VectorView< T, false, false > |
C VectorView< T, is_array, true > |
C VectorView< T, true, false > |
C VectorViewMvt | VectorViewMvt is a template expression that wraps either an Eigen::Matrix or a std::vector<Eigen::Matrix> and allows the template expression to be used as an array using `operator[]`
C VectorViewMvt< const T, is_array, throw_if_accessed > | VectorViewMvt with const correctness
▼N std |
C numeric_limits< stan::math::fvar< T > > |
C numeric_limits< stan::math::var > | Specialization of numeric limits for var objects

[ Stan Home Page ] © 2011–2016, Stan Development Team.