  boost | Reimplementing boost functionality |
  math | Reimplmeneting boost functionality for stan::agrad::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::agrad::var, false > | Implemented this for printing to stream |
| scalar_product_traits< stan::agrad::var, double > | Scalar product traits override for Eigen for automatic gradient variables |
| scalar_product_traits< double, stan::agrad::var > | Scalar product traits override for Eigen for automatic gradient variables |
| 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 |
| general_matrix_vector_product< Index, stan::agrad::var, RowMajor, ConjugateLhs, stan::agrad::var, ConjugateRhs > | |
| general_matrix_matrix_product< Index, stan::agrad::var, LhsStorageOrder, ConjugateLhs, stan::agrad::var, RhsStorageOrder, ConjugateRhs, ColMajor > | |
| NumTraits< stan::agrad::var > | Numerical traits template override for Eigen for automatic gradient variables |
| stan | Probability, optimization and sampling library |
| agrad | Function gradients via reverse-mode automatic differentiation |
| fvar | |
| partials_vari | |
| OperandsAndPartials | A variable implementation that stores operands and derivatives with respect to the variable |
| chainable | Abstract base class for variable implementations that handles memory management and applying the chain rule |
| op_ddv_vari | |
| op_dv_vari | |
| op_dvd_vari | |
| op_dvv_vari | |
| op_matrix_vari | |
| precomp_v_vari | |
| precomputed_gradients_vari | This is a var implementation class that takes precomputed gradient values |
| op_v_vari | |
| op_vd_vari | |
| op_vdd_vari | |
| op_vdv_vari | |
| op_vector_vari | |
| op_vv_vari | |
| op_vvd_vari | |
| op_vvv_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 |
| 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 |
| var | Independent (input) and dependent (output) variables for gradients |
| 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 |
| vari | The variable implementation base class |
| common | |
| recorder | |
| csv | Writes out a vector as string |
| filtered_values | |
| messages | |
| no_op | Does nothing |
| sum_values | |
| values | |
| NoOpFunctor | |
| var_context_factory | |
| dump_factory | |
| gm | Directed graphical model compiler |
| arg_adapt | |
| arg_adapt_delta | |
| arg_adapt_engaged | |
| arg_adapt_gamma | |
| arg_adapt_init_buffer | |
| arg_adapt_kappa | |
| arg_adapt_t0 | |
| arg_adapt_term_buffer | |
| arg_adapt_window | |
| arg_bfgs | |
| arg_data | |
| arg_data_file | |
| arg_dense_e | |
| arg_diag_e | |
| arg_diagnose | |
| arg_diagnostic_file | |
| arg_engine | |
| arg_fail | |
| arg_fixed_param | |
| arg_history_size | |
| arg_hmc | |
| arg_id | |
| arg_init | |
| arg_init_alpha | |
| arg_int_time | |
| arg_iter | |
| arg_lbfgs | |
| arg_max_depth | |
| arg_method | |
| arg_metric | |
| arg_newton | |
| arg_num_samples | |
| arg_num_warmup | |
| arg_nuts | |
| arg_optimize | |
| arg_optimize_algo | |
| arg_output | |
| arg_output_file | |
| arg_random | |
| arg_refresh | |
| arg_rwm | |
| arg_sample | |
| arg_sample_algo | |
| arg_save_iterations | |
| arg_save_warmup | |
| arg_seed | |
| arg_static | |
| arg_stepsize | |
| arg_stepsize_jitter | |
| arg_test | |
| arg_test_grad_eps | |
| arg_test_grad_err | |
| arg_test_gradient | |
| arg_thin | |
| arg_tolerance | |
| arg_unit_e | |
| argument | |
| argument_parser | |
| argument_probe | |
| categorical_argument | |
| list_argument | |
| type_name | |
| type_name< int > | |
| type_name< unsigned int > | |
| type_name< double > | |
| type_name< bool > | |
| type_name< std::string > | |
| singleton_argument | |
| unvalued_argument | |
| valued_argument | |
| nil | Placeholder struct for boost::variant default ctors |
| expr_type | |
| function_signatures | |
| statements | |
| distribution | |
| expression_type_vis | |
| expression | |
| printable | |
| is_nil_op | |
| variable_dims | |
| int_literal | |
| double_literal | |
| array_literal | |
| variable | |
| integrate_ode | |
| fun | |
| index_op | |
| binary_op | |
| unary_op | |
| range | |
| base_var_decl | |
| variable_map | |
| int_var_decl | |
| double_var_decl | |
| unit_vector_var_decl | |
| simplex_var_decl | |
| ordered_var_decl | |
| positive_ordered_var_decl | |
| vector_var_decl | |
| row_vector_var_decl | |
| matrix_var_decl | |
| cholesky_factor_var_decl | |
| cholesky_corr_var_decl | |
| cov_matrix_var_decl | |
| corr_matrix_var_decl | |
| name_vis | |
| var_decl | |
| statement | |
| is_no_op_statement_vis | |
| returns_type_vis | |
| increment_log_prob_statement | |
| for_statement | |
| conditional_statement | |
| while_statement | |
| print_statement | |
| reject_statement | |
| return_statement | |
| no_op_statement | |
| arg_decl | |
| function_decl_def | |
| function_decl_defs | |
| program | |
| sample | |
| assignment | |
| contains_var | |
| contains_nonparam_var | |
| error_codes | |
| visgen | Generic visitor with output for extension |
| expression_visgen | |
| printable_visgen | |
| var_size_validating_visgen | |
| var_resizing_visgen | |
| init_local_var_visgen | |
| validate_var_decl_visgen | |
| member_var_decl_visgen | |
| local_var_decl_visgen | |
| generate_local_var_init_nan_visgen | |
| generate_init_vars_visgen | |
| validate_transformed_params_visgen | |
| statement_visgen | |
| dump_member_var_visgen | |
| set_param_ranges_visgen | |
| generate_init_visgen | |
| write_dims_visgen | |
| write_param_names_visgen | |
| write_csv_header_visgen | |
| constrained_param_names_visgen | |
| unconstrained_param_names_visgen | |
| write_csv_visgen | |
| write_csv_vars_visgen | |
| write_array_visgen | |
| write_array_vars_visgen | |
| bare_type_grammar | |
| term_grammar | |
| expression_grammar | |
| expression07_grammar | |
| validate_expr_type3 | |
| result | |
| set_fun_type3 | |
| result | |
| addition_expr3 | |
| result | |
| subtraction_expr3 | |
| result | |
| set_fun_type2 | |
| result | |
| binary_op_expr | |
| result | |
| functions_grammar | |
| validate_non_void_arg_function | |
| result | |
| set_void_function | |
| result | |
| set_allows_sampling_origin | |
| result | |
| validate_declarations | |
| result | |
| add_function_signature | |
| result | |
| validate_return_type | |
| result | |
| scope_lp | |
| result | |
| unscope_variables | |
| result | |
| add_fun_var | |
| result | |
| program_grammar | |
| statement_grammar | |
| statement_2_grammar | |
| add_conditional_condition | |
| result | |
| add_conditional_body | |
| result | |
| validate_return_allowed | |
| result | |
| validate_void_return_allowed | |
| result | |
| validate_assignment | |
| result | |
| validate_sample | |
| result | |
| expression_as_statement | |
| result | |
| unscope_locals | |
| result | |
| add_while_condition | |
| result | |
| add_while_body | |
| result | |
| add_loop_identifier | |
| result | |
| remove_loop_identifier | |
| result | |
| validate_int_expr2 | |
| result | |
| validate_allow_sample | |
| result | |
| validate_non_void_expression | |
| result | |
| validate_integrate_ode | |
| result | |
| set_fun_type | |
| result | |
| set_fun_type_named | |
| result | |
| exponentiation_expr | |
| result | |
| multiplication_expr | |
| result | |
| division_expr | |
| result | |
| modulus_expr | |
| result | |
| left_division_expr | |
| result | |
| elt_multiplication_expr | |
| result | |
| elt_division_expr | |
| result | |
| negate_expr | |
| result | |
| logical_negate_expr | |
| result | |
| transpose_expr | |
| result | |
| add_expression_dimss | |
| result | |
| set_var_type | |
| result | |
| validate_int_expr3 | |
| result | |
| var_decls_grammar | |
| whitespace_grammar | |
| io | Input/output utilities |
| cmd_line | Parses and stores command-line arguments |
| csv_writer | Writes Stan variables in comma-separated-value format to an output stream |
| dump_writer | Writes data into the S-plus dump format |
| dump_reader | Reads data from S-plus dump format |
| dump | Represents named arrays with dimensions |
| mcmc_writer | Mcmc_writer writes out headers and samples |
| reader | A stream-based reader for integer, scalar, vector, matrix and array data types, with Jacobian calculations |
| stan_csv_metadata | |
| stan_csv_adaptation | |
| stan_csv_timing | |
| stan_csv | |
| stan_csv_reader | Reads from a Stan output csv file |
| var_context | A var_reader reads array variables of integer and floating point type by name and dimension |
| writer | A stream-based writer for integer, scalar, vector, matrix and array data types, which transforms from constrained to a sequence of constrained variables |
| 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 |
| 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 |
| json_error | Exception type for JSON errors |
| json_handler | Abstract base class for JSON handlers |
| math | Matrices and templated mathematical functions |
| detail | |
| bounded | |
| bounded< T_y, T_low, T_high, T_result, true > | |
| policies | Extending boost functionality |
| detail | Reimplementing boost::math::policies::detail::raise_domain_error |
| 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 |
| coupled_ode_system< F, double, stan::agrad::var > | The coupled ODE system for known initial values and unknown parameters |
| coupled_ode_system< F, stan::agrad::var, double > | The coupled ODE system for unknown initial values and known parameters |
| coupled_ode_system< F, stan::agrad::var, stan::agrad::var > | The coupled ode system for unknown intial values and unknown parameters |
| 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 |
| 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 |
| index_type< Eigen::Matrix< T, R, C > > | Template metaprogram defining typedef for the type of index for an Eigen matrix, vector, or row vector |
| 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< 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 > > | |
| 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 |
| index_type< std::vector< T > > | Template metaprogram class to compute the type of index for a standard vector |
| 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 |
| 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 |
| 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 > > | |
| mcmc | Markov chain Monte Carlo samplers |
| base_adaptation | |
| base_adapter | |
| base_mcmc | |
| chains | An mcmc::chains object stores parameter names and dimensionalities along with samples from multiple chains |
| covar_adaptation | |
| fixed_param_sampler | |
| base_hmc | |
| base_hamiltonian | |
| dense_e_metric | |
| dense_e_point | |
| diag_e_metric | |
| diag_e_point | |
| ps_point | |
| unit_e_metric | |
| unit_e_point | |
| base_integrator | |
| base_leapfrog | |
| expl_leapfrog | |
| adapt_dense_e_nuts | |
| adapt_diag_e_nuts | |
| adapt_unit_e_nuts | |
| nuts_util | |
| base_nuts | |
| dense_e_nuts | |
| diag_e_nuts | |
| unit_e_nuts | |
| adapt_dense_e_static_hmc | |
| adapt_diag_e_static_hmc | |
| adapt_unit_e_static_hmc | |
| base_static_hmc | |
| dense_e_static_hmc | |
| diag_e_static_hmc | |
| unit_e_static_hmc | |
| sample | |
| stepsize_adaptation | |
| stepsize_adapter | |
| stepsize_covar_adapter | |
| stepsize_var_adapter | |
| var_adaptation | |
| windowed_adaptation | |
| memory | (Expert) Allocate, free, and manage underlying system 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 |
| model | For compiling models |
| prob_grad | The prob_grad class represents the basic parameter holders for a model |
| model_functional | |
| optimization | |
| ConvergenceOptions | |
| LSOptions | |
| BFGSMinimizer | |
| ModelAdaptor | |
| BFGSLineSearch | |
| BFGSUpdate_HInv | |
| LBFGSUpdate | Implement a limited memory version of the BFGS update |
| prob | Templated probability distributions |
| include_summand | Template metaprogram to calculate whether a summand needs to be included in a proportional (log) probability calculation |
| welford_covar_estimator | |
| welford_var_estimator | |
| 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_vector | |
| 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 > > | |
| scalar_type | Metaprogram structure to determine the base scalar type of a template argument |
| size_of_helper | |
| size_of_helper< T, true > | |
| scalar_type< Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > > | |
| scalar_type< T * > | |
| is_vector_like | |
| is_vector_like< T * > | |
| is_vector_like< const T > | |
| is_vector_like< Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > > | |
| 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 > | |
| DoubleVectorView | DoubleVectorView allocates double values to be used as intermediate values |
| DoubleVectorView< true, false > | |
| DoubleVectorView< true, true > | |
| return_type | Metaprogram to calculate the base scalar return type resulting from promoting all the scalar types of the template parameters |
| is_fvar | |
| is_fvar< stan::agrad::fvar< T > > | |
| is_var | |
| is_var< stan::agrad::var > | |
| contains_fvar | Metaprogram to calculate the base scalar return type resulting from promoting all the scalar types of the template parameters |
| is_var_or_arithmetic | |
| scalar_type_pre | Metaprogram structure to determine the type of first container of the base scalar type of a template argument |
| VectorViewMvt | |
| VectorViewMvt< const T, is_array, throw_if_accessed > | VectorViewMvt that has const correctness |
| std | Template specification of functions in std for Stan |
| numeric_limits< stan::agrad::fvar< T > > | |
| numeric_limits< stan::agrad::var > | Specialization of numeric limits for var objects |
| add_var | |
| result | |
| copy_square_cholesky_dimension_if_necessary | |
| result | |
| data_only_expression | |
| empty_range | |
| result | |
| set_double_range_lower | |
| result | |
| set_double_range_upper | |
| result | |
| set_int_range_lower | |
| result | |
| set_int_range_upper | |
| result | |
| validate_decl_constraints | |
| result | |
| validate_double_expr | |
| result | |
| validate_identifier | |
| result | |
| validate_int_data_expr | |
| result | |
 validate_int_expr | |
 result | |
