  stan::mcmc::adaptive_sampler | An abstract base class for adaptive samplers |
  stan::mcmc::adaptive_cdhmc | Adaptive "constant distance" Hamiltonian Monte Carlo (CDHMC) sampler |
| stan::mcmc::hmc | Hamiltonian Monte Carlo (HMC) sampler |
 stan::mcmc::hmc_base< BaseRNG > | |
 stan::mcmc::adaptive_hmc< BaseRNG > | Adaptive Hamiltonian Monte Carlo (HMC) sampler |
| stan::mcmc::nuts< BaseRNG > | No-U-Turn Sampler (NUTS) |
 stan::mcmc::nuts_diag< BaseRNG > | No-U-Turn Sampler (NUTS) with varying step sizes |
| stan::gm::add_conditional_body | |
| stan::gm::add_conditional_condition | |
| stan::gm::addition_expr | |
| stan::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 |
| stan::gm::array_literal | |
| stan::agrad::assigner< PromoteRHS, LHS, RHS > | |
| stan::agrad::assigner< false, LHS, RHS > | |
| stan::agrad::assigner< true, LHS, RHS > | |
| stan::gm::assignment | |
| stan::gm::base_var_decl | |
| stan::gm::corr_matrix_var_decl | |
| stan::gm::cov_matrix_var_decl | |
| stan::gm::double_var_decl | |
| stan::gm::int_var_decl | |
| stan::gm::matrix_var_decl | |
| stan::gm::ordered_var_decl | |
| stan::gm::positive_ordered_var_decl | |
| stan::gm::row_vector_var_decl | |
| stan::gm::simplex_var_decl | |
| stan::gm::vector_var_decl | |
| stan::gm::binary_op | |
| stan::gm::binary_op_expr | |
| stan::agrad::chainable | Abstract base class for variable implementations that handles memory management and applying the chain rule |
| stan::agrad::vari | The variable implementation base class |
| stan::agrad::gevv_vvv_vari | |
| stan::agrad::partials_vari | |
| stan::mcmc::chains< RNG > | An mcmc::chains object stores parameter names and dimensionalities along with samples from multiple chains |
| stan::memory::chunk_alloc< T, Tnchunks_per_block > | |
| stan::io::cmd_line | Parses and stores command-line arguments |
| stan::math::common_type< T1, T2 > | |
| stan::math::common_type< Eigen::Matrix< T1, R, C >, Eigen::Matrix< T2, R, C > > | |
| stan::math::common_type< std::vector< T1 >, std::vector< T2 > > | |
| stan::gm::conditional_statement | |
| stan::io::csv_writer | Writes Stan variables in comma-separated-value format to an output stream |
| stan::gm::distribution | |
| stan::gm::double_literal | |
| stan::DoubleVectorView< used, T, is_vec > | |
| stan::DoubleVectorView< true, T, false > | |
| stan::DoubleVectorView< true, T, true > | |
| stan::mcmc::DualAverage | Implements Nesterov's dual average algorithm |
| stan::io::dump_reader | Reads data from S-plus dump format |
| stan::io::dump_writer | Writes data into the S-plus dump format |
| stan::gm::expr_type | |
| stan::gm::expression | |
| expression_grammar< Iterator > | |
| stan::gm::for_statement | |
| stan::gm::fun | |
| stan::gm::function_signatures | |
| Eigen::internal::general_matrix_matrix_product< Index, stan::agrad::var, LhsStorageOrder, ConjugateLhs, stan::agrad::var, RhsStorageOrder, ConjugateRhs, ColMajor > | |
| Eigen::internal::general_matrix_vector_product< Index, stan::agrad::var, ColMajor, ConjugateLhs, stan::agrad::var, ConjugateRhs > | Override matrix-vector and matrix-matrix products to use more efficient implementation |
| Eigen::internal::general_matrix_vector_product< Index, stan::agrad::var, RowMajor, ConjugateLhs, stan::agrad::var, ConjugateRhs > | |
| grammar | |
| stan::gm::expression_grammar< Iterator > | |
| stan::gm::program_grammar< Iterator > | |
| stan::gm::statement_2_grammar< Iterator > | |
| stan::gm::statement_grammar< Iterator > | |
| stan::gm::term_grammar< Iterator > | |
| stan::gm::var_decls_grammar< Iterator > | |
| stan::gm::whitespace_grammar< Iterator > | |
| stan::prob::include_summand< propto, T1, T2, T3, T4, T5, T6 > | Template metaprogram to calculate whether a summand needs to be included in a proportional (log) probability calculation |
| stan::gm::index_op | |
| stan::gm::int_literal | |
| stan::is_constant< T > | Metaprogramming struct to detect whether a given type is constant in the mathematical sense (not the C++ const sense) |
| stan::is_constant_struct< T > | Metaprogram to determine if a type has a base scalar type that can be assigned to type double |
| stan::is_constant_struct< Eigen::Matrix< T, R, C > > | |
| stan::is_constant_struct< std::vector< T > > | |
| stan::is_vector< T > | |
| stan::is_vector< const T > | |
| stan::is_vector< Eigen::Matrix< T, 1, Eigen::Dynamic > > | |
| stan::is_vector< Eigen::Matrix< T, Eigen::Dynamic, 1 > > | |
| stan::is_vector< std::vector< T > > | |
| stan::is_vector_like< T > | |
| stan::is_vector_like< const T > | |
| stan::is_vector_like< Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > > | |
| stan::is_vector_like< T * > | |
| stan::agrad::needs_promotion< LHS, RHS > | |
| stan::gm::nil | Placeholder struct for boost::variant default ctors |
| stan::gm::no_op_statement | |
| std::numeric_limits< stan::agrad::var > | Specialization of numeric limits for var objects |
| Eigen::NumTraits< stan::agrad::var > | Numerical traits template override for Eigen for automatic gradient variables |
| stan::agrad::OperandsAndPartials< T1, T2, T3, T4, T5, T6, T_return_type > | A variable implementation that stores operands and derivatives with respect to the variable |
| stan::gm::print_statement | |
| stan::gm::printable | |
| stan::model::prob_grad | The prob_grad class represents densities with fixed numbers of discrete and scalar parameters and the gradient with respet to the scalar parameters |
| stan::model::prob_grad_ad | |
| stan::model::stanc_model | The abstract base class for models generated by the Stan compiler stanc |
| stan::gm::program | |
| stan::math::promoter< F, T > | |
| stan::math::promoter< Eigen::Matrix< F, R, C >, Eigen::Matrix< T, R, C > > | |
| stan::math::promoter< Eigen::Matrix< T, R, C >, Eigen::Matrix< T, R, C > > | |
| stan::math::promoter< std::vector< F >, std::vector< T > > | |
| stan::math::promoter< std::vector< T >, std::vector< T > > | |
| stan::math::promoter< T, T > | |
| stan::gm::range | |
| stan::io::reader< T > | A stream-based reader for integer, scalar, vector, matrix and array data types, with Jacobian calculations |
| stan::gm::add_conditional_condition::result< T1, T2, T3 > | |
| stan::gm::add_conditional_body::result< T1, T2 > | |
| stan::gm::subtraction_expr::result< T1, T2, T3 > | |
| stan::gm::binary_op_expr::result< T1, T2, T3, T4, T5 > | |
| stan::gm::validate_expr_type2::result< T1, T2 > | |
| stan::gm::set_fun_type2::result< T1, T2 > | |
| stan::gm::addition_expr::result< T1, T2, T3 > | |
| stan::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 |
| stan::mcmc::sample | Representation of a MCMC sample |
| stan::gm::sample | |
| Eigen::internal::scalar_product_traits< double, stan::agrad::var > | Scalar product traits override for Eigen for automatic gradient variables |
| Eigen::internal::scalar_product_traits< stan::agrad::var, double > | Scalar product traits override for Eigen for automatic gradient variables |
| stan::scalar_type< T > | Metaprogram structure to determine the base scalar type of a template argument |
| stan::scalar_type< Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > > | |
| stan::scalar_type< T * > | |
| stan::gm::set_fun_type2 | |
| Eigen::internal::significant_decimals_default_impl< stan::agrad::var, false > | Implemented this for printing to stream |
| stan::size_of_helper< T, is_vec > | |
| stan::size_of_helper< T, true > | |
| stan::memory::stack_alloc | An instance of this class provides a memory pool through which blocks of raw memory may be allocated and then collected simultaneously |
| stan::gm::statement | |
| statement_grammar< Iterator > | |
| stan::gm::statements | |
| static_visitor | |
| stan::gm::expression_type_vis | |
| stan::gm::is_nil_op | |
| stan::gm::name_vis | |
| stan::gm::subtraction_expr | |
| term_grammar< Iterator > | |
| term_grammar< Iterator > | |
| stan::gm::unary_op | |
| stan::gm::validate_expr_type2 | |
| stan::agrad::var | Independent (input) and dependent (output) variables for gradients |
| stan::io::var_context | A var_reader reads array variables of integer and floating point type by name and dimension |
| stan::io::dump | Represents named arrays with dimensions |
| stan::gm::var_decl | |
| stan::gm::variable | |
| stan::gm::variable_dims | |
| stan::gm::variable_map | |
| stan::VectorView< T, is_array > | |
| stan::VectorView< const double, false > | |
| stan::VectorView< const T, is_array > | |
| stan::VectorView< double *, is_vector< T1 >::value > | |
| stan::VectorView< double *, is_vector< T2 >::value > | |
| stan::VectorView< double *, is_vector< T3 >::value > | |
| stan::VectorView< double *, is_vector< T4 >::value > | |
| stan::VectorView< double *, is_vector< T5 >::value > | |
| stan::VectorView< double *, is_vector< T6 >::value > | |
| stan::gm::visgen | Generic visitor with output for extension |
| stan::gm::dump_member_var_visgen | |
| stan::gm::expression_visgen | |
| stan::gm::generate_init_vars_visgen | |
| stan::gm::generate_init_visgen | |
| stan::gm::init_local_var_visgen | |
| stan::gm::local_var_decl_visgen | |
| stan::gm::member_var_decl_visgen | |
| stan::gm::printable_visgen | |
| stan::gm::set_param_ranges_visgen | |
| stan::gm::statement_visgen | |
| stan::gm::validate_transformed_params_visgen | |
| stan::gm::validate_var_decl_visgen | |
| stan::gm::var_resizing_visgen | |
| stan::gm::var_size_validating_visgen | |
| stan::gm::write_array_vars_visgen | |
| stan::gm::write_array_visgen | |
| stan::gm::write_csv_header_visgen | |
| stan::gm::write_csv_vars_visgen | |
| stan::gm::write_csv_visgen | |
| stan::gm::write_dims_visgen | |
| stan::gm::write_param_names_visgen | |
| stan::gm::while_statement | |
| stan::io::writer< T > | A stream-based writer for integer, scalar, vector, matrix and array data types, which transforms from constrained to a sequence of constrained variables |
