  stan::math::accumulator< T > | Class to accumulate values and eventually return their sum |
| stan::gm::add_conditional_body | |
| stan::gm::add_conditional_condition | |
| stan::gm::add_expression_dimss | |
| stan::gm::add_fun_var | |
| stan::gm::add_function_signature | |
| stan::gm::add_loop_identifier | |
| add_var | |
| stan::gm::add_while_body | |
| stan::gm::add_while_condition | |
| stan::gm::addition_expr3 | |
| stan::gm::arg_decl | |
 stan::gm::argument | |
 stan::gm::categorical_argument | |
| stan::gm::arg_adapt | |
| stan::gm::arg_bfgs | |
 stan::gm::arg_lbfgs | |
| stan::gm::arg_data | |
| stan::gm::arg_diagnose | |
| stan::gm::arg_hmc | |
| stan::gm::arg_newton | |
| stan::gm::arg_nuts | |
| stan::gm::arg_optimize | |
| stan::gm::arg_output | |
| stan::gm::arg_random | |
| stan::gm::arg_rwm | |
| stan::gm::arg_sample | |
| stan::gm::arg_static | |
| stan::gm::arg_test_gradient | |
| stan::gm::unvalued_argument | |
| stan::gm::arg_dense_e | |
| stan::gm::arg_diag_e | |
| stan::gm::arg_fail | |
| stan::gm::arg_fixed_param | |
| stan::gm::arg_unit_e | |
 stan::gm::valued_argument | |
 stan::gm::list_argument | |
| stan::gm::arg_engine | |
| stan::gm::arg_method | |
| stan::gm::arg_metric | |
| stan::gm::arg_optimize_algo | |
| stan::gm::arg_sample_algo | |
| stan::gm::arg_test | |
| stan::gm::singleton_argument< T > | |
| stan::gm::arg_adapt_delta | |
| stan::gm::arg_adapt_engaged | |
| stan::gm::arg_adapt_gamma | |
| stan::gm::arg_adapt_init_buffer | |
| stan::gm::arg_adapt_kappa | |
| stan::gm::arg_adapt_t0 | |
| stan::gm::arg_adapt_term_buffer | |
| stan::gm::arg_adapt_window | |
| stan::gm::arg_data_file | |
| stan::gm::arg_diagnostic_file | |
| stan::gm::arg_history_size | |
| stan::gm::arg_id | |
| stan::gm::arg_init | |
| stan::gm::arg_init_alpha | |
| stan::gm::arg_int_time | |
| stan::gm::arg_iter | |
| stan::gm::arg_max_depth | |
| stan::gm::arg_num_samples | |
| stan::gm::arg_num_warmup | |
| stan::gm::arg_output_file | |
| stan::gm::arg_refresh | |
| stan::gm::arg_save_iterations | |
| stan::gm::arg_save_warmup | |
| stan::gm::arg_seed | |
| stan::gm::arg_stepsize | |
| stan::gm::arg_stepsize_jitter | |
| stan::gm::arg_test_grad_eps | |
| stan::gm::arg_test_grad_err | |
| stan::gm::arg_thin | |
| stan::gm::arg_tolerance | |
| stan::gm::argument_parser | |
| stan::gm::argument_probe | |
| 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::gm::assignment | |
| stan::mcmc::base_adaptation | |
| stan::mcmc::stepsize_adaptation | |
| stan::mcmc::windowed_adaptation | |
| stan::mcmc::covar_adaptation | |
| stan::mcmc::var_adaptation | |
| stan::mcmc::base_adapter | |
| stan::mcmc::stepsize_adapter | |
| stan::mcmc::adapt_unit_e_nuts< M, BaseRNG > | |
| stan::mcmc::adapt_unit_e_static_hmc< M, BaseRNG > | |
| stan::mcmc::stepsize_covar_adapter | |
| stan::mcmc::adapt_dense_e_nuts< M, BaseRNG > | |
| stan::mcmc::adapt_dense_e_static_hmc< M, BaseRNG > | |
| stan::mcmc::stepsize_var_adapter | |
| stan::mcmc::adapt_diag_e_nuts< M, BaseRNG > | |
| stan::mcmc::adapt_diag_e_static_hmc< M, BaseRNG > | |
| stan::mcmc::base_hamiltonian< M, P, BaseRNG > | |
| stan::mcmc::base_hamiltonian< M, dense_e_point, BaseRNG > | |
| stan::mcmc::dense_e_metric< M, BaseRNG > | |
| stan::mcmc::base_hamiltonian< M, diag_e_point, BaseRNG > | |
| stan::mcmc::diag_e_metric< M, BaseRNG > | |
| stan::mcmc::base_hamiltonian< M, unit_e_point, BaseRNG > | |
| stan::mcmc::unit_e_metric< M, BaseRNG > | |
| stan::mcmc::base_integrator< H, P > | |
| stan::mcmc::base_leapfrog< H, P > | |
| stan::mcmc::expl_leapfrog< H, P > | |
| stan::mcmc::base_integrator< dense_e_metric< M, BaseRNG >, dense_e_point > | |
| stan::mcmc::base_leapfrog< dense_e_metric< M, BaseRNG >, dense_e_point > | |
| stan::mcmc::expl_leapfrog< dense_e_metric< M, BaseRNG >, dense_e_point > | |
| stan::mcmc::base_integrator< diag_e_metric< M, BaseRNG >, diag_e_point > | |
| stan::mcmc::base_leapfrog< diag_e_metric< M, BaseRNG >, diag_e_point > | |
| stan::mcmc::expl_leapfrog< diag_e_metric< M, BaseRNG >, diag_e_point > | |
| stan::mcmc::base_integrator< unit_e_metric< M, BaseRNG >, unit_e_point > | |
| stan::mcmc::base_leapfrog< unit_e_metric< M, BaseRNG >, unit_e_point > | |
| stan::mcmc::expl_leapfrog< unit_e_metric< M, BaseRNG >, unit_e_point > | |
| stan::mcmc::base_mcmc | |
| stan::mcmc::base_hmc< M, dense_e_point, dense_e_metric, expl_leapfrog, BaseRNG > | |
| stan::mcmc::base_nuts< M, dense_e_point, dense_e_metric, expl_leapfrog, BaseRNG > | |
| stan::mcmc::dense_e_nuts< M, BaseRNG > | |
| stan::mcmc::adapt_dense_e_nuts< M, BaseRNG > | |
| stan::mcmc::base_static_hmc< M, dense_e_point, dense_e_metric, expl_leapfrog, BaseRNG > | |
| stan::mcmc::dense_e_static_hmc< M, BaseRNG > | |
| stan::mcmc::adapt_dense_e_static_hmc< M, BaseRNG > | |
| stan::mcmc::base_hmc< M, diag_e_point, diag_e_metric, expl_leapfrog, BaseRNG > | |
| stan::mcmc::base_nuts< M, diag_e_point, diag_e_metric, expl_leapfrog, BaseRNG > | |
| stan::mcmc::diag_e_nuts< M, BaseRNG > | |
| stan::mcmc::adapt_diag_e_nuts< M, BaseRNG > | |
| stan::mcmc::base_static_hmc< M, diag_e_point, diag_e_metric, expl_leapfrog, BaseRNG > | |
| stan::mcmc::diag_e_static_hmc< M, BaseRNG > | |
| stan::mcmc::adapt_diag_e_static_hmc< M, BaseRNG > | |
| stan::mcmc::base_hmc< M, unit_e_point, unit_e_metric, expl_leapfrog, BaseRNG > | |
| stan::mcmc::base_nuts< M, unit_e_point, unit_e_metric, expl_leapfrog, BaseRNG > | |
| stan::mcmc::unit_e_nuts< M, BaseRNG > | |
| stan::mcmc::adapt_unit_e_nuts< M, BaseRNG > | |
| stan::mcmc::base_static_hmc< M, unit_e_point, unit_e_metric, expl_leapfrog, BaseRNG > | |
| stan::mcmc::unit_e_static_hmc< M, BaseRNG > | |
| stan::mcmc::adapt_unit_e_static_hmc< M, BaseRNG > | |
| stan::mcmc::base_hmc< M, P, H, I, BaseRNG > | |
| stan::mcmc::base_nuts< M, P, H, I, BaseRNG > | |
| stan::mcmc::base_static_hmc< M, P, H, I, BaseRNG > | |
| stan::mcmc::fixed_param_sampler | |
| stan::gm::base_var_decl | |
| stan::gm::cholesky_corr_var_decl | |
| stan::gm::cholesky_factor_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::unit_vector_var_decl | |
| stan::gm::vector_var_decl | |
| stan::optimization::BFGSMinimizer< FunctorType, QNUpdateType, Scalar, DimAtCompile > | |
| stan::optimization::BFGSMinimizer< ModelAdaptor< M >, QNUpdateType, Scalar, DimAtCompile > | |
| stan::optimization::BFGSLineSearch< M, QNUpdateType, Scalar, DimAtCompile > | |
| stan::optimization::BFGSUpdate_HInv< Scalar, DimAtCompile > | |
| stan::gm::binary_op | |
| stan::gm::binary_op_expr | |
| stan::math::detail::bounded< T_y, T_low, T_high, T_result, y_is_vec > | |
| stan::math::detail::bounded< T_y, T_low, T_high, T_result, true > | |
| 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::op_ddv_vari | |
| stan::agrad::op_dv_vari | |
| stan::agrad::op_dvd_vari | |
| stan::agrad::op_dvv_vari | |
| stan::agrad::op_matrix_vari | |
| stan::agrad::op_v_vari | |
| stan::agrad::precomp_v_vari | |
| stan::agrad::op_vd_vari | |
| stan::agrad::op_vdd_vari | |
| stan::agrad::op_vdv_vari | |
| stan::agrad::op_vector_vari | |
| stan::agrad::op_vv_vari | |
| stan::agrad::op_vvd_vari | |
| stan::agrad::op_vvv_vari | |
| stan::agrad::partials_vari | |
| stan::agrad::precomputed_gradients_vari | This is a var implementation class that takes precomputed gradient values |
| stan::agrad::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 |
| stan::agrad::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 |
| stan::agrad::LDLT_alloc< R, C > | 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 |
| stan::mcmc::chains< RNG > | An mcmc::chains object stores parameter names and dimensionalities along with samples from multiple chains |
| 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::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 |
| stan::optimization::ConvergenceOptions< Scalar > | |
| copy_square_cholesky_dimension_if_necessary | |
| stan::math::coupled_ode_observer | Observer for the coupled states |
| stan::math::coupled_ode_system< F, T1, T2 > | Base template class for a coupled ordinary differential equation system, which adds sensitivities to the base system |
| stan::math::coupled_ode_system< F, double, double > | The coupled ode system for known initial values and known parameters |
| stan::math::coupled_ode_system< F, double, stan::agrad::var > | The coupled ODE system for known initial values and unknown parameters |
| stan::math::coupled_ode_system< F, stan::agrad::var, double > | The coupled ODE system for unknown initial values and known parameters |
| stan::math::coupled_ode_system< F, stan::agrad::var, stan::agrad::var > | The coupled ode system for unknown intial values and unknown parameters |
| stan::common::recorder::csv | Writes out a vector as string |
| stan::io::csv_writer | Writes Stan variables in comma-separated-value format to an output stream |
| stan::gm::distribution | |
| stan::gm::division_expr | |
| stan::gm::double_literal | |
| stan::DoubleVectorView< used, is_vec > | DoubleVectorView allocates double values to be used as intermediate values |
| stan::DoubleVectorView< true, false > | |
| stan::DoubleVectorView< true, true > | |
| 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::elt_division_expr | |
| stan::gm::elt_multiplication_expr | |
| empty_range | |
| stan::gm::error_codes | |
| stan::error_index | |
| stan::gm::exponentiation_expr | |
| stan::gm::expr_type | |
| stan::gm::expression | |
| stan::gm::expression_as_statement | |
| stan::common::recorder::filtered_values< InternalVector > | |
| stan::gm::for_statement | |
| stan::gm::fun | |
| stan::gm::function_decl_def | |
| stan::gm::function_decl_defs | |
| stan::gm::function_signatures | |
| stan::agrad::fvar< T > | |
| 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::bare_type_grammar< Iterator > | |
| stan::gm::expression07_grammar< Iterator > | |
| stan::gm::expression_grammar< Iterator > | |
| stan::gm::functions_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, T7, T8, T9, T10 > | Template metaprogram to calculate whether a summand needs to be included in a proportional (log) probability calculation |
| stan::gm::increment_log_prob_statement | |
| stan::gm::index_op | |
| stan::math::index_type< T > | Primary template class for the metaprogram to compute the index type of a container |
| stan::math::index_type< const T > | Template class for metaprogram to compute the type of indexes used in a constant container type |
| stan::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 |
| stan::math::index_type< std::vector< T > > | Template metaprogram class to compute the type of index for a standard vector |
| stan::gm::int_literal | |
| stan::gm::integrate_ode | |
| 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::Block< T > > | |
| stan::is_constant_struct< Eigen::Matrix< T, R, C > > | |
| stan::is_constant_struct< std::vector< T > > | |
| stan::is_fvar< T > | |
| stan::is_fvar< stan::agrad::fvar< T > > | |
| stan::is_var< T > | |
| stan::is_var< stan::agrad::var > | |
| stan::is_var_or_arithmetic< T1, T2, T3, T4, T5, T6 > | |
| stan::is_vector< T > | |
| stan::is_vector< const T > | |
| stan::is_vector< Eigen::Block< 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::json::json_handler | Abstract base class for JSON handlers |
| stan::json::json_data_handler | A json_data_handler is an implementation of a json_handler that restricts the allowed JSON text a set of Stan variable declarations in JSON format |
| stan::optimization::LBFGSUpdate< Scalar, DimAtCompile > | Implement a limited memory version of the BFGS update |
| stan::math::LDLT_factor< T, R, C > | |
| stan::math::LDLT_factor< stan::agrad::var, R, C > | A template specialization of src/stan/math/matrix/LDLT_factor.hpp for stan::agrad::var which can be used with all the *_ldlt functions |
| stan::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 |
| stan::gm::left_division_expr | |
| logic_error | |
| stan::json::json_error | Exception type for JSON errors |
| stan::gm::logical_negate_expr | |
| stan::optimization::LSOptions< Scalar > | |
| stan::io::mcmc_writer< M, SampleRecorder, DiagnosticRecorder, MessageRecorder > | Mcmc_writer writes out headers and samples |
| stan::common::recorder::messages | |
| stan::model::model_functional< M > | |
| stan::optimization::ModelAdaptor< M > | |
| stan::gm::modulus_expr | |
| stan::gm::multiplication_expr | |
| stan::gm::negate_expr | |
| stan::gm::nil | Placeholder struct for boost::variant default ctors |
| stan::common::recorder::no_op | Does nothing |
| stan::gm::no_op_statement | |
| stan::common::NoOpFunctor | |
| std::numeric_limits< stan::agrad::fvar< T > > | |
| 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::mcmc::nuts_util | |
| 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::math::pass_type< T > | |
| stan::math::pass_type< double > | |
| stan::math::pass_type< int > | |
| stan::gm::print_statement | |
| stan::gm::printable | |
| stan::model::prob_grad | The prob_grad class represents the basic parameter holders for a model |
| stan::gm::program | |
| stan::math::promote_scalar_struct< T, S > | General struct to hold static function for promoting underlying scalar types |
| stan::math::promote_scalar_struct< T, Eigen::Matrix< S, 1,-1 > > | Struct to hold static function for promoting underlying scalar types |
| stan::math::promote_scalar_struct< T, Eigen::Matrix< S,-1, 1 > > | Struct to hold static function for promoting underlying scalar types |
| stan::math::promote_scalar_struct< T, Eigen::Matrix< S,-1,-1 > > | Struct to hold static function for promoting underlying scalar types |
| stan::math::promote_scalar_struct< T, std::vector< S > > | Struct to hold static function for promoting underlying scalar types |
| stan::math::promote_scalar_struct< T, T > | Struct to hold static function for promoting underlying scalar types |
| stan::math::promote_scalar_type< T, S > | Template metaprogram to calculate a type for converting a convertible type |
| stan::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 |
| stan::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 |
| stan::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 |
| stan::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 |
| 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::mcmc::ps_point | |
| stan::mcmc::dense_e_point | |
| stan::mcmc::diag_e_point | |
| stan::mcmc::unit_e_point | |
| 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::reject_statement | |
| stan::gm::remove_loop_identifier | |
| stan::gm::unscope_variables::result< T1, T2 > | |
| stan::gm::binary_op_expr::result< T1, T2, T3, T4, T5 > | |
| stan::gm::add_conditional_body::result< T1, T2 > | |
| set_double_range_upper::result< T1, T2, T3, T4 > | |
| validate_int_data_expr::result< T1, T2, T3, T4, T5 > | |
| stan::gm::add_expression_dimss::result< T1, T2, T3, T4 > | |
| stan::gm::logical_negate_expr::result< T1, T2, T3 > | |
| copy_square_cholesky_dimension_if_necessary::result< T1 > | |
| stan::gm::validate_expr_type3::result< T1, T2 > | |
| stan::gm::set_fun_type3::result< T1, T2 > | |
| stan::gm::addition_expr3::result< T1, T2, T3 > | |
| stan::gm::subtraction_expr3::result< T1, T2, T3 > | |
| stan::gm::set_fun_type2::result< T1, T2 > | |
| stan::gm::validate_non_void_arg_function::result< T1, T2, T3 > | |
| stan::gm::set_void_function::result< T1, T2, T3, T4 > | |
| stan::gm::set_allows_sampling_origin::result< T1, T2, T3 > | |
| stan::gm::validate_declarations::result< T1, T2, T3, T4 > | |
| stan::gm::add_function_signature::result< T1, T2, T3, T4, T5 > | |
| stan::gm::validate_return_type::result< T1, T2, T3 > | |
| stan::gm::elt_division_expr::result< T1, T2, T3 > | |
| stan::gm::scope_lp::result< T1 > | |
| stan::gm::add_conditional_condition::result< T1, T2, T3, T4 > | |
| set_int_range_lower::result< T1, T2, T3, T4 > | |
| stan::gm::division_expr::result< T1, T2, T3 > | |
| stan::gm::validate_return_allowed::result< T1, T2, T3 > | |
| stan::gm::validate_void_return_allowed::result< T1, T2, T3 > | |
| stan::gm::validate_assignment::result< T1, T2, T3, T4 > | |
| stan::gm::set_fun_type::result< T1, T2 > | |
| stan::gm::validate_sample::result< T1, T2, T3 > | |
| stan::gm::expression_as_statement::result< T1, T2, T3 > | |
| stan::gm::unscope_locals::result< T1, T2 > | |
| stan::gm::add_while_condition::result< T1, T2, T3 > | |
| stan::gm::add_while_body::result< T1, T2 > | |
| stan::gm::add_loop_identifier::result< T1, T2, T3, T4 > | |
| stan::gm::remove_loop_identifier::result< T1, T2 > | |
| stan::gm::validate_int_expr2::result< T1, T2, T3 > | |
| stan::gm::validate_allow_sample::result< T1, T2, T3 > | |
| stan::gm::validate_non_void_expression::result< T1, T2, T3 > | |
| stan::gm::validate_integrate_ode::result< T1, T2, T3, T4 > | |
| stan::gm::set_fun_type_named::result< T1, T2, T3, T4, T5 > | |
| stan::gm::exponentiation_expr::result< T1, T2, T3, T4, T5 > | |
| stan::gm::multiplication_expr::result< T1, T2, T3 > | |
| stan::gm::modulus_expr::result< T1, T2, T3, T4 > | |
| stan::gm::left_division_expr::result< T1, T2, T3 > | |
| stan::gm::elt_multiplication_expr::result< T1, T2, T3 > | |
| stan::gm::negate_expr::result< T1, T2, T3, T4 > | |
| stan::gm::transpose_expr::result< T1, T2 > | |
| stan::gm::set_var_type::result< T1, T2, T3, T4 > | |
| stan::gm::validate_int_expr3::result< T1, T2 > | |
| add_var::result< T1, T2, T3, T4, T5, T6 > | |
| validate_identifier::result< T1, T2 > | |
| validate_decl_constraints::result< T1, T2, T3, T4 > | |
| empty_range::result< T1 > | |
| validate_int_expr::result< T1, T2, T3 > | |
| validate_double_expr::result< T1, T2 > | |
| set_double_range_lower::result< T1, T2, T3, T4 > | |
| stan::gm::add_fun_var::result< T1, T2, T3, T4 > | |
| set_int_range_upper::result< T1, T2, T3, T4 > | |
| stan::gm::return_statement | |
| 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::gm::sample | |
| stan::mcmc::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::scalar_type_pre< T > | Metaprogram structure to determine the type of first container of the base scalar type of a template argument |
| stan::gm::scope_lp | |
| stan::math::seq_view< T, S > | |
| stan::math::seq_view< double, std::vector< int > > | |
| stan::math::seq_view< T, Eigen::Matrix< S, 1, Eigen::Dynamic > > | |
| stan::math::seq_view< T, Eigen::Matrix< S, Eigen::Dynamic, 1 > > | |
| stan::math::seq_view< T, Eigen::Matrix< S, Eigen::Dynamic, Eigen::Dynamic > > | |
| stan::math::seq_view< T, std::vector< S > > | |
| stan::math::seq_view< T, std::vector< std::vector< T > > > | |
| stan::math::seq_view< T, std::vector< T > > | |
| stan::gm::set_allows_sampling_origin | |
| set_double_range_lower | |
| set_double_range_upper | |
| stan::gm::set_fun_type | |
| stan::gm::set_fun_type2 | |
| stan::gm::set_fun_type3 | |
| stan::gm::set_fun_type_named | |
| set_int_range_lower | |
| set_int_range_upper | |
| stan::gm::set_var_type | |
| stan::gm::set_void_function | |
| 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::io::stan_csv | |
| stan::io::stan_csv_adaptation | |
| stan::io::stan_csv_metadata | |
| stan::io::stan_csv_reader | Reads from a Stan output csv file |
| stan::io::stan_csv_timing | |
| stan::gm::statement | |
| stan::gm::statements | |
| static_visitor | |
| data_only_expression | |
| stan::gm::contains_nonparam_var | |
| stan::gm::contains_var | |
| stan::gm::expression_type_vis | |
| stan::gm::is_nil_op | |
| stan::gm::is_no_op_statement_vis | |
| stan::gm::name_vis | |
| stan::gm::returns_type_vis | |
| stan::math::store_type< T > | |
| stan::math::store_type< double > | |
| stan::math::store_type< Eigen::Matrix< S, 1, Eigen::Dynamic > > | |
| stan::math::store_type< Eigen::Matrix< S, Eigen::Dynamic, 1 > > | |
| stan::math::store_type< Eigen::Matrix< S, Eigen::Dynamic, Eigen::Dynamic > > | |
| stan::math::store_type< int > | |
| stan::math::store_type< S > | |
| stan::math::store_type< std::vector< int > > | |
| stan::math::store_type< std::vector< S > > | |
| stan::math::store_type< std::vector< std::vector< T > > > | |
| stan::math::store_type< std::vector< T > > | |
| stan::gm::subtraction_expr3 | |
| stan::common::recorder::sum_values | |
| stan::gm::transpose_expr | |
| stan::gm::type_name< T > | |
| stan::gm::type_name< bool > | |
| stan::gm::type_name< double > | |
| stan::gm::type_name< int > | |
| stan::gm::type_name< std::string > | |
| stan::gm::type_name< unsigned int > | |
| stan::gm::unary_op | |
| stan::gm::unscope_locals | |
| stan::gm::unscope_variables | |
| stan::gm::validate_allow_sample | |
| stan::gm::validate_assignment | |
| validate_decl_constraints | |
| stan::gm::validate_declarations | |
| validate_double_expr | |
| stan::gm::validate_expr_type3 | |
| validate_identifier | |
| validate_int_data_expr | |
| validate_int_expr | |
| stan::gm::validate_int_expr2 | |
| stan::gm::validate_int_expr3 | |
| stan::gm::validate_integrate_ode | |
| stan::gm::validate_non_void_arg_function | |
| stan::gm::validate_non_void_expression | |
| stan::gm::validate_return_allowed | |
| stan::gm::validate_return_type | |
| stan::gm::validate_sample | |
| stan::gm::validate_void_return_allowed | |
| stan::math::value_type< T > | Primary template class for metaprogram to compute the type of values stored in a container |
| stan::math::value_type< const T > | Template class for metaprogram to compute the type of values stored in a constant container |
| stan::math::value_type< Eigen::Matrix< T, R, C > > | Template metaprogram defining the type of values stored in an Eigen matrix, vector, or row vector |
| stan::math::value_type< std::vector< T > > | Template metaprogram class to compute the type of values stored in a standard vector |
| stan::common::recorder::values< InternalVector > | |
| 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::json::json_data | A json_data is a var_context object that represents a set of named values which are typed to either double or int and can be either scalar value or a non-empty array of values of any dimensionality |
| stan::common::var_context_factory< VARCON > | |
| stan::common::var_context_factory< stan::io::dump > | |
| stan::common::dump_factory | |
| stan::gm::var_decl | |
| stan::gm::variable | |
| stan::gm::variable_dims | |
| stan::gm::variable_map | |
| stan::VectorView< T, is_array, throw_if_accessed > | VectorView is a template metaprogram that takes its argument and allows it to be used like a vector |
| stan::VectorView< const double, false, false > | |
| stan::VectorView< const T, is_array, throw_if_accessed > | VectorView that has const correctness |
| stan::VectorView< double *, stan::is_vector< T1 >::value, stan::is_constant_struct< T1 >::value > | |
| stan::VectorView< double *, stan::is_vector< T2 >::value, stan::is_constant_struct< T2 >::value > | |
| stan::VectorView< double *, stan::is_vector< T3 >::value, stan::is_constant_struct< T3 >::value > | |
| stan::VectorView< double *, stan::is_vector< T4 >::value, stan::is_constant_struct< T4 >::value > | |
| stan::VectorView< double *, stan::is_vector< T5 >::value, stan::is_constant_struct< T5 >::value > | |
| stan::VectorView< double *, stan::is_vector< T6 >::value, stan::is_constant_struct< T6 >::value > | |
| stan::VectorViewMvt< T, is_array, throw_if_accessed > | |
| stan::VectorViewMvt< const T, is_array, throw_if_accessed > | VectorViewMvt that has const correctness |
| stan::gm::visgen | Generic visitor with output for extension |
| stan::gm::constrained_param_names_visgen | |
| stan::gm::dump_member_var_visgen | |
| stan::gm::expression_visgen | |
| stan::gm::generate_init_vars_visgen | |
| stan::gm::generate_init_visgen | |
| stan::gm::generate_local_var_init_nan_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::unconstrained_param_names_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::prob::welford_covar_estimator | |
| stan::prob::welford_var_estimator | |
| 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 |
