 boost | Reimplementing boost functionality |
  math | Reimplmeneting boost functionality for stan::math::var and and bugs in classification of integer types |
 Eigen | (Expert) Numerical traits for algorithmic differentiation variables |
  internal | (Expert) Product traits for algorithmic differentiation variables |
   significant_decimals_default_impl< stan::math::fvar< T >, false > | Implemented this for printing to stream |
   significant_decimals_default_impl< stan::math::var, false > | Implemented this for printing to stream |
   scalar_product_traits< stan::math::var, double > | Scalar product traits override for Eigen for automatic gradient variables |
   scalar_product_traits< double, stan::math::var > | Scalar product traits override for Eigen for automatic gradient variables |
   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 |
   general_matrix_vector_product< Index, stan::math::var, RowMajor, ConjugateLhs, stan::math::var, ConjugateRhs > | |
   general_matrix_matrix_product< Index, stan::math::var, LhsStorageOrder, ConjugateLhs, stan::math::var, RhsStorageOrder, ConjugateRhs, ColMajor > | |
  NumTraits< stan::math::fvar< T > > | Numerical traits template override for Eigen for automatic gradient variables |
  NumTraits< stan::math::var > | Numerical traits template override for Eigen for automatic gradient variables |
 stan | |
  math | Matrices and templated mathematical functions |
   detail | |
    bounded | |
    bounded< T_y, T_low, T_high, true > | |
   fvar | |
   stack_alloc | An instance of this class provides a memory pool through which blocks of raw memory may be allocated and then collected simultaneously |
   coupled_ode_observer | Observer for the coupled states |
   coupled_ode_system | Base template class for a coupled ordinary differential equation system, which adds sensitivities to the base system |
   coupled_ode_system< F, double, double > | The coupled ode system for known initial values and known parameters |
   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 |
   index_type< std::vector< T > > | Template metaprogram class to compute the type of index for a standard vector |
   accumulator | Class to accumulate values and eventually return their sum |
   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 |
   common_type | |
   common_type< std::vector< T1 >, std::vector< T2 > > | |
   common_type< Eigen::Matrix< T1, R, C >, Eigen::Matrix< T2, R, C > > | |
   LDLT_factor | |
   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 |
   promote_scalar_struct< T, Eigen::Matrix< S,-1,-1 > > | Struct to hold static function for promoting underlying scalar types |
   promote_scalar_struct< T, Eigen::Matrix< S, 1,-1 > > | Struct to hold static function for promoting underlying scalar types |
   promote_scalar_struct< T, Eigen::Matrix< S,-1, 1 > > | Struct to hold static function for promoting underlying scalar types |
   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 |
   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 |
   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 |
   promoter | |
   promoter< T, T > | |
   promoter< std::vector< F >, std::vector< T > > | |
   promoter< std::vector< T >, std::vector< T > > | |
   promoter< Eigen::Matrix< F, R, C >, Eigen::Matrix< T, R, C > > | |
   promoter< Eigen::Matrix< T, R, C >, Eigen::Matrix< T, R, C > > | |
   welford_covar_estimator | |
   welford_var_estimator | |
   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 |
   container_view< Eigen::Matrix< T1, R, C >, T2 > | Template specialization for scalar view of array y with scalar type T2 |
   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 |
   index_type< Eigen::Matrix< T, R, C > > | Template metaprogram defining typedef for the type of index for an Eigen matrix, vector, or row vector |
   store_type | |
   store_type< double > | |
   store_type< int > | |
   pass_type | |
   pass_type< double > | |
   pass_type< int > | |
   seq_view | |
   seq_view< T, Eigen::Matrix< S, Eigen::Dynamic, 1 > > | |
   seq_view< T, Eigen::Matrix< S, 1, Eigen::Dynamic > > | |
   seq_view< T, Eigen::Matrix< S, Eigen::Dynamic, Eigen::Dynamic > > | |
   seq_view< T, std::vector< S > > | |
   seq_view< T, std::vector< T > > | |
   seq_view< T, std::vector< std::vector< T > > > | |
   seq_view< double, std::vector< int > > | |
   value_type< Eigen::Matrix< T, R, C > > | Template metaprogram defining the type of values stored in an Eigen matrix, vector, or row vector |
   promote_scalar_struct | General struct to hold static function for promoting underlying scalar types |
   promote_scalar_struct< T, T > | Struct to hold static function for promoting underlying scalar types |
   promote_scalar_struct< T, std::vector< S > > | Struct to hold static function for promoting underlying scalar types |
   promote_scalar_type | Template metaprogram to calculate a type for converting a convertible type |
   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 |
   child_type | Primary template class for metaprogram to compute child type of T |
   child_type< T_struct< T_child > > | Specialization for template classes / structs |
   container_view | Primary template class for container view of array y with same structure as T1 and size as x |
   dummy | Empty struct for use in boost::condtional<is_constant_struct<T1>::value, T1, dummy>::type as false condtion for safe indexing |
   container_view< dummy, T2 > | Dummy type specialization, used in conjunction with struct dummy as described above |
   include_summand | Template metaprogram to calculate whether a summand needs to be included in a proportional (log) probability calculation |
   index_type | Primary template class for the metaprogram to compute the index type of a container |
   index_type< const T > | Template class for metaprogram to compute the type of indexes used in a constant container type |
   partials_vari | |
   OperandsAndPartials | A variable implementation that stores operands and derivatives with respect to the variable |
   value_type | Primary template class for metaprogram to compute the type of values stored in a container |
   value_type< const T > | Template class for metaprogram to compute the type of values stored in a constant container |
   value_type< std::vector< T > > | Template metaprogram class to compute the type of values stored in a standard vector |
   sum_v_vari | Class for sums of variables constructed with standard vectors |
   coupled_ode_system< F, double, stan::math::var > | The coupled ODE system for known initial values and unknown parameters |
   coupled_ode_system< F, stan::math::var, double > | The coupled ODE system for unknown initial values and known parameters |
   coupled_ode_system< F, stan::math::var, stan::math::var > | The coupled ode system for unknown intial values and unknown parameters |
   AutodiffStackStorage | |
   chainable | Abstract base class for variable implementations that handles memory management and applying the chain rule |
   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 |
   op_ddv_vari | |
   op_dv_vari | |
   op_dvd_vari | |
   op_dvv_vari | |
   gevv_vvv_vari | |
   op_matrix_vari | |
   precomp_v_vari | |
   precomp_vv_vari | |
   precomp_vvv_vari | |
   precomputed_gradients_vari | A variable implementation taking a sequence of operands and partial derivatives with respect to the operands |
   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 |
   op_v_vari | |
   var | Independent (input) and dependent (output) variables for gradients |
   vari | The variable implementation base class |
   op_vd_vari | |
   op_vdd_vari | |
   op_vdv_vari | |
   op_vector_vari | |
   op_vv_vari | |
   op_vvd_vari | |
   op_vvv_vari | |
   cholesky_decompose_v_vari | |
   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 |
   LDLT_factor< stan::math::var, R, C > | A template specialization of src/stan/math/matrix/LDLT_factor.hpp for stan::math::var which can be used with all the *_ldlt functions |
   sum_eigen_v_vari | Class for representing sums with constructors for Eigen |
  is_fvar< stan::math::fvar< T > > | |
  partials_type< stan::math::fvar< T > > | |
  is_vector< const T > | |
  is_vector< std::vector< T > > | |
  is_vector< Eigen::Matrix< T, Eigen::Dynamic, 1 > > | |
  is_vector< Eigen::Matrix< T, 1, Eigen::Dynamic > > | |
  is_vector< Eigen::Block< T > > | |
  is_vector_like< Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > > | |
  contains_fvar | Metaprogram to calculate the base scalar return type resulting from promoting all the scalar types of the template parameters |
  contains_nonconstant_struct | |
  contains_vector | |
  error_index | |
  is_constant | Metaprogramming struct to detect whether a given type is constant in the mathematical sense (not the C++ const sense) |
  is_constant_struct | Metaprogram to determine if a type has a base scalar type that can be assigned to type double |
  is_constant_struct< std::vector< T > > | |
  is_constant_struct< Eigen::Matrix< T, R, C > > | |
  is_constant_struct< Eigen::Block< T > > | |
  is_fvar | |
  is_var | |
  is_var_or_arithmetic | |
  is_vector | |
  is_vector_like | |
  is_vector_like< T * > | |
  is_vector_like< const T > | |
  partials_return_type | |
  partials_type | |
  return_type | Metaprogram to calculate the base scalar return type resulting from promoting all the scalar types of the template parameters |
  scalar_type | Metaprogram structure to determine the base scalar type of a template argument |
  scalar_type< Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > > | |
  scalar_type< T * > | |
  scalar_type_pre | Metaprogram structure to determine the type of first container of the base scalar type of a template argument |
  size_of_helper | |
  size_of_helper< T, true > | |
  VectorBuilderHelper | VectorBuilder allocates type T1 values to be used as intermediate values |
  VectorBuilderHelper< T1, true, false > | |
  VectorBuilderHelper< T1, true, true > | |
  VectorBuilder | |
  VectorView | VectorView is a template metaprogram that takes its argument and allows it to be used like a vector |
  VectorView< const T, is_array, throw_if_accessed > | VectorView that has const correctness |
  VectorView< const double, false, false > | |
  VectorViewMvt | |
  VectorViewMvt< const T, is_array, throw_if_accessed > | VectorViewMvt that has const correctness |
  is_var< stan::math::var > | |
  partials_type< stan::math::var > | |
 std | |
  numeric_limits< stan::math::fvar< T > > | |
  numeric_limits< stan::math::var > | Specialization of numeric limits for var objects |