stan::math Namespace Reference

Detailed Description

Matrices and templated mathematical functions.

Templated probability distributions. All paramaterizations are based on Bayesian Data Analysis. Function gradients via reverse-mode automatic differentiation.

Namespaces
namespace	internal
	A comparator that works for any container type that has the brackets operator.
namespace	opencl
namespace	opencl_kernels

Classes
struct	abs_fun
	Return elementwise absolute value of the specified real-valued container. More...
class	accumulator
	Class to accumulate values and eventually return their sum. More...
class	accumulator< T, require_var_t< T > >
	Class to accumulate values and eventually return their sum. More...
class	acos_
struct	acos_fun
	Structure to wrap acos() so it can be vectorized. More...
class	acosh_
struct	acosh_fun
	Structure to wrap acosh() so it can be vectorized. More...
struct	ad_promotable
	If the type From can be converted to To using implicit conversions, or both From and To are possibly cv-qualified void), provides the member constant value equal to true. More...
class	ad_tape_observer
	TBB observer object which is a callback hook called whenever the TBB scheduler adds a new thread to the TBB managed threadpool. More...
class	addition_
class	addition_operator_
class	adjoint_results_cl
	Represents results that are adjoints of vars in kernel generrator expressions. More...
class	append_col_
	Represents appending of cols in kernel generator expressions. More...
struct	append_return_type
	This template metaprogram is used to compute the return type for append_array. More...
struct	append_return_type< Eigen::Matrix< T1, R, C >, Eigen::Matrix< T2, R, C > >
	This template metaprogram is used to compute the return type for append_array. More...
struct	append_return_type< int, int >
	This template metaprogram is used to compute the return type for append_array. More...
struct	append_return_type< std::vector< T1 >, std::vector< T2 > >
	This template metaprogram is used to compute the return type for append_array. More...
class	append_row_
	Represents appending of rows in kernel generator expressions. More...
struct	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. More...
struct	apply_scalar_unary< F, fvar< T > >
	Template specialization to fvar for vectorizing a unary scalar function. More...
struct	apply_scalar_unary< F, std::vector< T > >
	Template specialization for vectorized functions applying to standard vector containers. More...
struct	apply_scalar_unary< F, T, require_complex_t< T > >
	Template specialization for vectorized functions applying to complex arguments. More...
struct	apply_scalar_unary< F, T, require_eigen_t< T > >
	Template specialization for vectorized functions applying to Eigen matrix arguments. More...
struct	apply_scalar_unary< F, T, require_floating_point_t< T > >
	Template specialization for vectorized functions applying to double arguments. More...
struct	apply_scalar_unary< F, T, require_integral_t< T > >
	Template specialization for vectorized functions applying to integer arguments. More...
struct	apply_scalar_unary< F, T, require_var_matrix_t< T > >
struct	apply_scalar_unary< F, var >
	Template specialization to var for vectorizing a unary scalar function. More...
struct	apply_vector_unary
struct	apply_vector_unary< T, require_eigen_t< T > >
	Base template class for vectorization of unary vector functions defined by applying a functor to a standard library vector, Eigen dense matrix expression template, or container of these. More...
struct	apply_vector_unary< T, require_std_vector_vt< is_container_or_var_matrix, T > >
	Specialization for use with nested containers (std::vectors). More...
struct	apply_vector_unary< T, require_std_vector_vt< is_stan_scalar, T > >
	Specialization for use with (non-nested) std::vectors. More...
struct	apply_vector_unary< T, require_var_matrix_t< T > >
	Specialization for use with var_value<T> types where T inherits from EigenBase. More...
struct	arena_allocator
	std library compatible allocator that uses AD stack. More...
class	arena_matrix
	Equivalent to Eigen::Matrix, except that the data is stored on AD stack. More...
class	arena_matrix< MatrixType, require_eigen_dense_base_t< MatrixType > >
class	arena_matrix< MatrixType, require_eigen_sparse_base_t< MatrixType > >
class	arena_matrix_cl
	A variant of matrix_cl that schedules its destructor to be called, so it can be used on the AD stack. More...
class	array_builder
	Structure for building up arrays in an expression (rather than in statements) using an argument-chaining add() method and a getter method array() to return the result. More...
class	as_column_vector_or_scalar_
	Represents as_column_vector_or_scalar of a row or column vector in kernel generator expressions. More...
class	asin_
struct	asin_fun
	Structure to wrap asin() so it can be vectorized. More...
class	asinh_
struct	asinh_fun
	Structure to wrap asinh() so it can be vectorized. More...
class	atan_
struct	atan_fun
	Structure to wrap atan() so it can be vectorized. More...
class	atanh_
struct	atanh_fun
	Structure to wrap atanh() so it can be vectorized. More...
struct	AutodiffStackSingleton
	This struct always provides access to the autodiff stack using the singleton pattern. More...
class	beta_
class	binary_operation
	Represents a binary operation in kernel generator expressions. More...
class	binomial_coefficient_log_
class	block_
	Represents submatrix block in kernel generator expressions. More...
class	broadcast_
	Represents a broadcasting operation in kernel generator expressions. More...
class	calc_if_
	Represents a calc_if in kernel generator expressions. More...
class	cast_
	Represents a typecast os scalar in kernel generator expressions. More...
class	cbrt_
struct	cbrt_fun
	Structure to wrap cbrt() so it can be vectorized. More...
class	ceil_
struct	ceil_fun
	Structure to wrap ceil() so it can be vectorized. More...
class	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. More...
class	chainable_object
	chainable_object hold another object is useful for connecting the lifetime of a specific object to the chainable stack More...
class	check_cl_
	Represents a check in kernel generator expressions. More...
class	col_index
	Represents operation that determines column index. More...
class	colwise_max_
	Represents column wise max - reduction in kernel generator expressions. More...
class	colwise_min_
	Represents column wise min - reduction in kernel generator expressions. More...
class	colwise_prod_
	Represents column wise product - reduction in kernel generator expressions. More...
class	colwise_reduction
	Represents a column wise reduction in kernel generator expressions. More...
class	colwise_sum_
	Represents column wise sum - reduction in kernel generator expressions. More...
class	complex_base
	Base class for complex numbers. More...
struct	conjunction
	Extends std::true_type when instantiated with zero or more template parameters, all of which extend the std::true_type. More...
struct	conjunction< T, Ts... >
class	constant_
	Represents a matrix of single repeated value in kernel generator expressions. More...
class	copysign_
class	cos_
struct	cos_fun
	Structure to wrap cos() so it can be vectorized. More...
class	cosh_
struct	cosh_fun
	Structure to wrap cosh() so it can be vectorized. More...
struct	coupled_ode_system
struct	coupled_ode_system_impl
struct	coupled_ode_system_impl< false, F, T_y0, Args... >
	The coupled_ode_system_impl template specialization when the state or parameters are autodiff types. More...
struct	coupled_ode_system_impl< true, F, T_y0, Args... >
	The coupled_ode_system_impl for arithmetic arguments reduces to the regular ode system (there are no sensitivities) More...
class	cov_exp_quad_vari
class	cov_exp_quad_vari< T_x, double, T_l >
class	cvodes_integrator
	Integrator interface for CVODES' ODE solvers (Adams & BDF methods). More...
class	cvodes_integrator_adjoint_vari
	Integrator interface for CVODES' adjoint ODE solvers (Adams & BDF methods). More...
class	dae_system
	IDAS DAE system that contains information on residual equation functor, sensitivity residual equation functor, as well as initial conditions. More...
struct	deserializer
	A class to store a sequence of values which can be deserialized back into structured objects such as scalars, vectors, and matrices. More...
class	diagonal_
	Represents diagonal of a matrix (as column vector) in kernel generator expressions. More...
class	digamma_
struct	digamma_fun
	Structure to wrap digamma() so it can be vectorized. More...
struct	disjunction
	Extends std::false_type when instantiated with zero or more template parameters, all of which extend the std::false_type. More...
struct	disjunction< Cond, Conds... >
class	elt_divide_
class	elt_function_cl
	Represents an element-wise function in kernel generator expressions. More...
class	elt_modulo_
class	elt_multiply_
class	equals_
class	erf_
struct	erf_fun
	Structure to wrap erf() so it can be vectorized. More...
class	erfc_
struct	erfc_fun
	Structure to wrap the erfc() so that it can be vectorized. More...
class	exp2_
struct	exp2_fun
	Structure to wrap exp2() so it can be vectorized. More...
class	exp_
struct	exp_fun
	Structure to wrap exp() so that it can be vectorized. More...
class	expm1_
struct	expm1_fun
	Structure to wrap expm1() so that it can be vectorized. More...
class	expressions_cl
	Represents multiple expressions that will be calculated in same kernel. More...
class	fabs_
struct	fabs_fun
	Structure to wrap fabs() so that it can be vectorized. More...
class	fdim_
struct	FixedPointADJac
	Calculate Jacobian Jxy(Jacobian of unknown x w.r.t. More...
struct	FixedPointSolver
	Fixed point solver for problem of form. More...
struct	FixedPointSolver< KinsolFixedPointEnv< F >, fp_jac_type >
	Specialization for fixed point solver when using KINSOL. More...
class	floor_
struct	floor_fun
	Structure to wrap floor() so that it can be vectorized. More...
class	fmax_
class	fmin_
class	fmod_
struct	fvar
	This template class represents scalars used in forward-mode automatic differentiation, which consist of values and directional derivatives of the specified template type. More...
class	gevv_vvv_vari
class	greater_than_
class	greater_than_or_equal_
class	Holder
	A no-op Eigen operation. More...
class	holder_cl_
	Represents a no-op in kernel generator expressions. More...
struct	hybrj_functor_solver
	A functor with the required operators to call Eigen's algebraic solver. More...
class	hypot_
class	idas_integrator
	IDAS DAE integrator. More...
struct	idas_service
	For each type of Ode(with different rhs functor F and senstivity parameters), we allocate mem and workspace for idas. More...
struct	include_summand
	Template metaprogram to calculate whether a summand needs to be included in a proportional (log) probability calculation. More...
struct	include_summand< propto, T >
	true if a term with the specified propto value and subterm types should be included in a proportionality calculation. More...
struct	index_type
	Primary template class for the metaprogram to compute the index type of a container. More...
struct	index_type< T, require_eigen_t< T > >
	Template metaprogram defining typedef for the type of index for an Eigen matrix, vector, or row vector. More...
struct	index_type< T, require_std_vector_t< T > >
	Template metaprogram class to compute the type of index for a standard vector. More...
struct	index_type< T, std::enable_if_t< std::is_pointer< T >::value > >
	Specialization of index_type for pointers. More...
class	indexing_
	Represents indexing of a matrix with two matrices of indices. More...
struct	inv_cloglog_fun
	Structure to wrap inv_cloglog() so that it can be vectorized. More...
struct	inv_erfc_fun
	Structure to wrap the inv_erfc() function so that it can be vectorized. More...
struct	inv_fun
	Structure to wrap 1.0 / x so that it can be vectorized. More...
class	inv_logit_
struct	inv_logit_fun
	Structure to wrap inv_logit() so that it can be vectorized. More...
class	inv_Phi_
struct	inv_Phi_fun
	Structure to wrap inv_Phi() so it can be vectorized. More...
struct	inv_sqrt_fun
	Structure to wrap 1 / sqrt(x) so that it can be vectorized. More...
class	inv_square_
struct	is_tuple
class	isfinite_
class	isinf_
class	isnan_
struct	kernel_parts
	Parts of an OpenCL kernel, generated by an expression. More...
class	kinsol_system_data
	KINSOL algebraic system data holder. More...
struct	KinsolFixedPointEnv
	KINSOL algebraic system data holder that handles construction & destruction of SUNDIALS data, as well as auxiliary data that will be used for functor evaluation. More...
class	lbeta_
class	ldexp_
class	LDLT_factor
	LDLT_factor is a structure that holds a matrix of type T and the LDLT of its values. More...
class	LDLT_factor< T, require_eigen_matrix_dynamic_vt< is_var, T > >
	An LDLT_factor of an Eigen::Matrix<var, Eigen::Dynamic, Eigen::Dynamic> with alloc_in_arena = True holds a copy of the input matrix and the LDLT of its values, with all member variable allocations are done in the arena. More...
class	LDLT_factor< T, require_var_matrix_t< T > >
	An LDLT_factor of a var_value<Eigen::MatrixXd> holds a copy of the input var_value and the LDLT of its values. More...
class	LDLT_factor< T, std::enable_if_t< bool_constant< is_eigen_matrix_dynamic< T >::value &&!is_var< scalar_type_t< T > >::value >::value > >
	An LDLT_factor is a structure that holds a matrix of type T and the LDLT of its values. More...
class	less_than_
class	less_than_or_equal_
class	lgamma_
struct	lgamma_fun
	Structure to wrap lgamma() so that it can be vectorized. More...
class	lmultiply_
class	load_
	Represents an access to a matrix_cl in kernel generator expressions. More...
class	log10_
struct	log10_fun
	Structure to wrap log10() so it can be vectorized. More...
class	log1m_
class	log1m_exp_
struct	log1m_exp_fun
	Structure to wrap log1m_exp() so it can be vectorized. More...
struct	log1m_fun
	Structure to wrap log1m() so it can be vectorized. More...
class	log1m_inv_logit_
struct	log1m_inv_logit_fun
	Structure to wrap log1m_inv_logit() so it can be vectorized. More...
class	log1p_
class	log1p_exp_
struct	log1p_exp_fun
	Structure to wrap log1p_exp() so that it can be vectorized. More...
struct	log1p_fun
	Structure to wrap log1p() so it can be vectorized. More...
class	log2_
struct	log2_fun
	Structure to wrap log2() so it can be vectorized. More...
class	log_
class	log_diff_exp_
struct	log_fun
	Structure to wrap log() so that it can be vectorized. More...
class	log_inv_logit_
class	log_inv_logit_diff_
struct	log_inv_logit_fun
	Structure to wrap log_inv_logit() so it can be vectorized. More...
class	logical_and_
class	logical_negation_
	Represents a logical negation in kernel generator expressions. More...
class	logical_or_
class	logit_
struct	logit_fun
	Structure to wrap logit() so it can be vectorized. More...
class	matrix_cl
	Represents an arithmetic matrix on the OpenCL device. More...
class	matrix_cl_base
	Non-templated base class for matrix_cl simplifies checking if something is matrix_cl. More...
class	matrix_exp_action_handler
	The implementation of the work by Awad H. More...
class	max_2d_
	Represents two dimensional max - reduction in kernel generator expressions. More...
struct	max_op
	Operation for max reduction. More...
class	min_2d_
	Represents two dimensional min - reduction in kernel generator expressions. More...
struct	min_op
	Operation for min reduction. More...
struct	mpi_cluster
	MPI cluster holds MPI resources and must be initialized only once in any MPI program. More...
struct	mpi_command
	A MPI command object is used to execute code on worker nodes. More...
struct	mpi_distributed_apply
	MPI command template which calls the static method distributed_apply of the given class F. More...
class	mpi_is_in_use
	Exception thrown whenever the MPI resource is busy. More...
class	mpi_parallel_call
	The MPI parallel call class manages the distributed evaluation of a collection of tasks following the map - reduce - combine pattern. More...
class	mpi_stop_listen
	Exception used to stop workers nodes from further listening to commands send from the root. More...
struct	mpi_stop_worker
	MPI command used to stop childs nodes from listening for further commands. More...
class	multiply_log_
class	name_generator
	Unique name generator for variables used in generated kernels. More...
class	nested_rev_autodiff
	A class following the RAII idiom to start and recover nested autodiff scopes. More...
struct	nlo_functor
	A structure which gets passed to Eigen's dogleg algebraic solver. More...
class	not_equals_
class	op_ddv_vari
class	op_dv_vari
class	op_dvd_vari
class	op_dvv_vari
class	op_matrix_vari
class	op_v_vari
class	op_vd_vari
class	op_vdd_vari
class	op_vdv_vari
class	op_vector_vari
class	op_vv_vari
class	op_vvd_vari
class	op_vvv_vari
class	opencl_code_
	Represents custom code in kernel generator expressions. More...
class	opencl_code_output
	Represents output variable of custom code in kernel generator expressions. More...
class	opencl_context
	The API to access the methods and values in opencl_context_base. More...
class	opencl_context_base
	The opencl_context_base class represents an OpenCL context in the standard Meyers singleton design pattern. More...
class	operands_and_partials
	This template builds partial derivatives with respect to a set of operands. More...
class	operands_and_partials< Op1, Op2, Op3, Op4, Op5, Op6, Op7, Op8, fvar< Dx > >
	This class builds partial derivatives with respect to a set of operands. More...
class	operands_and_partials< Op1, Op2, Op3, Op4, Op5, Op6, Op7, Op8, var >
	This class builds partial derivatives with respect to a set of operands. More...
class	operation_cl
	Base for all kernel generator operations. More...
class	operation_cl_lhs
	Base for all kernel generator operations that can be used on left hand side of an expression. More...
class	optional_broadcast_
	Represents an optional broadcasting operation in kernel generator expressions. More...
struct	pass_type
struct	pass_type< double >
struct	pass_type< int >
class	Phi_
class	Phi_approx_
struct	Phi_approx_fun
	Structure to wrap Phi_approx() so it can be vectorized. More...
struct	Phi_fun
	Structure to wrap Phi() so it can be vectorized. More...
class	pinned_matrix
	Equivalent to Eigen::Matrix, except that the data is stored in (hopefully pinned) memory, allocated by OpenCL driver. More...
class	pow_
class	precomp_vv_vari
class	precomp_vvv_vari
class	precomputed_gradients_vari_template
	A variable implementation taking a sequence of operands and partial derivatives with respect to the operands. More...
class	prod_2d_
	Represents two dimensional product - reduction in kernel generator expressions. More...
struct	prod_op
	Operation for product reduction. More...
class	profile
	Profiles C++ lines where the object is in scope. More...
class	profile_info
	Class used for storing profiling information. More...
struct	promote_elements
	Struct with static function for elementwise type promotion. More...
struct	promote_elements< Eigen::Matrix< T, R, C >, Eigen::Matrix< S, R, C > >
	Struct with static function for elementwise type promotion. More...
struct	promote_elements< Eigen::Matrix< T, R, C >, Eigen::Matrix< T, R, C > >
	Struct with static function for elementwise type promotion. More...
struct	promote_elements< std::vector< T >, std::vector< S > >
	Struct with static function for elementwise type promotion. More...
struct	promote_elements< std::vector< T >, std::vector< T > >
	Struct with static function for elementwise type promotion. More...
struct	promote_elements< T, T >
	Struct with static function for elementwise type promotion. More...
struct	promote_scalar_type
	Template metaprogram to calculate a type for converting a convertible type. More...
struct	promote_scalar_type< std::tuple< PromotionScalars... >, std::tuple< UnPromotedTypes... > >
struct	promote_scalar_type< T, S, require_all_t< is_var< T >, is_var< S >, is_eigen< value_type_t< S > > > >
	Specialization for var_value when the type to convert to is a var_value. More...
struct	promote_scalar_type< T, S, require_all_t< std::is_arithmetic< T >, is_var< S >, is_eigen< value_type_t< S > > > >
	Specialization for var_value when the type to convert to is arithmetic. More...
struct	promote_scalar_type< T, S, require_eigen_dense_base_t< S > >
	Template metaprogram to calculate a type for a matrix, vector, row vector or Eigen::Array whose underlying scalar is converted from the second template parameter type to the first. More...
struct	promote_scalar_type< T, S, require_eigen_sparse_base_t< S > >
struct	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. More...
class	read_fvar_functor
	Functor for extracting the values and tangents from a matrix of fvar. More...
class	reduction_2d
	Represents a two dimensional reduction in kernel generator expressions. More...
struct	ref_type_for_opencl
	Determines appropriate type for assigning expression of given type to, so that the resulting type has directly accessible contiguous colum-major data, which is needed to copy to OpenCL device for construction of matrix_cl. More...
struct	ref_type_for_opencl< T, require_arena_matrix_t< T > >
struct	ref_type_for_opencl< T, require_not_eigen_t< T > >
class	results_cl
	Represents results that will be calculated in same kernel. More...
class	round_
struct	round_fun
	Structure to wrap round() so it can be vectorized. More...
class	row_index
	Represents operation that determines row index. More...
class	rowwise_max_
	Represents rowwise max reduction in kernel generator expressions. More...
class	rowwise_min_
	Represents rowwise min reduction in kernel generator expressions. More...
class	rowwise_prod_
	Represents rowwise product reduction in kernel generator expressions. More...
class	rowwise_reduction
	Represents a rowwise reduction in kernel generator expressions. More...
class	rowwise_sum_
	Represents rowwise sum reduction in kernel generator expressions. More...
class	rsqrt_
class	scalar_
	Represents a scalar in kernel generator expressions. More...
class	ScopedChainableStack
	The AD tape of reverse mode AD is by default stored globally within the process (or thread). More...
class	select_
	Represents a selection operation in kernel generator expressions. More...
class	seq_view
class	seq_view< double, std::vector< int > >
class	seq_view< T, Eigen::Matrix< S, 1, Eigen::Dynamic > >
class	seq_view< T, Eigen::Matrix< S, Eigen::Dynamic, 1 > >
class	seq_view< T, Eigen::Matrix< S, Eigen::Dynamic, Eigen::Dynamic > >
class	seq_view< T, std::vector< S > >
class	seq_view< T, std::vector< std::vector< T > > >
class	seq_view< T, std::vector< T > >
struct	serializer
	A structure to serialize structures to an internal stored sequence of scalars. More...
struct	sign_fun
	Structure to wrap sign() so it can be vectorized. More...
class	sin_
struct	sin_fun
	Structure to wrap sin() so it can be vectorized. More...
class	sinh_
struct	sinh_fun
	Structure to wrap sinh() so that it can be vectorized. More...
class	sqrt_
struct	sqrt_fun
	Structure to wrap sqrt() so that it can be vectorized. More...
class	square_
struct	square_fun
	Structure to wrap square() so that it can be vectorized. More...
class	stack_alloc
	An instance of this class provides a memory pool through which blocks of raw memory may be allocated and then collected simultaneously. More...
struct	std_normal_log_qf_fun
	Structure to wrap std_normal_log_qf() so it can be vectorized. More...
struct	step_fun
	Structure to wrap step() so it can be vectorized. More...
struct	store_type
struct	store_type< double >
struct	store_type< int >
class	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 autodiff memory stack. More...
class	subtraction_
class	subtraction_operator_
class	sum_2d_
	Represents two dimensional sum - reduction in kernel generator expressions. More...
struct	sum_op
	Operation for sum reduction. More...
class	tan_
struct	tan_fun
	Structure to wrap tan() so that it can be vectorized. More...
class	tanh_
struct	tanh_fun
	Structure to wrap tanh() so that it can be vectorized. More...
class	tgamma_
struct	tgamma_fun
	Structure to wrap tgamma() so that it can be vectorized. More...
struct	to_int_fun
	Return elementwise integer value of the specified real-valued container. More...
class	transpose_
	Represents a transpose in kernel generator expressions. More...
class	trigamma_
struct	trigamma_fun
	Structure to wrap trigamma() so it can be vectorized. More...
class	trunc_
struct	trunc_fun
	Structure to wrap trunc() so it can be vectorized. More...
class	unary_minus_
	Represents an unary minus operation in kernel generator expressions. More...
class	unary_operation_cl
	Represents a unary operation in kernel generator expressions. More...
class	unsafe_chainable_object
	unsafe_chainable_object hold another object and is useful for connecting the lifetime of a specific object to the chainable stack. More...
class	val_adj_functor
	Functor for extracting the values and adjoints from a matrix of var or vari. More...
class	var_value
class	var_value< T, internal::require_matrix_var_value< T > >
	Independent (input) and dependent (output) variables for gradients. More...
class	var_value< T, require_floating_point_t< T > >
	Independent (input) and dependent (output) variables for gradients. More...
class	vari_base
	Abstract base class that all vari_value and it's derived classes inherit. More...
class	vari_cl_base
class	vari_value
class	vari_value< T, require_all_t< is_plain_type< T >, is_eigen_dense_base< T > > >
	The variable implementation for Eigen dense matrix types. More...
class	vari_value< T, require_eigen_sparse_base_t< T > >
	The variable implementation for Eigen sparse matrix types. More...
class	vari_value< T, require_matrix_cl_t< T > >
	The variable implementation for matrix_cl. More...
class	vari_value< T, require_t< std::is_floating_point< T > > >
	The variable implementation for floating point types. More...
class	vari_view
	A vari_view is used to read from a slice of a vari_value with an inner eigen type. More...
class	vari_view< T, require_all_t< is_eigen< T >, bool_constant<!is_plain_type< T >::value > > >
class	vari_view< T, require_kernel_expression_lhs_t< T > >
class	vari_view_eigen
	This struct is follows the CRTP for methods common to vari_view<> and vari_value<Matrix>. More...
class	vi_adj_functor
	Functor for extracting the varis and adjoints from a matrix of var. More...
class	vi_val_adj_functor
	Functor for extracting the vari*, values, and adjoints from a matrix of var. More...
class	vi_val_functor
	Functor for extracting the varis and values from a matrix of var. More...
class	welford_covar_estimator
class	welford_var_estimator

Typedefs
using	size_type = Eigen::Matrix< double, Eigen::Dynamic, Eigen::Dynamic >::Index
	Type for sizes and indexes in an Eigen matrix with double elements.
using	matrix_fd = Eigen::Matrix< fvar< double >, Eigen::Dynamic, Eigen::Dynamic >
using	matrix_ffd = Eigen::Matrix< fvar< fvar< double > >, Eigen::Dynamic, Eigen::Dynamic >
using	vector_fd = Eigen::Matrix< fvar< double >, Eigen::Dynamic, 1 >
using	vector_ffd = Eigen::Matrix< fvar< fvar< double > >, Eigen::Dynamic, 1 >
using	row_vector_fd = Eigen::Matrix< fvar< double >, 1, Eigen::Dynamic >
using	row_vector_ffd = Eigen::Matrix< fvar< fvar< double > >, 1, Eigen::Dynamic >
using	matrix_fv = Eigen::Matrix< fvar< var >, Eigen::Dynamic, Eigen::Dynamic >
using	matrix_ffv = Eigen::Matrix< fvar< fvar< var > >, Eigen::Dynamic, Eigen::Dynamic >
using	vector_fv = Eigen::Matrix< fvar< var >, Eigen::Dynamic, 1 >
using	vector_ffv = Eigen::Matrix< fvar< fvar< var > >, Eigen::Dynamic, 1 >
using	row_vector_fv = Eigen::Matrix< fvar< var >, 1, Eigen::Dynamic >
using	row_vector_ffv = Eigen::Matrix< fvar< fvar< var > >, 1, Eigen::Dynamic >
template<typename T , assign_op_cl AssignOp = assign_op_cl::equals>
using	as_operation_cl_t = std::conditional_t< std::is_lvalue_reference< T >::value, decltype(as_operation_cl< AssignOp >(std::declval< T >())), std::remove_reference_t< decltype(as_operation_cl< AssignOp >(std::declval< T >()))> >
	Type that results when converting any valid kernel generator expression into operation.
template<typename T >
using	is_without_output = internal::is_without_output_impl< std::decay_t< T > >
template<typename T >
using	is_colwise_reduction = internal::is_colwise_reduction_impl< std::decay_t< T > >
	Check whether a kernel generator expression is a colwise reduction.
template<typename... Types>
using	common_scalar_t = typename std::common_type_t< typename std::remove_reference_t< Types >::Scalar... >
	Wrapper for std::common_type_t
template<typename T >
using	is_reduction_2d = internal::is_reduction_2d_impl< std::decay_t< T > >
	Check whether a kernel generator expression is a colwise reduction.
template<typename T >
using	ref_type_for_opencl_t = typename ref_type_for_opencl< T >::type
template<int B = 0>
using	boost_policy_t = boost::math::policies::policy< boost::math::policies::overflow_error< boost::math::policies::errno_on_error >, boost::math::policies::pole_error< boost::math::policies::errno_on_error >, boost::math::policies::promote_double< false >, boost::math::policies::digits2< B > >
	Boost policy that overrides the defaults to match the built-in C++ standard library functions.
using	matrix_d = Eigen::Matrix< double, Eigen::Dynamic, Eigen::Dynamic >
	Type for matrix of double values.
using	vector_d = Eigen::Matrix< double, Eigen::Dynamic, 1 >
	Type for (column) vector of double values.
using	row_vector_d = Eigen::Matrix< double, 1, Eigen::Dynamic >
	Type for (row) vector of double values.
template<typename T >
using	index_type_t = typename index_type< T >::type
template<typename T >
using	require_tuple_t = require_t< is_tuple< std::decay_t< T > > >
	Require type satisfies is_tuple.
template<typename T >
using	require_not_tuple_t = require_not_t< is_tuple< std::decay_t< T > > >
	Require type does not satisfy is_tuple.
template<typename... Types>
using	require_all_tuple_t = require_all_t< is_tuple< std::decay_t< Types > >... >
	Require all of the types satisfy is_tuple.
template<typename... Types>
using	require_all_not_tuple_t = require_all_not_t< is_tuple< std::decay_t< Types > >... >
	Require none of the types satisfy is_tuple.
template<typename Mat , int NewOptions>
using	change_eigen_options_t = typename internal::change_eigen_options_impl< plain_type_t< std::decay_t< Mat > >, NewOptions >::type
	Change the options of an Eigen matrix or array.
template<typename T , typename S >
using	promote_scalar_t = typename promote_scalar_type< std::decay_t< T >, std::decay_t< S > >::type
using	ChainableStack = AutodiffStackSingleton< vari_base, chainable_alloc >
using	precomputed_gradients_vari = precomputed_gradients_vari_template< std::tuple<>, std::tuple<> >
using	profile_key = std::pair< std::string, std::thread::id >
using	profile_map = tbb::concurrent_unordered_map< profile_key, profile_info, internal::hash_profile_key, internal::equal_profile_key >
using	matrix_v = Eigen::Matrix< var, Eigen::Dynamic, Eigen::Dynamic >
	The type of a matrix holding var values.
using	vector_v = Eigen::Matrix< var, Eigen::Dynamic, 1 >
	The type of a (column) vector holding var values.
using	row_vector_v = Eigen::Matrix< var, 1, Eigen::Dynamic >
	The type of a row vector holding var values.
using	matrix_vi = Eigen::Matrix< vari *, Eigen::Dynamic, Eigen::Dynamic >
	The type of a matrix holding vari* values.
using	vector_vi = Eigen::Matrix< vari *, Eigen::Dynamic, 1 >
	The type of a (column) vector holding vari* values.
using	row_vector_vi = Eigen::Matrix< vari *, 1, Eigen::Dynamic >
	The type of a row vector holding vari* values.
using	var = var_value< double >
using	vari = vari_value< double >

Enumerations
enum class	assign_op_cl {   equals ,   plus_equals ,   minus_equals ,   divide_equals ,   multiply_equals }
	Ops that decide the type of assignment for LHS operations. More...
enum class	matrix_cl_view {   Diagonal = 0 ,   Lower = 1 ,   Upper = 2 ,   Entire = 3 }

Functions
template<typename EigMat , require_eigen_col_vector_vt< is_fvar, EigMat > * = nullptr>
auto	unit_vector_constrain (const EigMat &y)
template<typename EigMat , typename T , require_eigen_vt< is_fvar, EigMat > * = nullptr, require_stan_scalar_t< T > * = nullptr>
auto	unit_vector_constrain (const EigMat &y, T &lp)
template<typename T >
fvar< T >	operator+ (const fvar< T > &x1, const fvar< T > &x2)
	Return the sum of the specified forward mode addends.
template<typename T >
fvar< T >	operator+ (double x1, const fvar< T > &x2)
	Return the sum of the specified double and forward mode addends.
template<typename T >
fvar< T >	operator+ (const fvar< T > &x1, double x2)
	Return the sum of the specified forward mode and double addends.
template<typename T >
fvar< T >	operator/ (const fvar< T > &x1, const fvar< T > &x2)
	Return the result of dividing the first argument by the second.
template<typename T , typename U , require_arithmetic_t< U > * = nullptr>
fvar< T >	operator/ (const fvar< T > &x1, U x2)
	Return the result of dividing the first argument by the second.
template<typename T , typename U , require_arithmetic_t< U > * = nullptr>
fvar< T >	operator/ (U x1, const fvar< T > &x2)
	Return the result of dividing the first argument by the second.
template<typename T >
std::complex< fvar< T > >	operator/ (const std::complex< fvar< T > > &x1, const std::complex< fvar< T > > &x2)
template<typename T , typename U , require_arithmetic_t< U > * = nullptr>
std::complex< fvar< T > >	operator/ (const std::complex< fvar< T > > &x1, const std::complex< U > &x2)
template<typename T >
std::complex< fvar< T > >	operator/ (const std::complex< fvar< T > > &x1, const fvar< T > &x2)
template<typename T , typename U , require_arithmetic_t< U > * = nullptr>
std::complex< fvar< T > >	operator/ (const std::complex< fvar< T > > &x1, U x2)
template<typename T , typename U , require_arithmetic_t< U > * = nullptr>
std::complex< fvar< T > >	operator/ (const std::complex< U > &x1, const std::complex< fvar< T > > &x2)
template<typename T , typename U , require_arithmetic_t< U > * = nullptr>
std::complex< fvar< T > >	operator/ (const std::complex< U > &x1, const fvar< T > &x2)
template<typename T >
std::complex< fvar< T > >	operator/ (const fvar< T > &x1, const std::complex< fvar< T > > &x2)
template<typename T , typename U , typename = std::enable_if_t<std::is_arithmetic<U>::value>>
std::complex< fvar< T > >	operator/ (const fvar< T > &x1, const std::complex< U > &x2)
template<typename T , typename U , require_arithmetic_t< U > * = nullptr>
std::complex< fvar< T > >	operator/ (U x1, const std::complex< fvar< T > > &x2)
template<typename T >
bool	operator== (const fvar< T > &x, const fvar< T > &y)
	Return true if the specified variables have equal values as defined by ==.
template<typename T >
bool	operator== (const fvar< T > &x, double y)
	Return true if the the first variable has a value equal to the second argument as defined by by ==.
template<typename T >
bool	operator== (double x, const fvar< T > &y)
	Return true if the the first argument is equal to the value of the second argument as defined by by ==.
template<typename T >
bool	operator> (const fvar< T > &x, const fvar< T > &y)
	Return true if the first argument has a greater value than the second as defined by >.
template<typename T >
bool	operator> (const fvar< T > &x, double y)
	Return true if the first argument has a greater value than the second as defined by >.
template<typename T >
bool	operator> (double x, const fvar< T > &y)
	Return true if the first argument has a greater value than the second as defined by >.
template<typename T >
bool	operator>= (const fvar< T > &x, const fvar< T > &y)
	Return true if the value of the first argument is greater than or equal to that of the second as defined by >=.
template<typename T >
bool	operator>= (const fvar< T > &x, double y)
	Return true if the value of the first argument has a value greater than or equal to the second argument as defined by >=.
template<typename T >
bool	operator>= (double x, const fvar< T > &y)
	Return true if the first argument is greater than or equal to the value of the second argument as defined by >=.
template<typename T >
bool	operator< (const fvar< T > &x, const fvar< T > &y)
	Return true if the first argument has a value less than the value of the second argument as defined by <.
template<typename T >
bool	operator< (double x, const fvar< T > &y)
	Return true if the first argument is less than the value of the second argument as defined by <.
template<typename T >
bool	operator< (const fvar< T > &x, double y)
	Return true if the first argument has a value less than the second argument as defined by <.
template<typename T >
bool	operator<= (const fvar< T > &x, const fvar< T > &y)
	Return true if the first argument has a value less than or equal to the value of the second argument as defined by <=.
template<typename T >
bool	operator<= (const fvar< T > &x, double y)
	Return true if the first argument has a value less than or equal to the second argument as defined by <=.
template<typename T >
bool	operator<= (double x, const fvar< T > &y)
	Return true if the first argument is less than or equal to the second argument's value as defined by <=.
template<typename T >
bool	operator&& (const fvar< T > &x, const fvar< T > &y)
	Return the logical conjunction of the values of the two arguments as defined by &&.
template<typename T >
bool	operator&& (const fvar< T > &x, double y)
	Return the logical conjunction of the values of the two arguments as defined by &&.
template<typename T >
bool	operator&& (double x, const fvar< T > &y)
	Return the logical conjunction of the values of the two arguments as defined by &&.
template<typename T >
bool	operator|| (const fvar< T > &x, const fvar< T > &y)
	Return the logical disjunction of the values of the two arguments as defined by ||.
template<typename T >
bool	operator|| (const fvar< T > &x, double y)
	Return the logical disjunction of the values of the two arguments as defined by ||.
template<typename T >
bool	operator|| (double x, const fvar< T > &y)
	Return the logical disjunction of the values of the two arguments as defined by ||.
template<typename T >
fvar< T >	operator* (const fvar< T > &x, const fvar< T > &y)
	Return the product of the two arguments.
template<typename T >
fvar< T >	operator* (double x, const fvar< T > &y)
	Return the product of the two arguments.
template<typename T >
fvar< T >	operator* (const fvar< T > &x, double y)
	Return the product of the two arguments.
template<typename T >
std::complex< stan::math::fvar< T > >	operator* (const std::complex< stan::math::fvar< T > > &x, const std::complex< stan::math::fvar< T > > &y)
	Return the product of the two complex fvar<T> arguments.
template<typename T >
std::complex< stan::math::fvar< T > >	operator* (const std::complex< double > &x, const std::complex< stan::math::fvar< T > > &y)
	Return the product of std::complex<double> and std::complex<fvar<T>> arguments.
template<typename T >
std::complex< stan::math::fvar< T > >	operator* (const std::complex< stan::math::fvar< T > > &x, const std::complex< double > &y)
	Return the product of std::complex<double> and std::complex<fvar<T>> arguments.
template<typename T >
bool	operator!= (const fvar< T > &x, const fvar< T > &y)
	Return true if the value of the two arguments are not equal as defined by !=.
template<typename T >
bool	operator!= (const fvar< T > &x, double y)
	Return true if the value of the first argument is not equal to the second argument as defined by !=.
template<typename T >
bool	operator!= (double x, const fvar< T > &y)
	Return true if the first argument is not equal to the value of the second argument as defined by !=.
template<typename T >
fvar< T >	operator- (const fvar< T > &x1, const fvar< T > &x2)
	Return the difference of the specified arguments.
template<typename T >
fvar< T >	operator- (double x1, const fvar< T > &x2)
	Return the difference of the specified arguments.
template<typename T >
fvar< T >	operator- (const fvar< T > &x1, double x2)
	Return the difference of the specified arguments.
template<typename T >
fvar< T >	operator- (const fvar< T > &x)
	Return the negation of the specified argument.
template<typename T >
bool	operator! (const fvar< T > &x)
	Return the negation of the value of the argument as defined by !.
template<typename T >
fvar< T >	operator+ (const fvar< T > &x)
	Returns the argument.
template<typename T >
fvar< T >	abs (const fvar< T > &x)
template<typename T >
fvar< T >	abs (const std::complex< fvar< T > > &z)
	Return the absolute value of the complex argument.
template<typename T >
fvar< T >	acos (const fvar< T > &x)
template<typename T >
std::complex< fvar< T > >	acos (const std::complex< fvar< T > > &x)
	Return the arc cosine of the complex argument.
template<typename T >
fvar< T >	acosh (const fvar< T > &x)
template<typename T >
std::complex< fvar< T > >	acosh (const std::complex< fvar< T > > &z)
	Return the hyperbolic arc cosine of the complex argument.
template<typename T >
fvar< T >	arg (const std::complex< fvar< T > > &z)
	Return the phase angle of the complex argument.
template<typename T >
fvar< T >	asin (const fvar< T > &x)
template<typename T >
std::complex< fvar< T > >	asin (const std::complex< fvar< T > > &z)
	Return the arc sine of the complex argument.
template<typename T >
fvar< T >	asinh (const fvar< T > &x)
template<typename T >
std::complex< fvar< T > >	asinh (const std::complex< fvar< T > > &z)
	Return the hyperbolic arcsine of the complex argument.
template<typename T >
fvar< T >	atan (const fvar< T > &x)
template<typename T >
std::complex< fvar< T > >	atan (const std::complex< fvar< T > > &z)
	Return the arc tangent of the complex argument.
template<typename T >
fvar< T >	atan2 (const fvar< T > &x1, const fvar< T > &x2)
template<typename T >
fvar< T >	atan2 (double x1, const fvar< T > &x2)
template<typename T >
fvar< T >	atan2 (const fvar< T > &x1, double x2)
template<typename T >
fvar< T >	atanh (const fvar< T > &x)
	Return inverse hyperbolic tangent of specified value.
template<typename T >
std::complex< fvar< T > >	atanh (const std::complex< fvar< T > > &z)
	Return the hyperbolic arc tangent of the complex argument.
template<typename T >
fvar< T >	bessel_first_kind (int v, const fvar< T > &z)
template<typename T >
fvar< T >	bessel_second_kind (int v, const fvar< T > &z)
template<typename T >
fvar< T >	beta (const fvar< T > &x1, const fvar< T > &x2)
	Return fvar with the beta function applied to the specified arguments and its gradient.
template<typename T >
fvar< T >	beta (double x1, const fvar< T > &x2)
template<typename T >
fvar< T >	beta (const fvar< T > &x1, double x2)
template<typename T >
fvar< T >	binary_log_loss (int y, const fvar< T > &y_hat)
template<typename T >
fvar< T >	cbrt (const fvar< T > &x)
	Return cube root of specified argument.
template<typename T >
fvar< T >	ceil (const fvar< T > &x)
template<typename T >
std::complex< fvar< T > >	conj (const std::complex< fvar< T > > &z)
	Return the phase angle of the complex argument.
template<typename T >
fvar< T >	cos (const fvar< T > &x)
template<typename T >
std::complex< fvar< T > >	cos (const std::complex< fvar< T > > &z)
	Return the cosine of the complex argument.
template<typename T >
fvar< T >	cosh (const fvar< T > &x)
template<typename T >
std::complex< fvar< T > >	cosh (const std::complex< fvar< T > > &z)
	Return the hyperbolic cosine of the complex argument.
template<typename EigMat , require_eigen_vt< is_fvar, EigMat > * = nullptr>
value_type_t< EigMat >	determinant (const EigMat &m)
template<typename T >
fvar< T >	digamma (const fvar< T > &x)
	Return the derivative of the log gamma function at the specified argument.
template<typename T >
fvar< T >	erf (const fvar< T > &x)
template<typename T >
fvar< T >	erfc (const fvar< T > &x)
template<typename T >
fvar< T >	exp (const fvar< T > &x)
template<typename T >
std::complex< fvar< T > >	exp (const std::complex< fvar< T > > &z)
	Return the natural exponentiation (base e) of the specified complex number.
template<typename T >
fvar< T >	exp2 (const fvar< T > &x)
template<typename T >
fvar< T >	expm1 (const fvar< T > &x)
template<typename T >
fvar< T >	fabs (const fvar< T > &x)
template<typename T >
fvar< T >	falling_factorial (const fvar< T > &x, int n)
	Return autodiff variable with the gradient and result of the falling factorial function applied to the inputs.
template<typename T >
fvar< T >	fdim (const fvar< T > &x, const fvar< T > &y)
	Return the positive difference of the specified values (C++11).
template<typename T >
fvar< T >	fdim (const fvar< T > &x, double y)
	Return the positive difference of the specified values (C++11).
template<typename T >
fvar< T >	fdim (double x, const fvar< T > &y)
	Return the positive difference of the specified values (C++11).
template<typename T >
fvar< T >	floor (const fvar< T > &x)
template<typename T1 , typename T2 , typename T3 , require_all_stan_scalar_t< T1, T2, T3 > * = nullptr>
fvar< return_type_t< T1, T2, T3 > >	fma (const fvar< T1 > &x1, const fvar< T2 > &x2, const fvar< T3 > &x3)
	The fused multiply-add operation (C99).
template<typename T1 , typename T2 , typename T3 , require_all_stan_scalar_t< T1, T2, T3 > * = nullptr>
fvar< return_type_t< T1, T2, T3 > >	fma (const T1 &x1, const fvar< T2 > &x2, const fvar< T3 > &x3)
	See all-var input signature for details on the function and derivatives.
template<typename T1 , typename T2 , typename T3 , require_all_stan_scalar_t< T1, T2, T3 > * = nullptr>
fvar< return_type_t< T1, T2, T3 > >	fma (const fvar< T1 > &x1, const T2 &x2, const fvar< T3 > &x3)
	See all-var input signature for details on the function and derivatives.
template<typename T1 , typename T2 , typename T3 , require_all_stan_scalar_t< T1, T2, T3 > * = nullptr>
fvar< return_type_t< T1, T2, T3 > >	fma (const fvar< T1 > &x1, const fvar< T2 > &x2, const T3 &x3)
	See all-var input signature for details on the function and derivatives.
template<typename T1 , typename T2 , typename T3 , require_all_stan_scalar_t< T1, T2, T3 > * = nullptr>
fvar< return_type_t< T1, T2, T3 > >	fma (const T1 &x1, const T2 &x2, const fvar< T3 > &x3)
	See all-var input signature for details on the function and derivatives.
template<typename T1 , typename T2 , typename T3 , require_all_stan_scalar_t< T1, T2, T3 > * = nullptr>
fvar< return_type_t< T1, T2, T3 > >	fma (const fvar< T1 > &x1, const T2 &x2, const T3 &x3)
	See all-var input signature for details on the function and derivatives.
template<typename T1 , typename T2 , typename T3 , require_all_stan_scalar_t< T1, T2, T3 > * = nullptr>
fvar< return_type_t< T1, T2, T3 > >	fma (const T1 &x1, const fvar< T2 > &x2, const T3 &x3)
	See all-var input signature for details on the function and derivatives.
template<typename T >
fvar< T >	fmax (const fvar< T > &x1, const fvar< T > &x2)
	Return the greater of the two specified arguments.
template<typename T >
fvar< T >	fmax (double x1, const fvar< T > &x2)
	Return the greater of the two specified arguments.
template<typename T >
fvar< T >	fmax (const fvar< T > &x1, double x2)
	Return the greater of the two specified arguments.
template<typename T >
fvar< T >	fmin (const fvar< T > &x1, const fvar< T > &x2)
template<typename T >
fvar< T >	fmin (double x1, const fvar< T > &x2)
template<typename T >
fvar< T >	fmin (const fvar< T > &x1, double x2)
template<typename T >
fvar< T >	fmod (const fvar< T > &x1, const fvar< T > &x2)
template<typename T >
fvar< T >	fmod (const fvar< T > &x1, double x2)
template<typename T >
fvar< T >	fmod (double x1, const fvar< T > &x2)
template<typename T >
fvar< T >	gamma_p (const fvar< T > &x1, const fvar< T > &x2)
template<typename T >
fvar< T >	gamma_p (const fvar< T > &x1, double x2)
template<typename T >
fvar< T >	gamma_p (double x1, const fvar< T > &x2)
template<typename T >
fvar< T >	gamma_q (const fvar< T > &x1, const fvar< T > &x2)
template<typename T >
fvar< T >	gamma_q (const fvar< T > &x1, double x2)
template<typename T >
fvar< T >	gamma_q (double x1, const fvar< T > &x2)
template<typename T >
void	grad_inc_beta (fvar< T > &g1, fvar< T > &g2, fvar< T > a, fvar< T > b, fvar< T > z)
	Gradient of the incomplete beta function beta(a, b, z) with respect to the first two arguments.
template<typename Ta , typename Tz , typename FvarT = return_type_t<Ta, Tz>, require_all_stan_scalar_t< Ta, Tz > * = nullptr, require_any_fvar_t< Ta, Tz > * = nullptr>
FvarT	hypergeometric_1f0 (const Ta &a, const Tz &z)
	Returns the Hypergeometric 1F0 function applied to the input arguments: \( _1F_0(a;;z) = \sum_{k=1}^{\infty}\frac{\left(a\right)_kz^k}{k!}\).
template<typename Ta1 , typename Ta2 , typename Tb , typename Tz , require_all_stan_scalar_t< Ta1, Ta2, Tb, Tz > * = nullptr, require_any_fvar_t< Ta1, Ta2, Tb, Tz > * = nullptr>
return_type_t< Ta1, Ta1, Tb, Tz >	hypergeometric_2F1 (const Ta1 &a1, const Ta2 &a2, const Tb &b, const Tz &z)
	Returns the Gauss hypergeometric function applied to the input arguments: \(_2F_1(a_1,a_2;b;z)\).
template<typename Ta , typename Tb , typename Tz , typename FvarT = return_type_t<Ta, Tb, Tz>, bool grad_a = !is_constant<Ta>::value, bool grad_b = !is_constant<Tb>::value, bool grad_z = !is_constant<Tz>::value, require_all_vector_t< Ta, Tb > * = nullptr, require_fvar_t< FvarT > * = nullptr>
FvarT	hypergeometric_pFq (const Ta &a, const Tb &b, const Tz &z)
	Returns the generalized hypergeometric (pFq) function applied to the input arguments.
template<typename T >
fvar< T >	hypot (const fvar< T > &x1, const fvar< T > &x2)
	Return the length of the hypotenuse of a right triangle with opposite and adjacent side lengths given by the specified arguments (C++11).
template<typename T >
fvar< T >	hypot (const fvar< T > &x1, double x2)
	Return the length of the hypotenuse of a right triangle with opposite and adjacent side lengths given by the specified arguments (C++11).
template<typename T >
fvar< T >	hypot (double x1, const fvar< T > &x2)
	Return the length of the hypotenuse of a right triangle with opposite and adjacent side lengths given by the specified arguments (C++11).
template<typename T >
fvar< T >	inc_beta (const fvar< T > &a, const fvar< T > &b, const fvar< T > &x)
template<typename T >
fvar< T >	inc_beta (double a, const fvar< T > &b, const fvar< T > &x)
template<typename T >
fvar< T >	inc_beta (const fvar< T > &a, double b, const fvar< T > &x)
template<typename T >
fvar< T >	inc_beta (const fvar< T > &a, const fvar< T > &b, double x)
template<typename T >
fvar< T >	inc_beta (double a, double b, const fvar< T > &x)
template<typename T >
fvar< T >	inc_beta (const fvar< T > &a, double b, double x)
template<typename T >
fvar< T >	inc_beta (double a, const fvar< T > &b, double x)
template<typename T >
fvar< T >	inv (const fvar< T > &x)
template<typename T >
fvar< T >	inv_cloglog (const fvar< T > &x)
template<typename T >
fvar< T >	inv_erfc (const fvar< T > &x)
template<typename T1 , typename T2 , typename T3 , require_all_stan_scalar_t< T1, T2, T3 > * = nullptr, require_any_fvar_t< T1, T2, T3 > * = nullptr>
fvar< partials_return_t< T1, T2, T3 > >	inv_inc_beta (const T1 &a, const T2 &b, const T3 &p)
	The inverse of the normalized incomplete beta function of a, b, with probability p.
template<typename T >
fvar< T >	inv_logit (const fvar< T > &x)
	Returns the inverse logit function applied to the argument.
template<typename T >
fvar< T >	inv_Phi (const fvar< T > &p)
template<typename T >
fvar< T >	inv_sqrt (const fvar< T > &x)
template<typename T >
fvar< T >	inv_square (const fvar< T > &x)
template<typename EigMat , require_eigen_vt< is_fvar, EigMat > * = nullptr>
Eigen::Matrix< value_type_t< EigMat >, EigMat::RowsAtCompileTime, EigMat::ColsAtCompileTime >	inverse (const EigMat &m)
	Forward mode specialization of calculating the inverse of the matrix.
template<typename T >
int	is_inf (const fvar< T > &x)
	Returns 1 if the input's value is infinite and 0 otherwise.
template<typename T , require_fvar_t< T > * = nullptr>
bool	is_nan (T &&x)
	Returns 1 if the input's value is NaN and 0 otherwise.
template<typename T >
fvar< T >	lambert_w0 (const fvar< T > &x)
template<typename T >
fvar< T >	lambert_wm1 (const fvar< T > &x)
template<typename T >
fvar< T >	lbeta (const fvar< T > &x1, const fvar< T > &x2)
template<typename T >
fvar< T >	lbeta (double x1, const fvar< T > &x2)
template<typename T >
fvar< T >	lbeta (const fvar< T > &x1, double x2)
template<typename T >
fvar< T >	ldexp (const fvar< T > &a, int b)
	Returns the product of a (the significand) times 2 to power b (the exponent).
template<typename T >
fvar< T >	lgamma (const fvar< T > &x)
	Return the natural logarithm of the gamma function applied to the specified argument.
template<typename T >
fvar< return_type_t< T, int > >	lmgamma (int x1, const fvar< T > &x2)
template<typename T >
fvar< T >	lmultiply (const fvar< T > &x1, const fvar< T > &x2)
template<typename T >
fvar< T >	lmultiply (double x1, const fvar< T > &x2)
template<typename T >
fvar< T >	lmultiply (const fvar< T > &x1, double x2)
template<typename T >
fvar< T >	log (const fvar< T > &x)
template<typename T >
std::complex< fvar< T > >	log (const std::complex< fvar< T > > &z)
	Return the natural logarithm (base e) of the specified complex argument.
template<typename T >
fvar< T >	log10 (const fvar< T > &x)
template<typename T >
std::complex< fvar< T > >	log10 (const std::complex< fvar< T > > &z)
	Return the base 10 logarithm of the specified complex number.
template<typename T >
fvar< T >	log1m (const fvar< T > &x)
template<typename T >
fvar< T >	log1m_exp (const fvar< T > &x)
	Return the natural logarithm of one minus the exponentiation of the specified argument.
template<typename T >
fvar< T >	log1m_inv_logit (const fvar< T > &x)
	Return the natural logarithm of one minus the inverse logit of the specified argument.
template<typename T >
fvar< T >	log1p (const fvar< T > &x)
template<typename T >
fvar< T >	log1p_exp (const fvar< T > &x)
template<typename T >
fvar< T >	log2 (const fvar< T > &x)
	Return the base two logarithm of the specified argument.
template<typename EigMat , require_eigen_vt< is_fvar, EigMat > * = nullptr>
value_type_t< EigMat >	log_determinant (const EigMat &m)
	Returns the log absolute determinant of the specified square matrix.
template<typename T >
fvar< T >	log_diff_exp (const fvar< T > &x1, const fvar< T > &x2)
template<typename T1 , typename T2 , require_arithmetic_t< T1 > * = nullptr>
fvar< T2 >	log_diff_exp (const T1 &x1, const fvar< T2 > &x2)
template<typename T1 , typename T2 , require_arithmetic_t< T2 > * = nullptr>
fvar< T1 >	log_diff_exp (const fvar< T1 > &x1, const T2 &x2)
template<typename T >
fvar< T >	log_falling_factorial (const fvar< T > &x, const fvar< T > &n)
template<typename T >
fvar< T >	log_falling_factorial (double x, const fvar< T > &n)
template<typename T >
fvar< T >	log_falling_factorial (const fvar< T > &x, double n)
template<typename T >
fvar< T >	log_inv_logit (const fvar< T > &x)
template<typename T >
fvar< T >	log_inv_logit_diff (const fvar< T > &x, const fvar< T > &y)
	Returns fvar with the natural logarithm of the difference of the inverse logits of the specified arguments and its gradients.
template<typename T >
fvar< T >	log_inv_logit_diff (const fvar< T > &x, double y)
template<typename T >
fvar< T >	log_inv_logit_diff (double x, const fvar< T > &y)
template<typename T_theta , typename T_lambda1 , typename T_lambda2 , int N>
void	log_mix_partial_helper (const T_theta &theta, const T_lambda1 &lambda1, const T_lambda2 &lambda2, promote_args_t< T_theta, T_lambda1, T_lambda2 >(&partials_array)[N])
template<typename T >
fvar< T >	log_mix (const fvar< T > &theta, const fvar< T > &lambda1, const fvar< T > &lambda2)
	Return the log mixture density with specified mixing proportion and log densities and its derivative at each.
template<typename T , typename P , require_all_arithmetic_t< P > * = nullptr>
fvar< T >	log_mix (const fvar< T > &theta, const fvar< T > &lambda1, P lambda2)
template<typename T , typename P , require_all_arithmetic_t< P > * = nullptr>
fvar< T >	log_mix (const fvar< T > &theta, P lambda1, const fvar< T > &lambda2)
template<typename T , typename P , require_all_arithmetic_t< P > * = nullptr>
fvar< T >	log_mix (P theta, const fvar< T > &lambda1, const fvar< T > &lambda2)
template<typename T , typename P1 , typename P2 , require_all_arithmetic_t< P1, P2 > * = nullptr>
fvar< T >	log_mix (const fvar< T > &theta, P1 lambda1, P2 lambda2)
template<typename T , typename P1 , typename P2 , require_all_arithmetic_t< P1, P2 > * = nullptr>
fvar< T >	log_mix (P1 theta, const fvar< T > &lambda1, P2 lambda2)
template<typename T , typename P1 , typename P2 , require_all_arithmetic_t< P1, P2 > * = nullptr>
fvar< T >	log_mix (P1 theta, P2 lambda1, const fvar< T > &lambda2)
template<typename T >
fvar< T >	log_rising_factorial (const fvar< T > &x, const fvar< T > &n)
template<typename T >
fvar< T >	log_rising_factorial (const fvar< T > &x, double n)
template<typename T >
fvar< T >	log_rising_factorial (double x, const fvar< T > &n)
template<typename T , require_vector_st< is_fvar, T > * = nullptr>
auto	log_softmax (const T &x)
	Return the log softmax of the specified vector or container of vectors.
template<typename T >
fvar< T >	log_sum_exp (const fvar< T > &x1, const fvar< T > &x2)
template<typename T >
fvar< T >	log_sum_exp (double x1, const fvar< T > &x2)
template<typename T >
fvar< T >	log_sum_exp (const fvar< T > &x1, double x2)
template<typename T , require_container_st< is_fvar, T > * = nullptr>
auto	log_sum_exp (const T &x)
	Return the log of the sum of the exponentiated values of the specified matrix of values.
template<typename T >
fvar< T >	logit (const fvar< T > &x)
template<typename T1 , typename T2 , require_all_eigen_vt< is_fvar, T1, T2 > * = nullptr, require_vt_same< T1, T2 > * = nullptr>
Eigen::Matrix< value_type_t< T1 >, T1::RowsAtCompileTime, T2::ColsAtCompileTime >	mdivide_left (const T1 &A, const T2 &b)
template<typename T1 , typename T2 , require_eigen_vt< std::is_arithmetic, T1 > * = nullptr, require_eigen_vt< is_fvar, T2 > * = nullptr>
Eigen::Matrix< value_type_t< T2 >, T1::RowsAtCompileTime, T2::ColsAtCompileTime >	mdivide_left (const T1 &A, const T2 &b)
template<typename T , typename EigMat , require_eigen_vt< std::is_arithmetic, T > * = nullptr, require_eigen_vt< is_fvar, EigMat > * = nullptr>
Eigen::Matrix< value_type_t< EigMat >, Eigen::Dynamic, EigMat::ColsAtCompileTime >	mdivide_left_ldlt (LDLT_factor< T > &A, const EigMat &b)
	Returns the solution of the system Ax=b given an LDLT_factor of A.
template<typename T1 , typename T2 , require_all_eigen_vt< is_fvar, T1, T2 > * = nullptr, require_vt_same< T1, T2 > * = nullptr>
Eigen::Matrix< value_type_t< T1 >, T1::RowsAtCompileTime, T2::ColsAtCompileTime >	mdivide_left_tri_low (const T1 &A, const T2 &b)
template<typename T1 , typename T2 , require_eigen_t< T1 > * = nullptr, require_vt_same< double, T1 > * = nullptr, require_eigen_vt< is_fvar, T2 > * = nullptr>
Eigen::Matrix< value_type_t< T2 >, T1::RowsAtCompileTime, T2::ColsAtCompileTime >	mdivide_left_tri_low (const T1 &A, const T2 &b)
template<typename T1 , typename T2 , require_eigen_vt< is_fvar, T1 > * = nullptr, require_eigen_t< T2 > * = nullptr, require_vt_same< double, T2 > * = nullptr>
Eigen::Matrix< value_type_t< T1 >, T1::RowsAtCompileTime, T2::ColsAtCompileTime >	mdivide_left_tri_low (const T1 &A, const T2 &b)
template<typename EigMat1 , typename EigMat2 , require_all_eigen_vt< is_fvar, EigMat1, EigMat2 > * = nullptr, require_vt_same< EigMat1, EigMat2 > * = nullptr>
Eigen::Matrix< value_type_t< EigMat1 >, EigMat1::RowsAtCompileTime, EigMat2::ColsAtCompileTime >	mdivide_right (const EigMat1 &A, const EigMat2 &b)
template<typename EigMat1 , typename EigMat2 , require_eigen_vt< std::is_arithmetic, EigMat1 > * = nullptr, require_eigen_vt< is_fvar, EigMat2 > * = nullptr>
Eigen::Matrix< value_type_t< EigMat2 >, EigMat1::RowsAtCompileTime, EigMat2::ColsAtCompileTime >	mdivide_right (const EigMat1 &A, const EigMat2 &b)
template<typename EigMat1 , typename EigMat2 , require_all_eigen_vt< is_fvar, EigMat1, EigMat2 > * = nullptr, require_vt_same< EigMat1, EigMat2 > * = nullptr>
Eigen::Matrix< value_type_t< EigMat1 >, EigMat1::RowsAtCompileTime, EigMat2::ColsAtCompileTime >	mdivide_right_tri_low (const EigMat1 &A, const EigMat2 &b)
template<typename EigMat1 , typename EigMat2 , require_eigen_vt< std::is_arithmetic, EigMat1 > * = nullptr, require_eigen_vt< is_fvar, EigMat2 > * = nullptr>
Eigen::Matrix< value_type_t< EigMat2 >, EigMat1::RowsAtCompileTime, EigMat2::ColsAtCompileTime >	mdivide_right_tri_low (const EigMat1 &A, const EigMat2 &b)
template<typename T >
fvar< T >	modified_bessel_first_kind (int v, const fvar< T > &z)
template<typename T >
fvar< T >	modified_bessel_second_kind (int v, const fvar< T > &z)
template<typename Mat1 , typename Mat2 , require_all_eigen_vt< is_fvar, Mat1, Mat2 > * = nullptr, require_vt_same< Mat1, Mat2 > * = nullptr, require_not_eigen_row_and_col_t< Mat1, Mat2 > * = nullptr>
auto	multiply (const Mat1 &m1, const Mat2 &m2)
	Return the product of the specified matrices.
template<typename T >
fvar< T >	multiply_log (const fvar< T > &x1, const fvar< T > &x2)
template<typename T >
fvar< T >	multiply_log (double x1, const fvar< T > &x2)
template<typename T >
fvar< T >	multiply_log (const fvar< T > &x1, double x2)
template<typename EigMat , require_eigen_vt< is_fvar, EigMat > * = nullptr>
Eigen::Matrix< value_type_t< EigMat >, EigMat::RowsAtCompileTime, EigMat::RowsAtCompileTime >	multiply_lower_tri_self_transpose (const EigMat &m)
template<typename T >
fvar< T >	norm (const std::complex< fvar< T > > &z)
	Return the squared magnitude of the complex argument.
template<typename Container , require_eigen_vt< is_fvar, Container > * = nullptr>
auto	norm1 (const Container &x)
	Compute the L1 norm of the specified vector of values.
template<typename Container , require_eigen_vt< is_fvar, Container > * = nullptr>
auto	norm2 (const Container &x)
	Compute the L2 norm of the specified vector of values.
template<typename T >
fvar< T >	owens_t (const fvar< T > &x1, const fvar< T > &x2)
	Return Owen's T function applied to the specified arguments.
template<typename T >
fvar< T >	owens_t (double x1, const fvar< T > &x2)
	Return Owen's T function applied to the specified arguments.
template<typename T >
fvar< T >	owens_t (const fvar< T > &x1, double x2)
	Return Owen's T function applied to the specified arguments.
template<typename T >
fvar< T >	Phi (const fvar< T > &x)
template<typename T >
fvar< T >	Phi_approx (const fvar< T > &x)
	Return an approximation of the unit normal cumulative distribution function (CDF).
template<typename T >
std::complex< fvar< T > >	polar (const fvar< T > &r, const fvar< T > &theta)
	Returns complex number with specified magnitude and phase angle.
template<typename T , typename U >
std::complex< fvar< T > >	polar (const fvar< T > &r, U theta)
	Returns complex number with specified magnitude and phase angle.
template<typename T , typename U >
std::complex< fvar< T > >	polar (U r, const fvar< T > &theta)
	Returns complex number with specified magnitude and phase angle.
template<typename T >
fvar< T >	pow (const fvar< T > &x1, const fvar< T > &x2)
template<typename T , typename U , typename = require_arithmetic_t<U>>
fvar< T >	pow (U x1, const fvar< T > &x2)
template<typename T , typename U , typename = require_arithmetic_t<U>>
fvar< T >	pow (const fvar< T > &x1, U x2)
template<typename V >
std::complex< fvar< V > >	pow (const std::complex< fvar< V > > &x, const std::complex< fvar< V > > &y)
	Return the first argument raised to the power of the second argument.
template<typename V , typename T , typename = require_arithmetic_t<T>>
std::complex< fvar< V > >	pow (const std::complex< fvar< V > > &x, const std::complex< T > &y)
	Return the first argument raised to the power of the second argument.
template<typename V >
std::complex< fvar< V > >	pow (const std::complex< fvar< V > > &x, const fvar< V > &y)
	Return the first argument raised to the power of the second argument.
template<typename V , typename T , typename = require_arithmetic_t<T>>
std::complex< fvar< V > >	pow (const std::complex< fvar< V > > &x, const T &y)
	Return the first argument raised to the power of the second argument.
template<typename V , typename T , typename = require_arithmetic_t<T>>
std::complex< fvar< V > >	pow (const std::complex< T > &x, const std::complex< fvar< V > > &y)
	Return the first argument raised to the power of the second argument.
template<typename V , typename T , typename = require_arithmetic_t<T>>
std::complex< fvar< V > >	pow (const std::complex< T > &x, const fvar< V > &y)
	Return the first argument raised to the power of the second argument.
template<typename V >
std::complex< fvar< V > >	pow (const fvar< V > &x, const std::complex< fvar< V > > &y)
	Return the first argument raised to the power of the second argument.
template<typename V , typename T , typename = require_arithmetic_t<T>>
std::complex< fvar< V > >	pow (const fvar< V > &x, const std::complex< T > &y)
	Return the first argument raised to the power of the second argument.
template<typename T , typename V , typename = require_arithmetic_t<T>>
std::complex< fvar< V > >	pow (T x, const std::complex< fvar< V > > &y)
	Return the first argument raised to the power of the second argument.
template<typename T >
std::complex< fvar< T > >	pow (const std::complex< fvar< T > > &x, int y)
	Return the first argument raised to the power of the second argument.
template<typename T >
double	primitive_value (const fvar< T > &v)
	Return the primitive value of the specified forward-mode autodiff variable.
template<typename T >
std::complex< fvar< T > >	proj (const std::complex< fvar< T > > &z)
	Return the projection of the complex argument onto the Riemann sphere.
template<typename EigMat1 , typename EigMat2 , require_all_eigen_t< EigMat1, EigMat2 > * = nullptr, require_not_eigen_col_vector_t< EigMat2 > * = nullptr, require_any_vt_fvar< EigMat1, EigMat2 > * = nullptr>
promote_scalar_t< return_type_t< EigMat1, EigMat2 >, EigMat2 >	quad_form (const EigMat1 &A, const EigMat2 &B)
	Return the quadratic form \( B^T A B \).
template<typename EigMat , typename ColVec , require_eigen_t< EigMat > * = nullptr, require_eigen_col_vector_t< ColVec > * = nullptr, require_any_vt_fvar< EigMat, ColVec > * = nullptr>
return_type_t< EigMat, ColVec >	quad_form (const EigMat &A, const ColVec &B)
	Return the quadratic form \( B^T A B \).
template<typename EigMat1 , typename EigMat2 , require_all_eigen_t< EigMat1, EigMat2 > * = nullptr, require_not_eigen_col_vector_t< EigMat2 > * = nullptr, require_any_vt_fvar< EigMat1, EigMat2 > * = nullptr>
promote_scalar_t< return_type_t< EigMat1, EigMat2 >, EigMat2 >	quad_form_sym (const EigMat1 &A, const EigMat2 &B)
	Return the quadratic form \( B^T A B \) of a symmetric matrix.
template<typename EigMat , typename ColVec , require_eigen_t< EigMat > * = nullptr, require_eigen_col_vector_t< ColVec > * = nullptr, require_any_vt_fvar< EigMat, ColVec > * = nullptr>
return_type_t< EigMat, ColVec >	quad_form_sym (const EigMat &A, const ColVec &B)
	Return the quadratic form \( B^T A B \) of a symmetric matrix.
template<typename EigFvar , typename EigOut >
void	read_fvar (const EigFvar &FvarMat, EigOut &ValMat, EigOut &DMat)
	Function applying the read_fvar_functor to extract the values and tangets of a given fvar matrix into separate matrices.
template<typename T >
fvar< T >	rising_factorial (const fvar< T > &x, int n)
	Return autodiff variable with the gradient and result of the rising factorial function applied to the inputs.
template<typename T >
fvar< T >	round (const fvar< T > &x)
	Return the closest integer to the specified argument, with halfway cases rounded away from zero.
template<typename T >
fvar< T >	sin (const fvar< T > &x)
template<typename T >
std::complex< fvar< T > >	sin (const std::complex< fvar< T > > &z)
	Return the sine of the complex argument.
template<typename T >
fvar< T >	sinh (const fvar< T > &x)
template<typename T >
std::complex< fvar< T > >	sinh (const std::complex< fvar< T > > &z)
	Return the hyperbolic sine of the complex argument.
template<typename ColVec , require_eigen_col_vector_vt< is_fvar, ColVec > * = nullptr>
auto	softmax (const ColVec &alpha)
template<typename T >
fvar< T >	sqrt (const fvar< T > &x)
template<typename T >
std::complex< fvar< T > >	sqrt (const std::complex< fvar< T > > &z)
	Return the square root of the complex argument.
template<typename T >
fvar< T >	square (const fvar< T > &x)
template<typename T >
fvar< T >	sum (const std::vector< fvar< T > > &m)
	Return the sum of the entries of the specified standard vector.
template<typename T , require_eigen_vt< is_fvar, T > * = nullptr>
value_type_t< T >	sum (const T &m)
	Return the sum of the entries of the specified matrix.
template<typename T >
fvar< T >	tan (const fvar< T > &x)
template<typename T >
std::complex< fvar< T > >	tan (const std::complex< fvar< T > > &z)
	Return the tangent of the complex argument.
template<typename T >
fvar< T >	tanh (const fvar< T > &x)
template<typename T >
std::complex< fvar< T > >	tanh (const std::complex< fvar< T > > &z)
	Return the hyperbolic tangent of the complex argument.
template<typename EigMat , require_eigen_vt< is_fvar, EigMat > * = nullptr>
Eigen::Matrix< value_type_t< EigMat >, EigMat::RowsAtCompileTime, EigMat::RowsAtCompileTime >	tcrossprod (const EigMat &m)
template<typename T >
fvar< T >	tgamma (const fvar< T > &x)
	Return the result of applying the gamma function to the specified argument.
template<typename T , require_stan_scalar_t< T > * = nullptr, require_not_fvar_t< T > * = nullptr>
fvar< T >	to_fvar (const T &x)
template<typename T , require_fvar_t< scalar_type_t< T > > * = nullptr>
T &&	to_fvar (T &&x)
	Specialization of to_fvar for [containers of] fvars.
template<typename T >
std::vector< fvar< T > >	to_fvar (const std::vector< T > &v)
template<typename T >
std::vector< fvar< T > >	to_fvar (const std::vector< T > &v, const std::vector< T > &d)
template<typename T , require_eigen_t< T > * = nullptr, require_not_eigen_vt< is_fvar, T > * = nullptr>
promote_scalar_t< fvar< value_type_t< T > >, T >	to_fvar (const T &m)
template<typename T1 , typename T2 , require_all_eigen_t< T1, T2 > * = nullptr, require_vt_same< T1, T2 > * = nullptr>
promote_scalar_t< fvar< value_type_t< T1 > >, T1 >	to_fvar (const T1 &val, const T2 &deriv)
template<typename EigMat1 , typename EigMat2 , require_all_eigen_t< EigMat1, EigMat2 > * = nullptr, require_any_vt_fvar< EigMat1, EigMat2 > * = nullptr>
return_type_t< EigMat1, EigMat2 >	trace_quad_form (const EigMat1 &A, const EigMat2 &B)
template<typename T >
fvar< T >	trigamma (const fvar< T > &u)
	Return the value of the trigamma function at the specified argument (i.e., the second derivative of the log Gamma function at the specified argument).
template<typename T >
fvar< T >	trunc (const fvar< T > &x)
	Return the nearest integral value that is not larger in magnitude than the specified argument.
template<typename T >
T	value_of (const fvar< T > &v)
	Return the value of the specified variable.
template<typename T >
double	value_of_rec (const fvar< T > &v)
	Return the value of the specified variable.
template<typename F , typename... TArgs, require_any_st_fvar< TArgs... > * = nullptr>
auto	finite_diff (const F &func, const TArgs &... args)
	Construct an fvar<T> where the tangent is calculated by finite-differencing.
template<typename T , typename F >
void	gradient (const F &f, const Eigen::Matrix< T, Eigen::Dynamic, 1 > &x, T &fx, Eigen::Matrix< T, Eigen::Dynamic, 1 > &grad_fx)
	Calculate the value and the gradient of the specified function at the specified argument.
template<typename T , typename F >
void	hessian (const F &f, const Eigen::Matrix< T, Eigen::Dynamic, 1 > &x, T &fx, Eigen::Matrix< T, Eigen::Dynamic, 1 > &grad, Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > &H)
	Calculate the value, the gradient, and the Hessian, of the specified function at the specified argument in time O(N^3) time and O(N^2) space.
template<typename F , typename T_a , typename T_b , typename... Args, require_any_st_fvar< T_a, T_b, Args... > * = nullptr>
return_type_t< T_a, T_b, Args... >	integrate_1d_impl (const F &f, const T_a &a, const T_b &b, double relative_tolerance, std::ostream *msgs, const Args &... args)
	Return the integral of f from a to b to the given relative tolerance.
template<typename F , typename T_a , typename T_b , typename T_theta , require_any_fvar_t< T_a, T_b, T_theta > * = nullptr>
return_type_t< T_a, T_b, T_theta >	integrate_1d (const F &f, const T_a &a, const T_b &b, const std::vector< T_theta > &theta, const std::vector< double > &x_r, const std::vector< int > &x_i, std::ostream *msgs, const double relative_tolerance)
	Compute the integral of the single variable function f from a to b to within a specified relative tolerance.
template<typename T , typename F >
void	jacobian (const F &f, const Eigen::Matrix< T, Eigen::Dynamic, 1 > &x, Eigen::Matrix< T, Eigen::Dynamic, 1 > &fx, Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > &J)
template<typename T >
fvar< T >	std_normal_log_qf (const fvar< T > &p)
template<typename T >
bool	is_aligned (T *ptr, unsigned int bytes_aligned)
	Return true if the specified pointer is aligned on the number of bytes.
template<typename T , typename F >
void	derivative (const F &f, const T &x, T &fx, T &dfx_dx)
	Return the derivative of the specified univariate function at the specified argument.
template<typename F >
void	finite_diff_grad_hessian (const F &f, const Eigen::VectorXd &x, double &fx, Eigen::MatrixXd &hess, std::vector< Eigen::MatrixXd > &grad_hess_fx, double epsilon=1e-04)
	Calculate the value and the gradient of the hessian of the specified function at the specified argument using second-order autodiff and first-order finite difference.
template<typename F >
void	finite_diff_grad_hessian_auto (const F &f, const Eigen::VectorXd &x, double &fx, Eigen::MatrixXd &hess, std::vector< Eigen::MatrixXd > &grad_hess_fx)
	Calculate the value, Hessian, and the gradient of the Hessian of the specified function at the specified argument using second-order autodiff and first-order finite difference.
template<typename F >
void	grad_hessian (const F &f, const Eigen::Matrix< double, Eigen::Dynamic, 1 > &x, double &fx, Eigen::Matrix< double, Eigen::Dynamic, Eigen::Dynamic > &H, std::vector< Eigen::Matrix< double, Eigen::Dynamic, Eigen::Dynamic > > &grad_H)
	Calculate the value, the Hessian, and the gradient of the Hessian of the specified function at the specified argument.
template<typename F >
void	grad_tr_mat_times_hessian (const F &f, const Eigen::Matrix< double, Eigen::Dynamic, 1 > &x, const Eigen::Matrix< double, Eigen::Dynamic, Eigen::Dynamic > &M, Eigen::Matrix< double, Eigen::Dynamic, 1 > &grad_tr_MH)
template<typename T1 , typename T2 , typename F >
void	gradient_dot_vector (const F &f, const Eigen::Matrix< T1, Eigen::Dynamic, 1 > &x, const Eigen::Matrix< T2, Eigen::Dynamic, 1 > &v, T1 &fx, T1 &grad_fx_dot_v)
template<typename F >
void	hessian (const F &f, const Eigen::Matrix< double, Eigen::Dynamic, 1 > &x, double &fx, Eigen::Matrix< double, Eigen::Dynamic, 1 > &grad, Eigen::Matrix< double, Eigen::Dynamic, Eigen::Dynamic > &H)
	Calculate the value, the gradient, and the Hessian, of the specified function at the specified argument in O(N^2) time and O(N^2) space.
template<typename F >
void	hessian_times_vector (const F &f, const Eigen::Matrix< double, Eigen::Dynamic, 1 > &x, const Eigen::Matrix< double, Eigen::Dynamic, 1 > &v, double &fx, Eigen::Matrix< double, Eigen::Dynamic, 1 > &Hv)
template<typename T , typename F >
void	hessian_times_vector (const F &f, const Eigen::Matrix< T, Eigen::Dynamic, 1 > &x, const Eigen::Matrix< T, Eigen::Dynamic, 1 > &v, T &fx, Eigen::Matrix< T, Eigen::Dynamic, 1 > &Hv)
template<typename T , typename F >
void	partial_derivative (const F &f, const Eigen::Matrix< T, Eigen::Dynamic, 1 > &x, int n, T &fx, T &dfx_dxn)
	Return the partial derivative of the specified multivariate function at the specified argument.
template<typename T , require_st_arithmetic< T > * = nullptr>
matrix_cl< scalar_type_t< T > >	to_matrix_cl (T &&src)
	Copies the source Eigen matrix, std::vector or scalar to the destination matrix that is stored on the OpenCL device.
template<typename T_ret , typename T , require_eigen_t< T_ret > * = nullptr, require_matrix_cl_t< T > * = nullptr, require_st_same< T_ret, T > * = nullptr>
auto	from_matrix_cl (const T &src)
	Copies the source matrix that is stored on the OpenCL device to the destination Eigen matrix.
template<typename T_ret , typename T , require_all_kernel_expressions_t< T > * = nullptr, require_not_matrix_cl_t< T > * = nullptr>
auto	from_matrix_cl (const T &src)
	Copies result of a kernel generator expression to the specified destination type.
template<typename T_dst , typename T , require_arithmetic_t< T > * = nullptr, require_same_t< T_dst, T > * = nullptr>
T_dst	from_matrix_cl (const matrix_cl< T > &src)
	Copy A 1 by 1 source matrix from the Device to the host.
template<typename T , require_all_kernel_expressions_t< T > * = nullptr>
auto	from_matrix_cl (const T &src)
	Copies the source kernel generator expression or matrix that is stored on the OpenCL device to the destination Eigen matrix.
template<typename T , require_matrix_cl_t< T > * = nullptr>
auto	packed_copy (const T &src)
	Packs the square flat triangular matrix on the OpenCL device and copies it to the std::vector.
template<matrix_cl_view matrix_view, typename Vec , typename Vec_scalar = scalar_type_t<Vec>, require_vector_vt< std::is_arithmetic, Vec > * = nullptr>
matrix_cl< Vec_scalar >	packed_copy (Vec &&src, int rows)
	Copies the packed triangular matrix from the source std::vector to an OpenCL buffer and unpacks it to a flat matrix on the OpenCL device.
template<typename T , require_matrix_cl_t< T > * = nullptr>
plain_type_t< T >	copy_cl (const T &src)
	Copies the source matrix to the destination matrix.
template<typename T >
void	check_mat_not_size_one (const char *function, const char *name, const matrix_cl< T > &A)
	Check if the matrix_cl has a single element.
void	check_opencl_error (const char *function, const cl::Error &e)
	Throws the domain error with specifying the OpenCL error that occurred.
template<typename T , typename = require_arithmetic_t<T>>
void	check_symmetric (const char *function, const char *name, const matrix_cl< T > &y)
	Check if the matrix_cl is symmetric.
template<typename T , require_matrix_cl_t< T > * = nullptr>
void	check_triangular (const char *function, const char *name, const T &A)
	Check if the matrix_cl is either upper triangular or lower triangular.
void	indexing_rev (matrix_cl< double > &adj, const matrix_cl< int > &idx, const matrix_cl< double > &res)
	Performs reverse pass for indexing operation on the OpenCL device.
template<typename Ta , typename Tb , typename = require_all_kernel_expressions_and_none_scalar_t<Ta, Tb>>
auto	append_row (Ta &&a, Tb &&b)
	Stack the rows of the first argument on top of the second argument.
template<typename Ta , typename Tb , typename = require_all_kernel_expressions_and_none_scalar_t<Ta, Tb>>
auto	append_col (Ta &&a, Tb &&b)
	Stack the cols of the arguments.
template<typename T , require_all_kernel_expressions_and_none_scalar_t< T > * = nullptr>
auto	as_column_vector_or_scalar (T &&a)
	as_column_vector_or_scalar of a kernel generator expression.
template<assign_op_cl AssignOp = assign_op_cl::equals, typename T_operation , typename = std::enable_if_t<std::is_base_of< operation_cl_base, std::remove_reference_t<T_operation>>::value>>
T_operation &&	as_operation_cl (T_operation &&a)
	Converts any valid kernel generator expression into an operation.
template<assign_op_cl AssignOp = assign_op_cl::equals, typename T_scalar , typename = require_arithmetic_t<T_scalar>, require_not_same_t< T_scalar, bool > * = nullptr>
scalar_< T_scalar >	as_operation_cl (const T_scalar a)
	Converts any valid kernel generator expression into an operation.
template<assign_op_cl AssignOp = assign_op_cl::equals>
scalar_< char >	as_operation_cl (const bool a)
	Converts any valid kernel generator expression into an operation.
template<assign_op_cl AssignOp = assign_op_cl::equals, typename T_matrix_cl , typename = require_any_t<is_matrix_cl<T_matrix_cl>, is_arena_matrix_cl<T_matrix_cl>>>
load_< T_matrix_cl, AssignOp >	as_operation_cl (T_matrix_cl &&a)
	Converts any valid kernel generator expression into an operation.
template<typename T >
constexpr const char *	assignment_op () noexcept
template<typename T_a , typename T_b , require_all_kernel_expressions_t< T_a, T_b > * = nullptr, require_any_not_arithmetic_t< T_a, T_b > * = nullptr>
addition_operator_< as_operation_cl_t< T_a >, as_operation_cl_t< T_b > >	operator+ (T_a &&a, T_b &&b)
template<typename T_a , typename T_b , require_all_kernel_expressions_t< T_a, T_b > * = nullptr, require_any_not_arithmetic_t< T_a, T_b > * = nullptr>
addition_< as_operation_cl_t< T_a >, as_operation_cl_t< T_b > >	add (T_a &&a, T_b &&b)
template<typename T_a , typename T_b , require_all_kernel_expressions_t< T_a, T_b > * = nullptr, require_any_not_arithmetic_t< T_a, T_b > * = nullptr>
subtraction_operator_< as_operation_cl_t< T_a >, as_operation_cl_t< T_b > >	operator- (T_a &&a, T_b &&b)
template<typename T_a , typename T_b , require_all_kernel_expressions_t< T_a, T_b > * = nullptr, require_any_not_arithmetic_t< T_a, T_b > * = nullptr>
subtraction_< as_operation_cl_t< T_a >, as_operation_cl_t< T_b > >	subtract (T_a &&a, T_b &&b)
template<typename T_a , typename T_b , require_all_kernel_expressions_t< T_a, T_b > * = nullptr, require_any_not_arithmetic_t< T_a, T_b > * = nullptr>
elt_multiply_< as_operation_cl_t< T_a >, as_operation_cl_t< T_b > >	elt_multiply (T_a &&a, T_b &&b)
template<typename T_a , typename T_b , require_all_kernel_expressions_t< T_a, T_b > * = nullptr, require_any_not_arithmetic_t< T_a, T_b > * = nullptr>
elt_divide_< as_operation_cl_t< T_a >, as_operation_cl_t< T_b > >	elt_divide (T_a &&a, T_b &&b)
template<typename T_a , typename T_b , require_all_kernel_expressions_t< T_a, T_b > * = nullptr, require_any_not_arithmetic_t< T_a, T_b > * = nullptr>
elt_modulo_< as_operation_cl_t< T_a >, as_operation_cl_t< T_b > >	operator% (T_a &&a, T_b &&b)
template<typename T_a , typename T_b , require_all_kernel_expressions_t< T_a, T_b > * = nullptr, require_any_not_arithmetic_t< T_a, T_b > * = nullptr>
less_than_< as_operation_cl_t< T_a >, as_operation_cl_t< T_b > >	operator< (T_a &&a, T_b &&b)
template<typename T_a , typename T_b , require_all_kernel_expressions_t< T_a, T_b > * = nullptr, require_any_not_arithmetic_t< T_a, T_b > * = nullptr>
less_than_or_equal_< as_operation_cl_t< T_a >, as_operation_cl_t< T_b > >	operator<= (T_a &&a, T_b &&b)
template<typename T_a , typename T_b , require_all_kernel_expressions_t< T_a, T_b > * = nullptr, require_any_not_arithmetic_t< T_a, T_b > * = nullptr>
greater_than_< as_operation_cl_t< T_a >, as_operation_cl_t< T_b > >	operator> (T_a &&a, T_b &&b)
template<typename T_a , typename T_b , require_all_kernel_expressions_t< T_a, T_b > * = nullptr, require_any_not_arithmetic_t< T_a, T_b > * = nullptr>
greater_than_or_equal_< as_operation_cl_t< T_a >, as_operation_cl_t< T_b > >	operator>= (T_a &&a, T_b &&b)
template<typename T_a , typename T_b , require_all_kernel_expressions_t< T_a, T_b > * = nullptr, require_any_not_arithmetic_t< T_a, T_b > * = nullptr>
equals_< as_operation_cl_t< T_a >, as_operation_cl_t< T_b > >	operator== (T_a &&a, T_b &&b)
template<typename T_a , typename T_b , require_all_kernel_expressions_t< T_a, T_b > * = nullptr, require_any_not_arithmetic_t< T_a, T_b > * = nullptr>
not_equals_< as_operation_cl_t< T_a >, as_operation_cl_t< T_b > >	operator!= (T_a &&a, T_b &&b)
template<typename T_a , typename T_b , require_all_kernel_expressions_t< T_a, T_b > * = nullptr, require_any_not_arithmetic_t< T_a, T_b > * = nullptr>
logical_or_< as_operation_cl_t< T_a >, as_operation_cl_t< T_b > >	operator|| (T_a &&a, T_b &&b)
template<typename T_a , typename T_b , require_all_kernel_expressions_t< T_a, T_b > * = nullptr, require_any_not_arithmetic_t< T_a, T_b > * = nullptr>
logical_and_< as_operation_cl_t< T_a >, as_operation_cl_t< T_b > >	operator&& (T_a &&a, T_b &&b)
template<typename T_a , typename T_b , typename = require_arithmetic_t<T_a>, typename = require_all_kernel_expressions_t<T_b>>
elt_multiply_< as_operation_cl_t< T_a >, as_operation_cl_t< T_b > >	operator* (T_a a, T_b &&b)
	Multiplication of a scalar and a kernel generator expression.
template<typename T_a , typename T_b , typename = require_all_kernel_expressions_t<T_a>, typename = require_arithmetic_t<T_b>>
elt_multiply_< as_operation_cl_t< T_a >, as_operation_cl_t< T_b > >	operator* (T_a &&a, const T_b b)
	Multiplication of a kernel generator expression and a scalar.
template<typename T , typename = require_all_kernel_expressions_and_none_scalar_t<T>>
auto	block_zero_based (T &&a, int start_row, int start_col, int rows, int cols)
	Block of a kernel generator expression.
template<bool Colwise, bool Rowwise, typename T , typename = require_all_kernel_expressions_and_none_scalar_t<T>>
auto	broadcast (T &&a)
	Broadcast an expression in specified dimension(s).
template<typename T , typename = require_all_kernel_expressions_and_none_scalar_t<T>>
auto	rowwise_broadcast (T &&a)
	Broadcast an expression in rowwise dimmension.
template<typename T , typename = require_all_kernel_expressions_and_none_scalar_t<T>>
auto	colwise_broadcast (T &&a)
	Broadcast an expression in colwise dimmension.
template<bool Do_Calculate, typename T , require_all_kernel_expressions_t< T > * = nullptr, std::enable_if_t< Do_Calculate > * = nullptr>
calc_if_< true, as_operation_cl_t< T > >	calc_if (T &&a)
template<bool Do_Calculate, typename T , std::enable_if_t<!Do_Calculate > * = nullptr>
calc_if_< false, scalar_< double > >	calc_if (T &&a)
template<typename Scalar , typename T , require_all_kernel_expressions_and_none_scalar_t< T > * = nullptr>
auto	cast (T &&a)
	Typecast a kernel generator expression scalar.
template<typename Scalar , typename T , require_stan_scalar_t< T > * = nullptr>
Scalar	cast (T a)
	Typecast a scalar.
template<typename T , typename = require_all_kernel_expressions_t<T>>
auto	check_cl (const char *function, const char *var_name, T &&y, const char *must_be)
	Constructs a check on opencl matrix or expression.
template<typename T , require_all_kernel_expressions_t< T > * = nullptr>
auto	colwise_sum (T &&a)
	Column wise sum - reduction of a kernel generator expression.
template<typename T , require_all_kernel_expressions_t< T > * = nullptr>
auto	colwise_prod (T &&a)
	Column wise product - reduction of a kernel generator expression.
template<typename T , require_all_kernel_expressions_t< T > * = nullptr>
auto	colwise_max (T &&a)
	Column wise max - reduction of a kernel generator expression.
template<typename T , require_all_kernel_expressions_t< T > * = nullptr>
auto	colwise_min (T &&a)
	Column wise min - reduction of a kernel generator expression.
template<typename T1 , typename T2 , require_kernel_expression_lhs_t< T1 > * = nullptr, require_all_kernel_expressions_t< T2 > * = nullptr>
T1	operator+= (T1 &&a, T2 &&b)
template<typename T1 , typename T2 , require_kernel_expression_lhs_t< T1 > * = nullptr, require_all_kernel_expressions_t< T2 > * = nullptr>
T1	operator-= (T1 &&a, T2 &&b)
template<typename T1 , typename T2 , require_kernel_expression_lhs_t< T1 > * = nullptr, require_all_kernel_expressions_t< T2 > * = nullptr>
T1	operator*= (T1 &&a, T2 &&b)
template<typename T , typename = require_arithmetic_t<T>>
auto	constant (const T a, int rows, int cols)
	Matrix of repeated values in kernel generator expressions.
template<typename T , typename = require_all_kernel_expressions_and_none_scalar_t<T>>
auto	diagonal (T &&a)
	Diagonal of a kernel generator expression.
template<typename T , typename Cond = require_all_kernel_expressions_and_none_scalar_t<T>>
rsqrt_< as_operation_cl_t< T > >	rsqrt (T &&a)
template<typename T , typename Cond = require_all_kernel_expressions_and_none_scalar_t<T>>
sqrt_< as_operation_cl_t< T > >	sqrt (T &&a)
template<typename T , typename Cond = require_all_kernel_expressions_and_none_scalar_t<T>>
cbrt_< as_operation_cl_t< T > >	cbrt (T &&a)
template<typename T , typename Cond = require_all_kernel_expressions_and_none_scalar_t<T>>
exp_< as_operation_cl_t< T > >	exp (T &&a)
template<typename T , typename Cond = require_all_kernel_expressions_and_none_scalar_t<T>>
exp2_< as_operation_cl_t< T > >	exp2 (T &&a)
template<typename T , typename Cond = require_all_kernel_expressions_and_none_scalar_t<T>>
expm1_< as_operation_cl_t< T > >	expm1 (T &&a)
template<typename T , typename Cond = require_all_kernel_expressions_and_none_scalar_t<T>>
log_< as_operation_cl_t< T > >	log (T &&a)
template<typename T , typename Cond = require_all_kernel_expressions_and_none_scalar_t<T>>
log2_< as_operation_cl_t< T > >	log2 (T &&a)
template<typename T , typename Cond = require_all_kernel_expressions_and_none_scalar_t<T>>
log10_< as_operation_cl_t< T > >	log10 (T &&a)
template<typename T , typename Cond = require_all_kernel_expressions_and_none_scalar_t<T>>
log1p_< as_operation_cl_t< T > >	log1p (T &&a)
template<typename T , typename Cond = require_all_kernel_expressions_and_none_scalar_t<T>>
sin_< as_operation_cl_t< T > >	sin (T &&a)
template<typename T , typename Cond = require_all_kernel_expressions_and_none_scalar_t<T>>
sinh_< as_operation_cl_t< T > >	sinh (T &&a)
template<typename T , typename Cond = require_all_kernel_expressions_and_none_scalar_t<T>>
cos_< as_operation_cl_t< T > >	cos (T &&a)
template<typename T , typename Cond = require_all_kernel_expressions_and_none_scalar_t<T>>
cosh_< as_operation_cl_t< T > >	cosh (T &&a)
template<typename T , typename Cond = require_all_kernel_expressions_and_none_scalar_t<T>>
tan_< as_operation_cl_t< T > >	tan (T &&a)
template<typename T , typename Cond = require_all_kernel_expressions_and_none_scalar_t<T>>
tanh_< as_operation_cl_t< T > >	tanh (T &&a)
template<typename T , typename Cond = require_all_kernel_expressions_and_none_scalar_t<T>>
asin_< as_operation_cl_t< T > >	asin (T &&a)
template<typename T , typename Cond = require_all_kernel_expressions_and_none_scalar_t<T>>
asinh_< as_operation_cl_t< T > >	asinh (T &&a)
template<typename T , typename Cond = require_all_kernel_expressions_and_none_scalar_t<T>>
acos_< as_operation_cl_t< T > >	acos (T &&a)
template<typename T , typename Cond = require_all_kernel_expressions_and_none_scalar_t<T>>
acosh_< as_operation_cl_t< T > >	acosh (T &&a)
template<typename T , typename Cond = require_all_kernel_expressions_and_none_scalar_t<T>>
atan_< as_operation_cl_t< T > >	atan (T &&a)
template<typename T , typename Cond = require_all_kernel_expressions_and_none_scalar_t<T>>
atanh_< as_operation_cl_t< T > >	atanh (T &&a)
template<typename T , typename Cond = require_all_kernel_expressions_and_none_scalar_t<T>>
tgamma_< as_operation_cl_t< T > >	tgamma (T &&a)
template<typename T , typename Cond = require_all_kernel_expressions_and_none_scalar_t<T>>
lgamma_< as_operation_cl_t< T > >	lgamma (T &&a)
template<typename T , typename Cond = require_all_kernel_expressions_and_none_scalar_t<T>>
erf_< as_operation_cl_t< T > >	erf (T &&a)
template<typename T , typename Cond = require_all_kernel_expressions_and_none_scalar_t<T>>
erfc_< as_operation_cl_t< T > >	erfc (T &&a)
template<typename T , typename Cond = require_all_kernel_expressions_and_none_scalar_t<T>>
floor_< as_operation_cl_t< T > >	floor (T &&a)
template<typename T , typename Cond = require_all_kernel_expressions_and_none_scalar_t<T>>
round_< as_operation_cl_t< T > >	round (T &&a)
template<typename T , typename Cond = require_all_kernel_expressions_and_none_scalar_t<T>>
ceil_< as_operation_cl_t< T > >	ceil (T &&a)
template<typename T , typename Cond = require_all_kernel_expressions_and_none_scalar_t<T>>
fabs_< as_operation_cl_t< T > >	fabs (T &&a)
template<typename T , typename Cond = require_all_kernel_expressions_and_none_scalar_t<T>>
trunc_< as_operation_cl_t< T > >	trunc (T &&a)
template<typename T , typename Cond = require_all_kernel_expressions_and_none_scalar_t<T>>
digamma_< as_operation_cl_t< T > >	digamma (T &&a)
template<typename T , typename Cond = require_all_kernel_expressions_and_none_scalar_t<T>>
log1m_< as_operation_cl_t< T > >	log1m (T &&a)
template<typename T , typename Cond = require_all_kernel_expressions_and_none_scalar_t<T>>
log_inv_logit_< as_operation_cl_t< T > >	log_inv_logit (T &&a)
template<typename T , typename Cond = require_all_kernel_expressions_and_none_scalar_t<T>>
log1m_exp_< as_operation_cl_t< T > >	log1m_exp (T &&a)
template<typename T , typename Cond = require_all_kernel_expressions_and_none_scalar_t<T>>
log1p_exp_< as_operation_cl_t< T > >	log1p_exp (T &&a)
template<typename T , typename Cond = require_all_kernel_expressions_and_none_scalar_t<T>>
inv_square_< as_operation_cl_t< T > >	inv_square (T &&a)
template<typename T , typename Cond = require_all_kernel_expressions_and_none_scalar_t<T>>
inv_logit_< as_operation_cl_t< T > >	inv_logit (T &&a)
template<typename T , typename Cond = require_all_kernel_expressions_and_none_scalar_t<T>>
logit_< as_operation_cl_t< T > >	logit (T &&a)
template<typename T , typename Cond = require_all_kernel_expressions_and_none_scalar_t<T>>
Phi_< as_operation_cl_t< T > >	Phi (T &&a)
template<typename T , typename Cond = require_all_kernel_expressions_and_none_scalar_t<T>>
Phi_approx_< as_operation_cl_t< T > >	Phi_approx (T &&a)
template<typename T , typename Cond = require_all_kernel_expressions_and_none_scalar_t<T>>
inv_Phi_< as_operation_cl_t< T > >	inv_Phi (T &&a)
template<typename T , typename Cond = require_all_kernel_expressions_and_none_scalar_t<T>>
log1m_inv_logit_< as_operation_cl_t< T > >	log1m_inv_logit (T &&a)
template<typename T , typename Cond = require_all_kernel_expressions_and_none_scalar_t<T>>
trigamma_< as_operation_cl_t< T > >	trigamma (T &&a)
template<typename T , typename Cond = require_all_kernel_expressions_and_none_scalar_t<T>>
square_< as_operation_cl_t< T > >	square (T &&a)
template<typename T , typename Cond = require_all_kernel_expressions_and_none_scalar_t<T>>
isfinite_< as_operation_cl_t< T > >	isfinite (T &&a)
template<typename T , typename Cond = require_all_kernel_expressions_and_none_scalar_t<T>>
isinf_< as_operation_cl_t< T > >	isinf (T &&a)
template<typename T , typename Cond = require_all_kernel_expressions_and_none_scalar_t<T>>
isnan_< as_operation_cl_t< T > >	isnan (T &&a)
template<typename T1 , typename T2 , require_all_kernel_expressions_t< T1, T2 > * = nullptr, require_any_not_stan_scalar_t< T1, T2 > * = nullptr>
fdim_< as_operation_cl_t< T1 >, as_operation_cl_t< T2 > >	fdim (T1 &&a, T2 &&b)
template<typename T1 , typename T2 , require_all_kernel_expressions_t< T1, T2 > * = nullptr, require_any_not_stan_scalar_t< T1, T2 > * = nullptr>
fmax_< as_operation_cl_t< T1 >, as_operation_cl_t< T2 > >	fmax (T1 &&a, T2 &&b)
template<typename T1 , typename T2 , require_all_kernel_expressions_t< T1, T2 > * = nullptr, require_any_not_stan_scalar_t< T1, T2 > * = nullptr>
fmin_< as_operation_cl_t< T1 >, as_operation_cl_t< T2 > >	fmin (T1 &&a, T2 &&b)
template<typename T1 , typename T2 , require_all_kernel_expressions_t< T1, T2 > * = nullptr, require_any_not_stan_scalar_t< T1, T2 > * = nullptr>
fmod_< as_operation_cl_t< T1 >, as_operation_cl_t< T2 > >	fmod (T1 &&a, T2 &&b)
template<typename T1 , typename T2 , require_all_kernel_expressions_t< T1, T2 > * = nullptr, require_any_not_stan_scalar_t< T1, T2 > * = nullptr>
hypot_< as_operation_cl_t< T1 >, as_operation_cl_t< T2 > >	hypot (T1 &&a, T2 &&b)
template<typename T1 , typename T2 , require_all_kernel_expressions_t< T1, T2 > * = nullptr, require_any_not_stan_scalar_t< T1, T2 > * = nullptr>
ldexp_< as_operation_cl_t< T1 >, as_operation_cl_t< T2 > >	ldexp (T1 &&a, T2 &&b)
template<typename T1 , typename T2 , require_all_kernel_expressions_t< T1, T2 > * = nullptr, require_any_not_stan_scalar_t< T1, T2 > * = nullptr>
pow_< as_operation_cl_t< T1 >, as_operation_cl_t< T2 > >	pow (T1 &&a, T2 &&b)
template<typename T1 , typename T2 , require_all_kernel_expressions_t< T1, T2 > * = nullptr, require_any_not_stan_scalar_t< T1, T2 > * = nullptr>
copysign_< as_operation_cl_t< T1 >, as_operation_cl_t< T2 > >	copysign (T1 &&a, T2 &&b)
template<typename T1 , typename T2 , require_all_kernel_expressions_t< T1, T2 > * = nullptr, require_any_not_stan_scalar_t< T1, T2 > * = nullptr>
beta_< as_operation_cl_t< T1 >, as_operation_cl_t< T2 > >	beta (T1 &&a, T2 &&b)
template<typename T1 , typename T2 , require_all_kernel_expressions_t< T1, T2 > * = nullptr, require_any_not_stan_scalar_t< T1, T2 > * = nullptr>
binomial_coefficient_log_< as_operation_cl_t< T1 >, as_operation_cl_t< T2 > >	binomial_coefficient_log (T1 &&a, T2 &&b)
template<typename T1 , typename T2 , require_all_kernel_expressions_t< T1, T2 > * = nullptr, require_any_not_stan_scalar_t< T1, T2 > * = nullptr>
lbeta_< as_operation_cl_t< T1 >, as_operation_cl_t< T2 > >	lbeta (T1 &&a, T2 &&b)
template<typename T1 , typename T2 , require_all_kernel_expressions_t< T1, T2 > * = nullptr, require_any_not_stan_scalar_t< T1, T2 > * = nullptr>
log_inv_logit_diff_< as_operation_cl_t< T1 >, as_operation_cl_t< T2 > >	log_inv_logit_diff (T1 &&a, T2 &&b)
template<typename T1 , typename T2 , require_all_kernel_expressions_t< T1, T2 > * = nullptr, require_any_not_stan_scalar_t< T1, T2 > * = nullptr>
log_diff_exp_< as_operation_cl_t< T1 >, as_operation_cl_t< T2 > >	log_diff_exp (T1 &&a, T2 &&b)
template<typename T1 , typename T2 , require_all_kernel_expressions_t< T1, T2 > * = nullptr, require_any_not_stan_scalar_t< T1, T2 > * = nullptr>
multiply_log_< as_operation_cl_t< T1 >, as_operation_cl_t< T2 > >	multiply_log (T1 &&a, T2 &&b)
template<typename T1 , typename T2 , require_all_kernel_expressions_t< T1, T2 > * = nullptr, require_any_not_stan_scalar_t< T1, T2 > * = nullptr>
lmultiply_< as_operation_cl_t< T1 >, as_operation_cl_t< T2 > >	lmultiply (T1 &&a, T2 &&b)
template<typename T , typename... Ptrs, require_all_kernel_expressions_t< T, Ptrs... > * = nullptr>
auto	holder_cl (T &&a, Ptrs *... ptrs)
	Constructs a no-op operation that also holds pointer to some other expressions, allocated on heap.
template<typename T , typename... Args, require_all_kernel_expressions_t< decltype(std::declval< T >()(std::declval< Args & >()...)), Args... > * = nullptr>
auto	make_holder_cl (const T &func, Args &&... args)
	Constructs an expression from given arguments using given functor.
template<typename T_mat , typename T_row_index , typename T_col_index , require_all_kernel_expressions_t< T_mat, T_row_index, T_col_index > * = nullptr>
auto	indexing (T_mat &&mat, T_row_index &&row_index, T_col_index &&col_index)
	Index a kernel generator expression using two expressions for indices.
template<typename T_matrix , typename T_vector , typename = require_all_kernel_expressions_t<T_matrix, T_vector>>
auto	matrix_vector_multiply (T_matrix &&matrix, T_vector &&vector)
	Multiplies a matrix and a vector on an OpenCL device.
template<typename... T_expressions>
expressions_cl< T_expressions... >	expressions (T_expressions &&... expressions)
	Deduces types for constructing expressions_cl object.
template<typename... T_results>
results_cl< T_results... >	results (T_results &&... results)
	Deduces types for constructing results_cl object.
template<const char * Code, typename... T_arguments, require_all_kernel_expressions_t< T_arguments... > * = nullptr>
auto	opencl_code (std::tuple< typename std::pair< const char *, T_arguments >::first_type... > names, T_arguments &&... arguments)
	Custom code in kernel generator expressions.
std::ostream &	operator<< (std::ostream &os, kernel_parts &parts)
template<bool Colwise, bool Rowwise, typename T , typename = require_all_kernel_expressions_and_none_scalar_t<T>>
optional_broadcast_< as_operation_cl_t< T >, Colwise, Rowwise >	optional_broadcast (T &&a)
	Broadcast an expression in specified dimension(s) if the size along that dimension equals 1.
template<typename T , typename = require_all_kernel_expressions_and_none_scalar_t<T>>
auto	rowwise_optional_broadcast (T &&a)
	Broadcast an expression in rowwise dimmension if the number of columns equals to 1.
template<typename T , typename = require_all_kernel_expressions_and_none_scalar_t<T>>
auto	colwise_optional_broadcast (T &&a)
	Broadcast an expression in colwise dimmension if the number of rows equals to 1.
template<typename T , require_all_kernel_expressions_t< T > * = nullptr>
auto	sum_2d (T &&a)
	Two dimensional sum - reduction of a kernel generator expression.
template<typename T , require_all_kernel_expressions_t< T > * = nullptr>
auto	prod_2d (T &&a)
	Two dimensional product - reduction of a kernel generator expression.
template<typename T , require_all_kernel_expressions_t< T > * = nullptr>
auto	max_2d (T &&a)
	Two dimensional max - reduction of a kernel generator expression.
template<typename T , require_all_kernel_expressions_t< T > * = nullptr>
auto	min_2d (T &&a)
	Two dimensional min - reduction of a kernel generator expression.
template<typename T , typename = require_all_kernel_expressions_and_none_scalar_t<T>>
auto	rowwise_sum (T &&a)
	Rowwise sum reduction of a kernel generator expression.
template<typename T , typename = require_all_kernel_expressions_and_none_scalar_t<T>>
auto	rowwise_prod (T &&a)
	Rowwise product reduction of a kernel generator expression.
template<typename T , typename = require_all_kernel_expressions_and_none_scalar_t<T>>
auto	rowwise_max (T &&a)
	Rowwise max reduction of a kernel generator expression.
template<typename T , typename = require_all_kernel_expressions_and_none_scalar_t<T>>
auto	rowwise_min (T &&a)
	Min reduction of a kernel generator expression.
template<typename T_condition , typename T_then , typename T_else , require_all_kernel_expressions_t< T_condition, T_then, T_else > * = nullptr, require_any_not_arithmetic_t< T_condition, T_then, T_else > * = nullptr>
select_< as_operation_cl_t< T_condition >, as_operation_cl_t< T_then >, as_operation_cl_t< T_else > >	select (T_condition &&condition, T_then &&then, T_else &&els)
	Selection operation on kernel generator expressions.
template<typename Arg , typename = require_all_kernel_expressions_and_none_scalar_t<Arg>>
auto	transpose (Arg &&a)
	Transposes a kernel generator expression.
template<typename T >
std::string	type_str ()
	Determines a string name of a type.
template<>
std::string	type_str< double > ()
template<>
std::string	type_str< int > ()
template<>
std::string	type_str< char > ()
template<>
std::string	type_str< bool > ()
template<typename T , require_all_kernel_expressions_and_none_scalar_t< T > * = nullptr>
logical_negation_< as_operation_cl_t< T > >	operator! (T &&a)
	Logical negation of a kernel generator expression.
template<typename T , require_all_kernel_expressions_and_none_scalar_t< T > * = nullptr>
unary_minus_< as_operation_cl_t< T > >	operator- (T &&a)
	Unary minus of a kernel generator expression.
const matrix_cl_view	either (const matrix_cl_view left_view, const matrix_cl_view right_view)
	Determines which parts are nonzero in any of the input views.
const matrix_cl_view	both (const matrix_cl_view left_view, const matrix_cl_view right_view)
	Determines which parts are nonzero in both input views.
bool	contains_nonzero (const matrix_cl_view view, const matrix_cl_view part)
	Check whether a view contains certain nonzero part.
const matrix_cl_view	transpose (const matrix_cl_view view)
	Transposes a view - swaps lower and upper parts.
const matrix_cl_view	invert (const matrix_cl_view view)
	Inverts a view.
matrix_cl_view	from_eigen_uplo_type (Eigen::UpLoType eigen_type)
	Creates a view from Eigen::UpLoType.
int	either (int left_view, int right_view)
	Determines which parts are nonzero in any of the input views.
int	both (int left_view, int right_view)
	Determines which parts are nonzero in both input views.
bool	contains_nonzero (int view, int part)
	Check whether a view contains certain nonzero part.
template<typename T , typename = require_arithmetic_t<T>>
matrix_cl< T >	multiply_transpose (const matrix_cl< T > &A)
	Computes the product of a square OpenCL matrix with its transpose.
template<typename T_m , typename T_a , require_all_kernel_expressions_and_none_scalar_t< T_m > * = nullptr, require_all_kernel_expressions_t< T_a > * = nullptr>
auto	add_diag (T_m &&mat, T_a &&to_add)
	Returns a Matrix with values added along the main diagonal.
template<typename T_x , typename T_y , require_all_nonscalar_prim_or_rev_kernel_expression_t< T_x, T_y > * = nullptr>
auto	append_array (T_x &&x, T_y &&y)
	Return the concatenation of two specified vectors in the order of the arguments.
template<typename T_n_cl , typename T_prob_cl , require_all_prim_or_rev_kernel_expression_t< T_n_cl, T_prob_cl > * = nullptr, require_any_not_stan_scalar_t< T_n_cl, T_prob_cl > * = nullptr>
return_type_t< T_prob_cl >	bernoulli_cdf (const T_n_cl &n, const T_prob_cl &theta)
	Returns the CDF of the Bernoulli distribution.
template<typename T_n_cl , typename T_prob_cl , require_all_prim_or_rev_kernel_expression_t< T_n_cl, T_prob_cl > * = nullptr, require_any_not_stan_scalar_t< T_n_cl, T_prob_cl > * = nullptr>
return_type_t< T_prob_cl >	bernoulli_lccdf (const T_n_cl &n, const T_prob_cl &theta)
	Returns the log CCDF of the Bernoulli distribution.
template<typename T_n_cl , typename T_prob_cl , require_all_prim_or_rev_kernel_expression_t< T_n_cl, T_prob_cl > * = nullptr, require_any_not_stan_scalar_t< T_n_cl, T_prob_cl > * = nullptr>
return_type_t< T_prob_cl >	bernoulli_lcdf (const T_n_cl &n, const T_prob_cl &theta)
	Returns the log CDF of the Bernoulli distribution.
template<bool propto, typename T_x_cl , typename T_y_cl , typename T_alpha_cl , typename T_beta_cl , require_all_prim_or_rev_kernel_expression_t< T_y_cl, T_x_cl, T_alpha_cl, T_beta_cl > * = nullptr>
return_type_t< T_x_cl, T_alpha_cl, T_beta_cl >	bernoulli_logit_glm_lpmf (const T_y_cl &y, const T_x_cl &x, const T_alpha_cl &alpha, const T_beta_cl &beta)
	Returns the log PMF of the Generalized Linear Model (GLM) with Bernoulli distribution and logit link function.
template<bool propto, typename T_n_cl , typename T_prob_cl , require_all_prim_or_rev_kernel_expression_t< T_n_cl, T_prob_cl > * = nullptr, require_any_not_stan_scalar_t< T_n_cl, T_prob_cl > * = nullptr>
return_type_t< T_prob_cl >	bernoulli_logit_lpmf (const T_n_cl &n, const T_prob_cl &theta)
	Returns the log PMF of the logit-parametrized Bernoulli distribution.
template<bool propto, typename T_n_cl , typename T_prob_cl , require_all_prim_or_rev_kernel_expression_t< T_n_cl, T_prob_cl > * = nullptr, require_any_not_stan_scalar_t< T_n_cl, T_prob_cl > * = nullptr>
return_type_t< T_prob_cl >	bernoulli_lpmf (const T_n_cl &n, const T_prob_cl &theta)
	Returns the log PMF of the Bernoulli distribution.
template<bool propto, typename T_n_cl , typename T_N_cl , typename T_size1_cl , typename T_size2_cl , require_all_prim_or_rev_kernel_expression_t< T_n_cl, T_size1_cl, T_size2_cl > * = nullptr, require_any_not_stan_scalar_t< T_n_cl, T_size1_cl, T_size2_cl > * = nullptr>
return_type_t< T_n_cl, T_size1_cl, T_size2_cl >	beta_binomial_lpmf (const T_n_cl &n, const T_N_cl N, const T_size1_cl &alpha, const T_size2_cl &beta)
	Returns the log PMF of the Beta-Binomial distribution with given population size, prior success, and prior failure parameters.
template<bool propto, typename T_y_cl , typename T_scale_succ_cl , typename T_scale_fail_cl , require_all_prim_or_rev_kernel_expression_t< T_y_cl, T_scale_succ_cl, T_scale_fail_cl > * = nullptr, require_any_not_stan_scalar_t< T_y_cl, T_scale_succ_cl, T_scale_fail_cl > * = nullptr>
return_type_t< T_y_cl, T_scale_succ_cl, T_scale_fail_cl >	beta_lpdf (const T_y_cl &y, const T_scale_succ_cl &alpha, const T_scale_fail_cl &beta)
	The log of the beta density for the specified scalar(s) given the specified sample stan::math::size(s).
template<bool propto, typename T_y_cl , typename T_loc_cl , typename T_prec_cl , require_all_prim_or_rev_kernel_expression_t< T_y_cl, T_loc_cl, T_prec_cl > * = nullptr, require_any_not_stan_scalar_t< T_y_cl, T_loc_cl, T_prec_cl > * = nullptr>
return_type_t< T_y_cl, T_loc_cl, T_prec_cl >	beta_proportion_lpdf (const T_y_cl &y, const T_loc_cl &mu, const T_prec_cl &kappa)
	The log of the beta density for specified y, location, and precision: beta_proportion_lpdf(y | mu, kappa) = beta_lpdf(y | mu * kappa, (1 - mu) * kappa).
template<bool propto, typename T_n_cl , typename T_N_cl , typename T_x_cl , typename T_alpha_cl , typename T_beta_cl , require_all_prim_or_rev_kernel_expression_t< T_n_cl, T_N_cl, T_x_cl, T_alpha_cl, T_beta_cl > * = nullptr>
return_type_t< T_x_cl, T_alpha_cl, T_beta_cl >	binomial_logit_glm_lpmf (const T_n_cl &n, const T_N_cl &N, const T_x_cl &x, const T_alpha_cl &alpha, const T_beta_cl &beta)
template<bool propto, typename T_n_cl , typename T_N_cl , typename T_prob_cl , require_all_prim_or_rev_kernel_expression_t< T_n_cl, T_N_cl, T_prob_cl > * = nullptr, require_any_nonscalar_prim_or_rev_kernel_expression_t< T_n_cl, T_N_cl, T_prob_cl > * = nullptr>
return_type_t< T_prob_cl >	binomial_logit_lpmf (const T_n_cl &n, const T_N_cl N, const T_prob_cl &alpha)
	Binomial log PMF in logit parametrization.
template<bool propto, typename T_n_cl , typename T_N_cl , typename T_prob_cl , require_all_prim_or_rev_kernel_expression_t< T_n_cl, T_N_cl, T_prob_cl > * = nullptr, require_any_nonscalar_prim_or_rev_kernel_expression_t< T_n_cl, T_N_cl, T_prob_cl > * = nullptr>
return_type_t< T_prob_cl >	binomial_lpmf (const T_n_cl &n, const T_N_cl N, const T_prob_cl &theta)
	Returns the log PMF for the binomial distribution evaluated at the specified success, population size, and chance of success.
template<typename T_x , typename = require_all_kernel_expressions_and_none_scalar_t<T_x>>
auto	block (T_x &&x, size_t i, size_t j, size_t nrows, size_t ncols)
	Return a nrows x ncols submatrix starting at (i-1, j-1).
template<bool propto, typename T_y , typename T_x , typename T_alpha , typename T_beta , require_all_prim_or_rev_kernel_expression_t< T_y, T_x, T_alpha, T_beta > * = nullptr>
return_type_t< T_x, T_alpha, T_beta >	categorical_logit_glm_lpmf (const T_y &y, const T_x &x, const T_alpha &alpha, const T_beta &beta)
	Returns the log PMF of the Generalized Linear Model (GLM) with categorical distribution and logit (softmax) link function.
template<typename T_y_cl , typename T_loc_cl , typename T_scale_cl , require_all_prim_or_rev_kernel_expression_t< T_y_cl, T_loc_cl, T_scale_cl > * = nullptr, require_any_not_stan_scalar_t< T_y_cl, T_loc_cl, T_scale_cl > * = nullptr>
return_type_t< T_y_cl, T_loc_cl, T_scale_cl >	cauchy_cdf (const T_y_cl &y, const T_loc_cl &mu, const T_scale_cl &sigma)
	Returns the cauchy cumulative distribution function for the given location, and scale.
template<typename T_y_cl , typename T_loc_cl , typename T_scale_cl , require_all_prim_or_rev_kernel_expression_t< T_y_cl, T_loc_cl, T_scale_cl > * = nullptr, require_any_not_stan_scalar_t< T_y_cl, T_loc_cl, T_scale_cl > * = nullptr>
return_type_t< T_y_cl, T_loc_cl, T_scale_cl >	cauchy_lccdf (const T_y_cl &y, const T_loc_cl &mu, const T_scale_cl &sigma)
	Returns the cauchy log complementary cumulative distribution function for the given location, and scale.
template<typename T_y_cl , typename T_loc_cl , typename T_scale_cl , require_all_prim_or_rev_kernel_expression_t< T_y_cl, T_loc_cl, T_scale_cl > * = nullptr, require_any_not_stan_scalar_t< T_y_cl, T_loc_cl, T_scale_cl > * = nullptr>
return_type_t< T_y_cl, T_loc_cl, T_scale_cl >	cauchy_lcdf (const T_y_cl &y, const T_loc_cl &mu, const T_scale_cl &sigma)
	Returns the cauchy cumulative distribution function for the given location, and scale.
template<bool propto, typename T_y_cl , typename T_loc_cl , typename T_scale_cl , require_all_prim_or_rev_kernel_expression_t< T_y_cl, T_loc_cl, T_scale_cl > * = nullptr, require_any_not_stan_scalar_t< T_y_cl, T_loc_cl, T_scale_cl > * = nullptr>
return_type_t< T_y_cl, T_loc_cl, T_scale_cl >	cauchy_lpdf (const T_y_cl &y, const T_loc_cl &mu, const T_scale_cl &sigma)
	The log of the Cauchy density for the specified scalar(s) given the specified location parameter(s) and scale parameter(s).
template<bool propto, typename T_y_cl , typename T_dof_cl , require_all_prim_or_rev_kernel_expression_t< T_y_cl, T_dof_cl > * = nullptr, require_any_not_stan_scalar_t< T_y_cl, T_dof_cl > * = nullptr>
return_type_t< T_y_cl, T_dof_cl >	chi_square_lpdf (const T_y_cl &y, const T_dof_cl &nu)
	The log of a chi-squared density for y with the specified degrees of freedom parameter.
matrix_cl< double >	cholesky_decompose (const matrix_cl< double > &A)
	Returns the lower-triangular Cholesky factor (i.e., matrix square root) of the specified square, symmetric matrix on the OpenCL device.
template<typename T_x , typename = require_nonscalar_prim_or_rev_kernel_expression_t<T_x>>
auto	col (T_x &&x, size_t j)
	Return the specified column of the specified kernel generator expression using start-at-1 indexing.
template<typename T_x , require_nonscalar_prim_or_rev_kernel_expression_t< T_x > * = nullptr>
int64_t	cols (const T_x &x)
	Returns the number of columns in the specified kernel generator expression.
template<typename T_a , typename T_b , require_all_kernel_expressions_and_none_scalar_t< T_a, T_b > * = nullptr>
auto	columns_dot_product (const T_a &a, const T_b &b)
	Returns the dot product of columns of the specified matrices.
template<typename T , require_all_kernel_expressions_and_none_scalar_t< T > * = nullptr>
auto	columns_dot_self (const T &a)
	Returns the dot product of each column of a matrix with itself.
template<typename T , typename L , require_all_kernel_expressions_and_none_scalar_t< T > * = nullptr, require_all_kernel_expressions_t< L > * = nullptr>
auto	lb_constrain (T &&x, L &&lb)
	Return the lower-bounded value for the specified unconstrained input and specified lower bound.
template<typename T , typename L , require_all_kernel_expressions_and_none_scalar_t< T > * = nullptr, require_all_kernel_expressions_t< L > * = nullptr>
auto	lb_constrain (const T &x, const L &lb, return_type_t< T, L > &lp)
	Return the lower-bounded value for the specified unconstrained input and specified lower bound.
template<typename T , typename L , typename U , require_all_kernel_expressions_and_none_scalar_t< T > * = nullptr, require_all_kernel_expressions_t< L, U > * = nullptr>
matrix_cl< double >	lub_constrain (const T &x, const L &lb, const U &ub)
	Return the lower and upper-bounded matrix derived by transforming the specified free matrix given the specified lower and upper bounds.
template<typename T , typename L , typename U , require_all_kernel_expressions_and_none_scalar_t< T > * = nullptr, require_all_kernel_expressions_t< L, U > * = nullptr>
auto	lub_constrain (const T &x, const L &lb, const U &ub, return_type_t< T, L, U > &lp)
	Return the lower and upper-bounded matrix derived by transforming the specified free matrix given the specified lower and upper bounds.
template<typename T , typename M , typename S , require_all_kernel_expressions_t< T, M, S > * = nullptr, require_any_not_stan_scalar_t< T, M, S > * = nullptr>
auto	offset_multiplier_constrain (const T &x, const M &mu, const S &sigma)
	Return the linearly transformed value for the specified unconstrained input and specified offset and multiplier.
template<typename T , typename M , typename S , require_all_kernel_expressions_t< T, M, S > * = nullptr, require_any_not_stan_scalar_t< T, M, S > * = nullptr>
auto	offset_multiplier_constrain (const T &x, const M &mu, const S &sigma, double &lp)
	Return the linearly transformed value for the specified unconstrained input and specified offset and multiplier.
template<typename T , typename U , require_all_kernel_expressions_and_none_scalar_t< T > * = nullptr, require_all_kernel_expressions_t< U > * = nullptr>
auto	ub_constrain (T &&x, U &&ub)
	Return the upper-bounded value for the specified unconstrained matrix and upper bound.
template<typename T , typename U , require_all_kernel_expressions_and_none_scalar_t< T > * = nullptr, require_all_kernel_expressions_t< U > * = nullptr>
auto	ub_constrain (const T &x, const U &ub, return_type_t< T, U > &lp)
	Return the upper-bounded value for the specified unconstrained matrix and upper bound.
template<typename T_x , require_all_kernel_expressions_and_none_scalar_t< T_x > * = nullptr>
auto	unit_vector_constrain (T_x &&x)
	Return the unit length vector corresponding to the given free vector.
template<typename T_x , require_all_kernel_expressions_and_none_scalar_t< T_x > * = nullptr>
auto	unit_vector_constrain (T_x &&x, double &lp)
	Return the unit length vector corresponding to the given free vector.
template<typename T_A , typename = require_all_kernel_expressions_and_none_scalar_t<T_A>>
matrix_cl< typename std::decay_t< T_A >::Scalar >	crossprod (T_A &&A)
	Returns the result of pre-multiplying a matrix by its own transpose.
template<typename T_vec , require_all_kernel_expressions_and_none_scalar_t< T_vec > * = nullptr>
auto	cumulative_sum (T_vec &&v)
	Return the cumulative sum of the specified vector.
template<typename T_x , require_all_kernel_expressions_and_none_scalar_t< T_x > * = nullptr>
auto	diag_matrix (T_x &&x)
	Return a square diagonal matrix with the specified vector of coefficients as the diagonal values.
template<typename T1 , typename T2 , require_all_kernel_expressions_and_none_scalar_t< T1, T2 > * = nullptr>
auto	diag_post_multiply (const T1 &m1, const T2 &m2)
	Return the product of a matrix and the diagonal matrix formed from the vector or row_vector.
template<typename T1 , typename T2 , require_all_kernel_expressions_and_none_scalar_t< T1, T2 > * = nullptr>
auto	diag_pre_multiply (const T1 &m1, const T2 &m2)
	Return the product of the diagonal matrix formed from the vector or row_vector and a matrix.
template<typename T_x , require_nonscalar_prim_or_rev_kernel_expression_t< T_x > * = nullptr>
void	dims (const T_x &x, std::vector< int > &result)
	matrix_cl overload of the dims helper function in prim/fun/dims.hpp.
template<bool propto, typename T_prob_cl , typename T_prior_size_cl , require_all_prim_or_rev_kernel_expression_t< T_prob_cl, T_prior_size_cl > * = nullptr, require_any_not_stan_scalar_t< T_prob_cl, T_prior_size_cl > * = nullptr>
return_type_t< T_prob_cl, T_prior_size_cl >	dirichlet_lpdf (const T_prob_cl &theta, const T_prior_size_cl &alpha)
	The log of the Dirichlet density for the given theta and a vector of prior sample sizes, alpha.
template<typename T_a , typename T_b , require_all_nonscalar_prim_or_rev_kernel_expression_t< T_a, T_b > * = nullptr>
auto	distance (const T_a &a, const T_b &b)
	Returns the distance between the specified vectors.
template<typename T_a , typename = require_all_kernel_expressions_and_none_scalar_t<T_a>>
auto	divide (T_a &&a, double d)
	Returns the elementwise division of the kernel generator expression.
template<typename T1 , typename T2 , typename = require_all_arithmetic_t<T1, T2>>
void	divide_columns (matrix_cl< T1 > &A, const matrix_cl< T2 > &B)
	Divides each column of a matrix by a vector.
template<typename T1 , typename T2 , typename = require_all_arithmetic_t<T1, T2>>
void	divide_columns (matrix_cl< T1 > &A, const T2 &divisor)
	Divides each column of a matrix by a scalar.
template<typename T_a , typename T_b , require_all_kernel_expressions_and_none_scalar_t< T_a, T_b > * = nullptr>
auto	dot_product (const T_a &a, const T_b &b)
	Returns the dot product of the specified vectors.
template<typename T , require_all_kernel_expressions_and_none_scalar_t< T > * = nullptr>
auto	dot_self (const T &a)
	Returns squared norm of a vector or matrix.
template<typename T_y_cl , typename T_loc_cl , typename T_scale_cl , require_all_prim_or_rev_kernel_expression_t< T_y_cl, T_loc_cl, T_scale_cl > * = nullptr, require_any_not_stan_scalar_t< T_y_cl, T_loc_cl, T_scale_cl > * = nullptr>
return_type_t< T_y_cl, T_loc_cl, T_scale_cl >	double_exponential_cdf (const T_y_cl &y, const T_loc_cl &mu, const T_scale_cl &sigma)
	Returns the double exponential cumulative density function.
template<typename T_y_cl , typename T_loc_cl , typename T_scale_cl , require_all_prim_or_rev_kernel_expression_t< T_y_cl, T_loc_cl, T_scale_cl > * = nullptr, require_any_not_stan_scalar_t< T_y_cl, T_loc_cl, T_scale_cl > * = nullptr>
return_type_t< T_y_cl, T_loc_cl, T_scale_cl >	double_exponential_lccdf (const T_y_cl &y, const T_loc_cl &mu, const T_scale_cl &sigma)
	Returns the double exponential log complementary cumulative density function.
template<typename T_y_cl , typename T_loc_cl , typename T_scale_cl , require_all_prim_or_rev_kernel_expression_t< T_y_cl, T_loc_cl, T_scale_cl > * = nullptr, require_any_not_stan_scalar_t< T_y_cl, T_loc_cl, T_scale_cl > * = nullptr>
return_type_t< T_y_cl, T_loc_cl, T_scale_cl >	double_exponential_lcdf (const T_y_cl &y, const T_loc_cl &mu, const T_scale_cl &sigma)
	Returns the double exponential log cumulative density function.
template<bool propto, typename T_y_cl , typename T_loc_cl , typename T_scale_cl , require_all_prim_or_rev_kernel_expression_t< T_y_cl, T_loc_cl, T_scale_cl > * = nullptr, require_any_not_stan_scalar_t< T_y_cl, T_loc_cl, T_scale_cl > * = nullptr>
return_type_t< T_y_cl, T_loc_cl, T_scale_cl >	double_exponential_lpdf (const T_y_cl &y, const T_loc_cl &mu, const T_scale_cl &sigma)
	Returns the double exponential log probability density function.
matrix_cl< double >	eigenvalues_sym (const matrix_cl< double > &m)
matrix_cl< double >	eigenvectors_sym (const matrix_cl< double > &m)
template<typename T_y_cl , typename T_loc_cl , typename T_scale_cl , typename T_inv_scale_cl , require_all_prim_or_rev_kernel_expression_t< T_y_cl, T_loc_cl, T_scale_cl, T_inv_scale_cl > * = nullptr, require_any_not_stan_scalar_t< T_y_cl, T_loc_cl, T_scale_cl, T_inv_scale_cl > * = nullptr>
return_type_t< T_y_cl, T_loc_cl, T_scale_cl, T_inv_scale_cl >	exp_mod_normal_cdf (const T_y_cl &y, const T_loc_cl &mu, const T_scale_cl &sigma, const T_inv_scale_cl &lambda)
	Returns the double exponential cumulative density function.
template<typename T_y_cl , typename T_loc_cl , typename T_scale_cl , typename T_inv_scale_cl , require_all_prim_or_rev_kernel_expression_t< T_y_cl, T_loc_cl, T_scale_cl, T_inv_scale_cl > * = nullptr, require_any_not_stan_scalar_t< T_y_cl, T_loc_cl, T_scale_cl, T_inv_scale_cl > * = nullptr>
return_type_t< T_y_cl, T_loc_cl, T_scale_cl, T_inv_scale_cl >	exp_mod_normal_lccdf (const T_y_cl &y, const T_loc_cl &mu, const T_scale_cl &sigma, const T_inv_scale_cl &lambda)
	Returns the exp mod normal log complementary cumulative density function.
template<typename T_y_cl , typename T_loc_cl , typename T_scale_cl , typename T_inv_scale_cl , require_all_prim_or_rev_kernel_expression_t< T_y_cl, T_loc_cl, T_scale_cl, T_inv_scale_cl > * = nullptr, require_any_not_stan_scalar_t< T_y_cl, T_loc_cl, T_scale_cl, T_inv_scale_cl > * = nullptr>
return_type_t< T_y_cl, T_loc_cl, T_scale_cl, T_inv_scale_cl >	exp_mod_normal_lcdf (const T_y_cl &y, const T_loc_cl &mu, const T_scale_cl &sigma, const T_inv_scale_cl &lambda)
	Returns the exp mod normal log cumulative density function.
template<bool propto, typename T_y_cl , typename T_loc_cl , typename T_scale_cl , typename T_inv_scale_cl , require_all_prim_or_rev_kernel_expression_t< T_y_cl, T_loc_cl, T_scale_cl, T_inv_scale_cl > * = nullptr, require_any_not_stan_scalar_t< T_y_cl, T_loc_cl, T_scale_cl, T_inv_scale_cl > * = nullptr>
return_type_t< T_y_cl, T_loc_cl, T_scale_cl, T_inv_scale_cl >	exp_mod_normal_lpdf (const T_y_cl &y, const T_loc_cl &mu, const T_scale_cl &sigma, const T_inv_scale_cl &lambda)
	Returns the log PMF of the exp mod normal distribution.
template<typename T_y_cl , typename T_inv_scale_cl , require_all_prim_or_rev_kernel_expression_t< T_y_cl, T_inv_scale_cl > * = nullptr, require_any_not_stan_scalar_t< T_y_cl, T_inv_scale_cl > * = nullptr>
return_type_t< T_y_cl, T_inv_scale_cl >	exponential_cdf (const T_y_cl &y, const T_inv_scale_cl &beta)
	Calculates the exponential cumulative distribution function for the given y and beta.
template<typename T_y_cl , typename T_inv_scale_cl , require_all_prim_or_rev_kernel_expression_t< T_y_cl, T_inv_scale_cl > * = nullptr, require_any_not_stan_scalar_t< T_y_cl, T_inv_scale_cl > * = nullptr>
return_type_t< T_y_cl, T_inv_scale_cl >	exponential_lccdf (const T_y_cl &y, const T_inv_scale_cl &beta)
	Calculates the log exponential cumulative distribution function for the given y and beta.
template<typename T_y_cl , typename T_inv_scale_cl , require_all_prim_or_rev_kernel_expression_t< T_y_cl, T_inv_scale_cl > * = nullptr, require_any_not_stan_scalar_t< T_y_cl, T_inv_scale_cl > * = nullptr>
return_type_t< T_y_cl, T_inv_scale_cl >	exponential_lcdf (const T_y_cl &y, const T_inv_scale_cl &beta)
	Calculates the log exponential cumulative distribution function for the given y and beta.
template<bool propto, typename T_y_cl , typename T_inv_scale_cl , require_all_prim_or_rev_kernel_expression_t< T_y_cl, T_inv_scale_cl > * = nullptr, require_any_not_stan_scalar_t< T_y_cl, T_inv_scale_cl > * = nullptr>
return_type_t< T_y_cl, T_inv_scale_cl >	exponential_lpdf (const T_y_cl &y, const T_inv_scale_cl &beta)
	The log of an exponential density for y with the specified inverse scale parameter.
template<typename T_y_cl , typename T_shape_cl , typename T_scale_cl , require_all_prim_or_rev_kernel_expression_t< T_y_cl, T_shape_cl, T_scale_cl > * = nullptr, require_any_not_stan_scalar_t< T_y_cl, T_shape_cl, T_scale_cl > * = nullptr>
return_type_t< T_y_cl, T_shape_cl, T_scale_cl >	frechet_cdf (const T_y_cl &y, const T_shape_cl &alpha, const T_scale_cl &sigma)
	Returns the frechet cumulative distribution function for the given location, and scale.
template<typename T_y_cl , typename T_shape_cl , typename T_scale_cl , require_all_prim_or_rev_kernel_expression_t< T_y_cl, T_shape_cl, T_scale_cl > * = nullptr, require_any_not_stan_scalar_t< T_y_cl, T_shape_cl, T_scale_cl > * = nullptr>
return_type_t< T_y_cl, T_shape_cl, T_scale_cl >	frechet_lccdf (const T_y_cl &y, const T_shape_cl &alpha, const T_scale_cl &sigma)
	Returns the frechet log complementary cumulative distribution function for the given location, and scale.
template<typename T_y_cl , typename T_shape_cl , typename T_scale_cl , require_all_prim_or_rev_kernel_expression_t< T_y_cl, T_shape_cl, T_scale_cl > * = nullptr, require_any_not_stan_scalar_t< T_y_cl, T_shape_cl, T_scale_cl > * = nullptr>
return_type_t< T_y_cl, T_shape_cl, T_scale_cl >	frechet_lcdf (const T_y_cl &y, const T_shape_cl &alpha, const T_scale_cl &sigma)
	Returns the frechet log cumulative distribution function for the given location, and scale.
template<bool propto, typename T_y_cl , typename T_shape_cl , typename T_scale_cl , require_all_prim_or_rev_kernel_expression_t< T_y_cl, T_shape_cl, T_scale_cl > * = nullptr, require_any_not_stan_scalar_t< T_y_cl, T_shape_cl, T_scale_cl > * = nullptr>
return_type_t< T_y_cl, T_shape_cl, T_scale_cl >	frechet_lpdf (const T_y_cl &y, const T_shape_cl &alpha, const T_scale_cl &sigma)
	The log of the frechet density for the specified scalar(s) given the specified sample stan::math::size(s).
template<bool propto, typename T_y_cl , typename T_shape_cl , typename T_inv_scale_cl , require_all_prim_or_rev_kernel_expression_t< T_y_cl, T_shape_cl, T_inv_scale_cl > * = nullptr, require_any_not_stan_scalar_t< T_y_cl, T_shape_cl, T_inv_scale_cl > * = nullptr>
return_type_t< T_y_cl, T_shape_cl, T_inv_scale_cl >	gamma_lpdf (const T_y_cl &y, const T_shape_cl &alpha, const T_inv_scale_cl &beta)
	The log of a gamma density for y with the specified shape and inverse scale parameters.
template<typename T_x , typename T_sigma , require_all_prim_or_rev_kernel_expression_t< T_x > * = nullptr, require_stan_scalar_t< T_sigma > * = nullptr>
auto	gp_dot_prod_cov (const T_x &x, const T_sigma sigma)
	Dot product kernel on the GPU.
template<typename T_x , typename T_y , typename T_sigma , require_all_prim_or_rev_kernel_expression_t< T_x, T_y > * = nullptr, require_stan_scalar_t< T_sigma > * = nullptr>
auto	gp_dot_prod_cov (const T_x &x, const T_y &y, const T_sigma sigma)
	Dot product kernel on the GPU.
template<typename T1 , typename T2 , typename T3 , typename = require_all_arithmetic_t<T1, T2, T3>>
matrix_cl< return_type_t< T1, T2, T3 > >	gp_exp_quad_cov (const matrix_cl< T1 > &x, const T2 sigma, const T3 length_scale)
	Squared exponential kernel on the GPU.
template<typename T1 , typename T2 , typename T3 , typename T4 , typename = require_all_arithmetic_t<T1, T2, T3, T4>>
matrix_cl< return_type_t< T1, T2, T3, T4 > >	gp_exp_quad_cov (const matrix_cl< T1 > &x, const matrix_cl< T2 > &y, const T3 sigma, const T4 length_scale)
	Squared exponential kernel on the GPU.
template<typename T1 , typename T2 , typename T3 , require_all_kernel_expressions_and_none_scalar_t< T1 > * = nullptr, require_all_arithmetic_t< T2, T3 > * = nullptr>
matrix_cl< return_type_t< T1, T2, T3 > >	gp_exponential_cov (const T1 &x, const T2 sigma, const T3 length_scale)
	Matern exponential kernel on the GPU.
template<typename T1 , typename T2 , typename T3 , typename T4 , require_all_kernel_expressions_and_none_scalar_t< T1, T2 > * = nullptr, require_all_arithmetic_t< T3, T4 > * = nullptr>
matrix_cl< return_type_t< T1, T2, T3, T4 > >	gp_exponential_cov (const T1 &x, const T2 &y, const T3 sigma, const T4 length_scale)
	Matern exponential kernel on the GPU.
template<typename T1 , typename T2 , typename T3 , require_all_kernel_expressions_and_none_scalar_t< T1 > * = nullptr, require_all_arithmetic_t< T2, T3 > * = nullptr>
matrix_cl< return_type_t< T1, T2, T3 > >	gp_matern32_cov (const T1 &x, const T2 sigma, const T3 length_scale)
	Matern 3/2 kernel on the GPU.
template<typename T1 , typename T2 , typename T3 , typename T4 , require_all_kernel_expressions_and_none_scalar_t< T1, T2 > * = nullptr, require_all_arithmetic_t< T3, T4 > * = nullptr>
matrix_cl< return_type_t< T1, T2, T3, T4 > >	gp_matern32_cov (const T1 &x, const T2 &y, const T3 sigma, const T4 length_scale)
	Matern 3/2 kernel on the GPU.
template<typename T1 , typename T2 , typename T3 , require_all_kernel_expressions_and_none_scalar_t< T1 > * = nullptr, require_all_arithmetic_t< T2, T3 > * = nullptr>
matrix_cl< return_type_t< T1, T2, T3 > >	gp_matern52_cov (const T1 &x, const T2 sigma, const T3 length_scale)
	Matern 5/2 kernel on the GPU.
template<typename T1 , typename T2 , typename T3 , typename T4 , require_all_kernel_expressions_and_none_scalar_t< T1, T2 > * = nullptr, require_all_arithmetic_t< T3, T4 > * = nullptr>
matrix_cl< return_type_t< T1, T2, T3, T4 > >	gp_matern52_cov (const T1 &x, const T2 &y, const T3 sigma, const T4 length_scale)
	Matern 5/2 kernel on the GPU.
template<typename T_y_cl , typename T_loc_cl , typename T_scale_cl , require_all_prim_or_rev_kernel_expression_t< T_y_cl, T_loc_cl, T_scale_cl > * = nullptr, require_any_not_stan_scalar_t< T_y_cl, T_loc_cl, T_scale_cl > * = nullptr>
return_type_t< T_y_cl, T_loc_cl, T_scale_cl >	gumbel_cdf (const T_y_cl &y, const T_loc_cl &mu, const T_scale_cl &beta)
	Returns the gumbel cumulative distribution function for the given location, and scale.
template<typename T_y_cl , typename T_loc_cl , typename T_scale_cl , require_all_prim_or_rev_kernel_expression_t< T_y_cl, T_loc_cl, T_scale_cl > * = nullptr, require_any_not_stan_scalar_t< T_y_cl, T_loc_cl, T_scale_cl > * = nullptr>
return_type_t< T_y_cl, T_loc_cl, T_scale_cl >	gumbel_lccdf (const T_y_cl &y, const T_loc_cl &mu, const T_scale_cl &beta)
	Returns the Gumbel log complementary cumulative distribution function for the given location, and scale.
template<typename T_y_cl , typename T_loc_cl , typename T_scale_cl , require_all_prim_or_rev_kernel_expression_t< T_y_cl, T_loc_cl, T_scale_cl > * = nullptr, require_any_not_stan_scalar_t< T_y_cl, T_loc_cl, T_scale_cl > * = nullptr>
return_type_t< T_y_cl, T_loc_cl, T_scale_cl >	gumbel_lcdf (const T_y_cl &y, const T_loc_cl &mu, const T_scale_cl &beta)
	Returns the Gumbel log complementary cumulative distribution function for the given location, and scale.
template<bool propto, typename T_y_cl , typename T_loc_cl , typename T_scale_cl , require_all_prim_or_rev_kernel_expression_t< T_y_cl, T_loc_cl, T_scale_cl > * = nullptr, require_any_not_stan_scalar_t< T_y_cl, T_loc_cl, T_scale_cl > * = nullptr>
return_type_t< T_y_cl, T_loc_cl, T_scale_cl >	gumbel_lpdf (const T_y_cl &y, const T_loc_cl &mu, const T_scale_cl &beta)
	Returns the Gumbel log probability density for the given location and scale.
template<typename T_x , typename = require_nonscalar_prim_or_rev_kernel_expression_t<T_x>>
auto	head (T_x &&x, size_t n)
	Return the specified number of elements as a vector or row vector (same as input) from the front of the specified vector or row vector.
template<typename T_x , require_matrix_cl_t< T_x > * = nullptr>
auto	identity_matrix (int K)
	Return a square identity matrix.
template<typename T_x , typename = require_all_kernel_expressions_and_none_scalar_t<T_x>>
auto	inv (T_x &&x)
	Return the elementwise 1.0 / x of the specified argument, which may be a scalar or any Stan container of numeric scalars.
template<bool propto, typename T_y_cl , typename T_dof_cl , require_all_prim_or_rev_kernel_expression_t< T_y_cl, T_dof_cl > * = nullptr, require_any_not_stan_scalar_t< T_y_cl, T_dof_cl > * = nullptr>
return_type_t< T_y_cl, T_dof_cl >	inv_chi_square_lpdf (const T_y_cl &y, const T_dof_cl &nu)
	The log of an inverse chi-squared density for y with the specified degrees of freedom parameter.
template<typename T_x , typename = require_all_kernel_expressions_and_none_scalar_t<T_x>>
auto	inv_cloglog (T_x &&x)
	The inverse complementary log-log function.
template<bool propto, typename T_y_cl , typename T_shape_cl , typename T_scale_cl , require_all_prim_or_rev_kernel_expression_t< T_y_cl, T_shape_cl, T_scale_cl > * = nullptr, require_any_not_stan_scalar_t< T_y_cl, T_shape_cl, T_scale_cl > * = nullptr>
return_type_t< T_y_cl, T_shape_cl, T_scale_cl >	inv_gamma_lpdf (const T_y_cl &y, const T_shape_cl &alpha, const T_scale_cl &beta)
	The log of an inverse gamma density for y with the specified shape and scale parameters.
template<typename T_x , typename = require_all_kernel_expressions_and_none_scalar_t<T_x>>
auto	inv_sqrt (T_x &&x)
	Return the elementwise 1 / sqrt(x) of the specified kernel generator expression.
template<typename T_theta_cl , typename T_lambda_cl , require_all_prim_or_rev_kernel_expression_t< T_theta_cl, T_lambda_cl > * = nullptr>
auto	log_mix (const T_theta_cl &theta, const T_lambda_cl &lambda)
	Return the log mixture density with specified mixing proportions and log densities.
template<typename T , require_all_kernel_expressions_and_none_scalar_t< T > * = nullptr>
matrix_cl< double >	log_softmax (const T &a)
	Return log of the softmax of the specified vector.
template<typename T , require_all_kernel_expressions_and_none_scalar_t< T > * = nullptr>
double	log_sum_exp (const T &a)
	Return the log of the sum of the exponentiated values of the specified matrix of values.
template<typename T_y_cl , typename T_loc_cl , typename T_scale_cl , require_all_prim_or_rev_kernel_expression_t< T_y_cl, T_loc_cl, T_scale_cl > * = nullptr, require_any_not_stan_scalar_t< T_y_cl, T_loc_cl, T_scale_cl > * = nullptr>
return_type_t< T_y_cl, T_loc_cl, T_scale_cl >	logistic_cdf (const T_y_cl &y, const T_loc_cl &mu, const T_scale_cl &sigma)
	Returns the logistic cumulative distribution function for the given location, and scale.
template<typename T_y_cl , typename T_loc_cl , typename T_scale_cl , require_all_prim_or_rev_kernel_expression_t< T_y_cl, T_loc_cl, T_scale_cl > * = nullptr, require_any_not_stan_scalar_t< T_y_cl, T_loc_cl, T_scale_cl > * = nullptr>
return_type_t< T_y_cl, T_loc_cl, T_scale_cl >	logistic_lccdf (const T_y_cl &y, const T_loc_cl &mu, const T_scale_cl &sigma)
	Returns the logistic cumulative distribution function for the given location, and scale.
template<typename T_y_cl , typename T_loc_cl , typename T_scale_cl , require_all_prim_or_rev_kernel_expression_t< T_y_cl, T_loc_cl, T_scale_cl > * = nullptr, require_any_not_stan_scalar_t< T_y_cl, T_loc_cl, T_scale_cl > * = nullptr>
return_type_t< T_y_cl, T_loc_cl, T_scale_cl >	logistic_lcdf (const T_y_cl &y, const T_loc_cl &mu, const T_scale_cl &sigma)
	Returns the logistic cumulative distribution function for the given location, and scale.
template<bool propto, typename T_y_cl , typename T_loc_cl , typename T_scale_cl , require_all_prim_or_rev_kernel_expression_t< T_y_cl, T_loc_cl, T_scale_cl > * = nullptr, require_any_not_stan_scalar_t< T_y_cl, T_loc_cl, T_scale_cl > * = nullptr>
return_type_t< T_y_cl, T_loc_cl, T_scale_cl >	logistic_lpdf (const T_y_cl &y, const T_loc_cl &mu, const T_scale_cl &sigma)
	The log of a logistic density for y with the specified location and scale parameters.
template<typename T_y_cl , typename T_loc_cl , typename T_scale_cl , require_all_prim_or_rev_kernel_expression_t< T_y_cl, T_loc_cl, T_scale_cl > * = nullptr, require_any_not_stan_scalar_t< T_y_cl, T_loc_cl, T_scale_cl > * = nullptr>
return_type_t< T_y_cl, T_loc_cl, T_scale_cl >	lognormal_cdf (const T_y_cl &y, const T_loc_cl &mu, const T_scale_cl &sigma)
	Returns the loghormal cumulative distribution function for the given location, and scale.
template<typename T_y_cl , typename T_loc_cl , typename T_scale_cl , require_all_prim_or_rev_kernel_expression_t< T_y_cl, T_loc_cl, T_scale_cl > * = nullptr, require_any_not_stan_scalar_t< T_y_cl, T_loc_cl, T_scale_cl > * = nullptr>
return_type_t< T_y_cl, T_loc_cl, T_scale_cl >	lognormal_lccdf (const T_y_cl &y, const T_loc_cl &mu, const T_scale_cl &sigma)
	Returns the lognormal log complementary cumulative distribution function for the given location, and scale.
template<typename T_y_cl , typename T_loc_cl , typename T_scale_cl , require_all_prim_or_rev_kernel_expression_t< T_y_cl, T_loc_cl, T_scale_cl > * = nullptr, require_any_not_stan_scalar_t< T_y_cl, T_loc_cl, T_scale_cl > * = nullptr>
return_type_t< T_y_cl, T_loc_cl, T_scale_cl >	lognormal_lcdf (const T_y_cl &y, const T_loc_cl &mu, const T_scale_cl &sigma)
	Returns the lognormal log cumulative distribution function for the given location, and scale.
template<bool propto, typename T_y_cl , typename T_loc_cl , typename T_scale_cl , require_all_prim_or_rev_kernel_expression_t< T_y_cl, T_loc_cl, T_scale_cl > * = nullptr, require_any_not_stan_scalar_t< T_y_cl, T_loc_cl, T_scale_cl > * = nullptr>
return_type_t< T_y_cl, T_loc_cl, T_scale_cl >	lognormal_lpdf (const T_y_cl &y, const T_loc_cl &mu, const T_scale_cl &sigma)
	The log of the lognormal density for the specified scalar(s) given the specified sample stan::math::size(s).
template<typename T_m , require_all_kernel_expressions_and_none_scalar_t< T_m > * = nullptr>
plain_type_t< T_m >	matrix_power (T_m &&M, const int n)
	Returns the nth power of the specific matrix.
template<typename T1 , typename T2 , require_all_kernel_expressions_t< T1, T2 > * = nullptr>
matrix_cl< double >	mdivide_left_tri_low (const T1 &A, const T2 &b)
	Returns the solution of the system Ax=b when A is lower triangular.
template<typename T , require_all_kernel_expressions_t< T > * = nullptr>
matrix_cl< double >	mdivide_left_tri_low (const T &A)
	Returns the solution of the system Ax=b when A is triangular and b=I.
template<typename T1 , typename T2 , require_all_kernel_expressions_t< T1, T2 > * = nullptr>
matrix_cl< double >	mdivide_right_tri_low (const T2 &b, const T1 &A)
	Returns the solution of the system Ax=b where A is a lower triangular matrix.
template<typename T , require_nonscalar_prim_or_rev_kernel_expression_t< T > * = nullptr>
scalar_type_t< T >	mean (const T &m)
	Returns the sample mean (i.e., average) of the coefficients in the specified std vector, vector, row vector, or matrix.
template<bool propto, typename T_y_cl , typename T_loc_cl , typename T_covar_cl , require_all_prim_or_rev_kernel_expression_t< T_y_cl, T_loc_cl, T_covar_cl > * = nullptr>
return_type_t< T_y_cl, T_loc_cl, T_covar_cl >	multi_normal_cholesky_lpdf (const T_y_cl &y, const T_loc_cl &mu, const T_covar_cl &L)
	The log of the multivariate normal density for the given y, mu, and a Cholesky factor L of the variance matrix.
template<typename T1 , typename T2 , typename = require_all_kernel_expressions_and_none_scalar_t<T1, T2>>
matrix_cl< return_type_t< T1, T2 > >	multiply (const T1 &A, const T2 &B)
	Computes the product of the specified matrices with the option of specifying the triangularity of either input matrices.
template<typename T_a , typename T_b , typename = require_all_kernel_expressions_and_none_scalar_t<T_a, T_b>>
matrix_cl< return_type_t< T_a, T_b > >	operator* (const T_a &a, const T_b &b)
	Matrix multiplication of two kernel generator expressions.
template<typename T_a , typename T_b , require_stan_scalar_t< T_a > * = nullptr, require_all_kernel_expressions_and_none_scalar_t< T_b > * = nullptr, require_all_not_var_t< T_a, T_b > * = nullptr>
matrix_cl< return_type_t< T_a, T_b > >	multiply (const T_a &a, const T_b &b)
	Matrix multiplication of a scalar and a kernel generator expressions.
template<typename T_x , require_all_kernel_expressions_and_none_scalar_t< T_x > * = nullptr>
auto	multiply_lower_tri_self_transpose (T_x &&x)
	Returns the result of multiplying the lower triangular portion of the input matrix by its own transpose.
template<bool propto, typename T_y_cl , typename T_x_cl , typename T_alpha_cl , typename T_beta_cl , typename T_phi_cl , require_all_prim_or_rev_kernel_expression_t< T_x_cl, T_y_cl, T_alpha_cl, T_beta_cl, T_phi_cl > * = nullptr>
return_type_t< T_x_cl, T_alpha_cl, T_beta_cl, T_phi_cl >	neg_binomial_2_log_glm_lpmf (const T_y_cl &y, const T_x_cl &x, const T_alpha_cl &alpha, const T_beta_cl &beta, const T_phi_cl &phi)
	Returns the log PMF of the Generalized Linear Model (GLM) with Negative-Binomial-2 distribution and log link function.
template<bool propto, typename T_n_cl , typename T_log_location_cl , typename T_precision_cl , require_all_prim_or_rev_kernel_expression_t< T_n_cl, T_log_location_cl, T_precision_cl > * = nullptr, require_any_not_stan_scalar_t< T_n_cl, T_log_location_cl, T_precision_cl > * = nullptr>
return_type_t< T_n_cl, T_log_location_cl, T_precision_cl >	neg_binomial_2_log_lpmf (const T_n_cl &n, const T_log_location_cl &eta, const T_precision_cl &phi)
	The log of the log transformed negative binomial density for the specified scalars given the specified mean(s) and deviation(s).
template<bool propto, typename T_n_cl , typename T_location_cl , typename T_precision_cl , require_all_prim_or_rev_kernel_expression_t< T_n_cl, T_location_cl, T_precision_cl > * = nullptr, require_any_not_stan_scalar_t< T_n_cl, T_location_cl, T_precision_cl > * = nullptr>
return_type_t< T_n_cl, T_location_cl, T_precision_cl >	neg_binomial_2_lpmf (const T_n_cl &n, const T_location_cl &mu, const T_precision_cl &phi)
	The log of the negative binomial density for the specified scalars given the specified mean(s) and deviation(s).
template<bool propto, typename T_n_cl , typename T_shape_cl , typename T_inv_scale_cl , require_all_prim_or_rev_kernel_expression_t< T_n_cl, T_shape_cl, T_inv_scale_cl > * = nullptr, require_any_not_stan_scalar_t< T_n_cl, T_shape_cl, T_inv_scale_cl > * = nullptr>
return_type_t< T_n_cl, T_shape_cl, T_inv_scale_cl >	neg_binomial_lpmf (const T_n_cl &n, const T_shape_cl &alpha, const T_inv_scale_cl &beta)
	The log of the negative binomial density for the specified scalars given the specified mean(s) and deviation(s).
template<typename T_y_cl , typename T_loc_cl , typename T_scale_cl , require_all_prim_or_rev_kernel_expression_t< T_y_cl, T_loc_cl, T_scale_cl > * = nullptr, require_any_not_stan_scalar_t< T_y_cl, T_loc_cl, T_scale_cl > * = nullptr>
return_type_t< T_y_cl, T_loc_cl, T_scale_cl >	normal_cdf (const T_y_cl &y, const T_loc_cl &mu, const T_scale_cl &sigma)
	Returns the normal cumulative distribution function for the given location, and scale.
template<bool propto, typename T_y_cl , typename T_x_cl , typename T_alpha_cl , typename T_beta_cl , typename T_sigma_cl , require_all_prim_or_rev_kernel_expression_t< T_x_cl, T_y_cl, T_alpha_cl, T_beta_cl, T_sigma_cl > * = nullptr>
return_type_t< T_y_cl, T_x_cl, T_alpha_cl, T_beta_cl, T_sigma_cl >	normal_id_glm_lpdf (const T_y_cl &y, const T_x_cl &x, const T_alpha_cl &alpha, const T_beta_cl &beta, const T_sigma_cl &sigma)
	Returns the log PDF of the Generalized Linear Model (GLM) with Normal distribution and id link function.
template<typename T_y_cl , typename T_loc_cl , typename T_scale_cl , require_all_prim_or_rev_kernel_expression_t< T_y_cl, T_loc_cl, T_scale_cl > * = nullptr, require_any_not_stan_scalar_t< T_y_cl, T_loc_cl, T_scale_cl > * = nullptr>
return_type_t< T_y_cl, T_loc_cl, T_scale_cl >	normal_lccdf (const T_y_cl &y, const T_loc_cl &mu, const T_scale_cl &sigma)
	Returns the normal log complementary cumulative distribution function for the given location, and scale.
template<typename T_y_cl , typename T_loc_cl , typename T_scale_cl , require_all_prim_or_rev_kernel_expression_t< T_y_cl, T_loc_cl, T_scale_cl > * = nullptr, require_any_not_stan_scalar_t< T_y_cl, T_loc_cl, T_scale_cl > * = nullptr>
return_type_t< T_y_cl, T_loc_cl, T_scale_cl >	normal_lcdf (const T_y_cl &y, const T_loc_cl &mu, const T_scale_cl &sigma)
	Returns the normal log complementary cumulative distribution function for the given location, and scale.
template<bool propto, typename T_y_cl , typename T_loc_cl , typename T_scale_cl , require_all_prim_or_rev_kernel_expression_t< T_y_cl, T_loc_cl, T_scale_cl > * = nullptr, require_any_not_stan_scalar_t< T_y_cl, T_loc_cl, T_scale_cl > * = nullptr>
return_type_t< T_y_cl, T_loc_cl, T_scale_cl >	normal_lpdf (const T_y_cl &y, const T_loc_cl &mu, const T_scale_cl &sigma)
	The log of the normal density for the specified scalar(s) given the specified mean(s) and deviation(s).
template<typename T , require_nonscalar_prim_or_rev_kernel_expression_t< T > * = nullptr>
int64_t	num_elements (const T &m)
	Returns the number of the elements of a matrix_cl or var_value<matrix_cl<T>>.
template<bool propto, typename T_y , typename T_x , typename T_beta , typename T_cuts , require_all_prim_or_rev_kernel_expression_t< T_y, T_x, T_beta, T_cuts > * = nullptr>
return_type_t< T_x, T_beta, T_cuts >	ordered_logistic_glm_lpmf (const T_y &y, const T_x &x, const T_beta &beta, const T_cuts &cuts)
	Returns the log PMF of the ordinal regression Generalized Linear Model (GLM).
template<bool propto, typename T_y_cl , typename T_loc_cl , typename T_cuts_cl , require_all_prim_or_rev_kernel_expression_t< T_y_cl, T_loc_cl, T_cuts_cl > * = nullptr>
return_type_t< T_y_cl, T_loc_cl, T_cuts_cl >	ordered_logistic_lpmf (const T_y_cl &y, const T_loc_cl &lambda, const T_cuts_cl &cuts)
	Returns the (natural) log probability of the specified array of integers given the vector of continuous locations and specified cutpoints in an ordered logistic model.
template<typename T_y_cl , typename T_scale_cl , typename T_shape_cl , require_all_prim_or_rev_kernel_expression_t< T_y_cl, T_scale_cl, T_shape_cl > * = nullptr, require_any_not_stan_scalar_t< T_y_cl, T_scale_cl, T_shape_cl > * = nullptr>
return_type_t< T_y_cl, T_scale_cl, T_shape_cl >	pareto_cdf (const T_y_cl &y, const T_scale_cl &y_min, const T_shape_cl &alpha)
	Returns the Pareto cumulative density function.
template<typename T_y_cl , typename T_scale_cl , typename T_shape_cl , require_all_prim_or_rev_kernel_expression_t< T_y_cl, T_scale_cl, T_shape_cl > * = nullptr, require_any_not_stan_scalar_t< T_y_cl, T_scale_cl, T_shape_cl > * = nullptr>
return_type_t< T_y_cl, T_scale_cl, T_shape_cl >	pareto_lccdf (const T_y_cl &y, const T_scale_cl &y_min, const T_shape_cl &alpha)
	Returns the Pareto cumulative density function.
template<typename T_y_cl , typename T_scale_cl , typename T_shape_cl , require_all_prim_or_rev_kernel_expression_t< T_y_cl, T_scale_cl, T_shape_cl > * = nullptr, require_any_not_stan_scalar_t< T_y_cl, T_scale_cl, T_shape_cl > * = nullptr>
return_type_t< T_y_cl, T_scale_cl, T_shape_cl >	pareto_lcdf (const T_y_cl &y, const T_scale_cl &y_min, const T_shape_cl &alpha)
	Returns the Pareto cumulative density function.
template<bool propto, typename T_y_cl , typename T_scale_cl , typename T_shape_cl , require_all_prim_or_rev_kernel_expression_t< T_y_cl, T_scale_cl, T_shape_cl > * = nullptr, require_any_not_stan_scalar_t< T_y_cl, T_scale_cl, T_shape_cl > * = nullptr>
return_type_t< T_y_cl, T_scale_cl, T_shape_cl >	pareto_lpdf (const T_y_cl &y, const T_scale_cl &y_min, const T_shape_cl &alpha)
	The log of the Cauchy density for the specified scalar(s) given the specified location parameter(s) and scale parameter(s).
template<typename T_y_cl , typename T_loc_cl , typename T_scale_cl , typename T_shape_cl , require_all_prim_or_rev_kernel_expression_t< T_y_cl, T_loc_cl, T_scale_cl, T_shape_cl > * = nullptr, require_any_not_stan_scalar_t< T_y_cl, T_loc_cl, T_scale_cl, T_shape_cl > * = nullptr>
return_type_t< T_y_cl, T_loc_cl, T_scale_cl, T_shape_cl >	pareto_type_2_cdf (const T_y_cl &y, const T_loc_cl &mu, const T_scale_cl &lambda, const T_shape_cl &alpha)
	Returns the pareto type 2 cumulative density function.
template<typename T_y_cl , typename T_loc_cl , typename T_scale_cl , typename T_shape_cl , require_all_prim_or_rev_kernel_expression_t< T_y_cl, T_loc_cl, T_scale_cl, T_shape_cl > * = nullptr, require_any_not_stan_scalar_t< T_y_cl, T_loc_cl, T_scale_cl, T_shape_cl > * = nullptr>
return_type_t< T_y_cl, T_loc_cl, T_scale_cl, T_shape_cl >	pareto_type_2_lccdf (const T_y_cl &y, const T_loc_cl &mu, const T_scale_cl &lambda, const T_shape_cl &alpha)
	Returns the pareto type 2 log complementaty cumulative density function.
template<typename T_y_cl , typename T_loc_cl , typename T_scale_cl , typename T_shape_cl , require_all_prim_or_rev_kernel_expression_t< T_y_cl, T_loc_cl, T_scale_cl, T_shape_cl > * = nullptr, require_any_not_stan_scalar_t< T_y_cl, T_loc_cl, T_scale_cl, T_shape_cl > * = nullptr>
return_type_t< T_y_cl, T_loc_cl, T_scale_cl, T_shape_cl >	pareto_type_2_lcdf (const T_y_cl &y, const T_loc_cl &mu, const T_scale_cl &lambda, const T_shape_cl &alpha)
	Returns the pareto type 2 log cumulative density function.
template<bool propto, typename T_y_cl , typename T_loc_cl , typename T_scale_cl , typename T_shape_cl , require_all_prim_or_rev_kernel_expression_t< T_y_cl, T_loc_cl, T_scale_cl, T_shape_cl > * = nullptr, require_any_not_stan_scalar_t< T_y_cl, T_loc_cl, T_scale_cl, T_shape_cl > * = nullptr>
return_type_t< T_y_cl, T_loc_cl, T_scale_cl, T_shape_cl >	pareto_type_2_lpdf (const T_y_cl &y, const T_loc_cl &mu, const T_scale_cl &lambda, const T_shape_cl &alpha)
	Returns the log PMF of the Pareto type 2 distribution.
template<bool propto, typename T_y_cl , typename T_x_cl , typename T_alpha_cl , typename T_beta_cl , require_all_prim_or_rev_kernel_expression_t< T_y_cl, T_x_cl, T_alpha_cl, T_beta_cl > * = nullptr>
return_type_t< T_x_cl, T_alpha_cl, T_beta_cl >	poisson_log_glm_lpmf (const T_y_cl &y, const T_x_cl &x, const T_alpha_cl &alpha, const T_beta_cl &beta)
	Returns the log PMF of the Generalized Linear Model (GLM) with Poisson distribution and log link function.
template<bool propto, typename T_n_cl , typename T_log_rate_cl , require_all_prim_or_rev_kernel_expression_t< T_n_cl, T_log_rate_cl > * = nullptr, require_any_not_stan_scalar_t< T_n_cl, T_log_rate_cl > * = nullptr>
return_type_t< T_log_rate_cl >	poisson_log_lpmf (const T_n_cl &n, const T_log_rate_cl &alpha)
	Returns the log PMF of the Poisson log distribution.
template<bool propto, typename T_n_cl , typename T_rate_cl , require_all_prim_or_rev_kernel_expression_t< T_n_cl, T_rate_cl > * = nullptr, require_any_not_stan_scalar_t< T_n_cl, T_rate_cl > * = nullptr>
return_type_t< T_rate_cl >	poisson_lpmf (const T_n_cl &n, const T_rate_cl &lambda)
	Returns the log PMF of the Poisson distribution.
template<typename T , require_all_kernel_expressions_and_none_scalar_t< T > * = nullptr>
value_type_t< T >	prod (const T &m)
	Calculates product of given kernel generator expression elements.
template<typename T_m , require_all_kernel_expressions_and_none_scalar_t< T_m > * = nullptr>
matrix_cl< double >	qr_Q (T_m &&m)
	Returns the orthogonal factor of the fat QR decomposition.
template<typename T_m , require_all_kernel_expressions_and_none_scalar_t< T_m > * = nullptr>
matrix_cl< double >	qr_R (T_m &&m)
	Returns the orthogonal factor of the fat QR decomposition.
template<typename T_m , require_all_kernel_expressions_and_none_scalar_t< T_m > * = nullptr>
matrix_cl< double >	qr_thin_Q (T_m &&m)
	Returns the orthogonal factor of the fat QR decomposition.
template<typename T_m , require_all_kernel_expressions_and_none_scalar_t< T_m > * = nullptr>
matrix_cl< double >	qr_thin_R (T_m &&m)
	Returns the orthogonal factor of the thin QR decomposition.
template<typename T , require_all_kernel_expressions_and_none_scalar_t< T > * = nullptr>
int	rank (const T &v, int s)
	Return the number of components of v less than v[s].
template<typename T_y_cl , typename T_scale_cl , require_all_prim_or_rev_kernel_expression_t< T_y_cl, T_scale_cl > * = nullptr, require_any_not_stan_scalar_t< T_y_cl, T_scale_cl > * = nullptr>
return_type_t< T_y_cl, T_scale_cl >	rayleigh_cdf (const T_y_cl &y, const T_scale_cl &sigma)
	Returns the Rayleigh cumulative distribution function for the given location, and scale.
template<typename T_y_cl , typename T_scale_cl , require_all_prim_or_rev_kernel_expression_t< T_y_cl, T_scale_cl > * = nullptr, require_any_not_stan_scalar_t< T_y_cl, T_scale_cl > * = nullptr>
return_type_t< T_y_cl, T_scale_cl >	rayleigh_lccdf (const T_y_cl &y, const T_scale_cl &sigma)
	Returns the Rayleigh log complementary cumulative distribution function for the given location, and scale.
template<typename T_y_cl , typename T_scale_cl , require_all_prim_or_rev_kernel_expression_t< T_y_cl, T_scale_cl > * = nullptr, require_any_not_stan_scalar_t< T_y_cl, T_scale_cl > * = nullptr>
return_type_t< T_y_cl, T_scale_cl >	rayleigh_lcdf (const T_y_cl &y, const T_scale_cl &sigma)
	Returns the Rayleigh log cumulative distribution function for the given location, and scale.
template<bool propto, typename T_y_cl , typename T_scale_cl , require_all_prim_or_rev_kernel_expression_t< T_y_cl, T_scale_cl > * = nullptr, require_any_not_stan_scalar_t< T_y_cl, T_scale_cl > * = nullptr>
return_type_t< T_y_cl, T_scale_cl >	rayleigh_lpdf (const T_y_cl &y, const T_scale_cl &sigma)
	The log of an Rayleigh density for y with the specified scale parameter.
template<typename T , require_any_t< is_matrix_cl< T >, math::conjunction< is_var< T >, is_matrix_cl< value_type_t< T > > > > * = nullptr>
auto	rep_array (const scalar_type_t< T > &x, int n)
	Creates a matrix_cl representing an array by replicating the input value.
template<typename T , require_matrix_cl_t< T > * = nullptr>
auto	rep_matrix (const value_type_t< T > &x, int n, int m)
	Creates a matrix_cl by replicating the given value of arithmetic type.
template<typename T , require_arithmetic_t< T > * = nullptr>
auto	rep_matrix (const matrix_cl< T > &x, int m)
	Creates a matrix_cl by replicating the input vector or row_vector.
template<typename T , require_any_t< is_matrix_cl< T >, math::conjunction< is_var< T >, is_matrix_cl< value_type_t< T > > > > * = nullptr>
auto	rep_row_vector (const scalar_type_t< T > &x, int n)
	Creates a matrix_cl representing a row vector by replicating the input value.
template<typename T , require_any_t< is_matrix_cl< T >, math::conjunction< is_var< T >, is_matrix_cl< value_type_t< T > > > > * = nullptr>
auto	rep_vector (const scalar_type_t< T > &x, int n)
	Creates a matrix_cl representing a vector by replicating the input value.
template<typename T_x , require_all_kernel_expressions_and_none_scalar_t< T_x > * = nullptr>
auto	reverse (T_x &&x)
	Return reversed view into the specified vector or row vector.
template<typename T_x , typename = require_nonscalar_prim_or_rev_kernel_expression_t<T_x>>
auto	row (T_x &&x, size_t j)
	Return the specified row of the specified kernel generator expression using start-at-1 indexing.
template<typename T_x , require_nonscalar_prim_or_rev_kernel_expression_t< T_x > * = nullptr>
int64_t	rows (const T_x &x)
	Returns the number of rows in the specified kernel generator expression.
template<typename T_a , typename T_b , require_all_kernel_expressions_and_none_scalar_t< T_a, T_b > * = nullptr>
auto	rows_dot_product (T_a &&a, T_b &&b)
	Returns the dot product of rows of the specified matrices.
template<typename T_a , require_all_kernel_expressions_and_none_scalar_t< T_a > * = nullptr>
auto	rows_dot_self (T_a &&a)
	Returns the dot product of each row of a matrix with itself.
template<bool propto, typename T_y_cl , typename T_dof_cl , typename T_scale_cl , require_all_prim_or_rev_kernel_expression_t< T_y_cl, T_dof_cl, T_scale_cl > * = nullptr, require_any_not_stan_scalar_t< T_y_cl, T_dof_cl, T_scale_cl > * = nullptr>
return_type_t< T_y_cl, T_dof_cl, T_scale_cl >	scaled_inv_chi_square_lpdf (const T_y_cl &y, const T_dof_cl &nu, const T_scale_cl &s)
	The log of a scaled inverse chi-squared density for y with the specified degrees of freedom parameter and scale parameter.
template<typename T , require_all_kernel_expressions_and_none_scalar_t< T > * = nullptr>
double	sd (const T &a)
	Returns the unbiased sample standard deviation of the coefficients in the specified std vector, column vector, row vector, or matrix.
template<typename T_x , require_nonscalar_prim_or_rev_kernel_expression_t< T_x > * = nullptr>
auto	segment (T_x &&x, size_t i, size_t n)
	Return the specified number of elements as a row/column vector starting from the specified element - 1 of the specified row/column vector.
template<typename T , require_all_kernel_expressions_and_none_scalar_t< T > * = nullptr>
auto	sign (const T &x)
	Returns signs of the arguments.
template<typename T , require_nonscalar_prim_or_rev_kernel_expression_t< T > * = nullptr>
int64_t	size (const T &m)
	Returns the size (number of the elements) of a matrix_cl or var_value<matrix_cl<T>>.
template<typename T_y_cl , typename T_loc_cl , typename T_scale_cl , typename T_skewness_cl , require_all_prim_or_rev_kernel_expression_t< T_y_cl, T_loc_cl, T_scale_cl, T_skewness_cl > * = nullptr, require_any_not_stan_scalar_t< T_y_cl, T_loc_cl, T_scale_cl, T_skewness_cl > * = nullptr>
return_type_t< T_y_cl, T_loc_cl, T_scale_cl, T_skewness_cl >	skew_double_exponential_cdf (const T_y_cl &y, const T_loc_cl &mu, const T_scale_cl &sigma, const T_skewness_cl &tau)
	Returns the skew double exponential cumulative density function.
template<typename T_y_cl , typename T_loc_cl , typename T_scale_cl , typename T_skewness_cl , require_all_prim_or_rev_kernel_expression_t< T_y_cl, T_loc_cl, T_scale_cl, T_skewness_cl > * = nullptr, require_any_not_stan_scalar_t< T_y_cl, T_loc_cl, T_scale_cl, T_skewness_cl > * = nullptr>
return_type_t< T_y_cl, T_loc_cl, T_scale_cl, T_skewness_cl >	skew_double_exponential_lccdf (const T_y_cl &y, const T_loc_cl &mu, const T_scale_cl &sigma, const T_skewness_cl &tau)
	Returns the skew double exponential cumulative density function.
template<typename T_y_cl , typename T_loc_cl , typename T_scale_cl , typename T_skewness_cl , require_all_prim_or_rev_kernel_expression_t< T_y_cl, T_loc_cl, T_scale_cl, T_skewness_cl > * = nullptr, require_any_not_stan_scalar_t< T_y_cl, T_loc_cl, T_scale_cl, T_skewness_cl > * = nullptr>
return_type_t< T_y_cl, T_loc_cl, T_scale_cl, T_skewness_cl >	skew_double_exponential_lcdf (const T_y_cl &y, const T_loc_cl &mu, const T_scale_cl &sigma, const T_skewness_cl &tau)
	Returns the skew double exponential cumulative density function.
template<bool propto, typename T_y_cl , typename T_loc_cl , typename T_scale_cl , typename T_skewness_cl , require_all_prim_or_rev_kernel_expression_t< T_y_cl, T_loc_cl, T_scale_cl, T_skewness_cl > * = nullptr, require_any_not_stan_scalar_t< T_y_cl, T_loc_cl, T_scale_cl, T_skewness_cl > * = nullptr>
return_type_t< T_y_cl, T_loc_cl, T_scale_cl, T_skewness_cl >	skew_double_exponential_lpdf (const T_y_cl &y, const T_loc_cl &mu, const T_scale_cl &sigma, const T_skewness_cl &tau)
	Returns the log PMF of the skew double exponential distribution.
template<bool propto, typename T_y_cl , typename T_loc_cl , typename T_scale_cl , typename T_shape_cl , require_all_prim_or_rev_kernel_expression_t< T_y_cl, T_loc_cl, T_scale_cl, T_shape_cl > * = nullptr, require_any_not_stan_scalar_t< T_y_cl, T_loc_cl, T_scale_cl, T_shape_cl > * = nullptr>
return_type_t< T_y_cl, T_loc_cl, T_scale_cl, T_shape_cl >	skew_normal_lpdf (const T_y_cl &y, const T_loc_cl &mu, const T_scale_cl &sigma, const T_shape_cl &alpha)
	The log of the skew normal density for the specified scalar(s) given the specified mean(s), deviation(s) and shape(s).
template<typename T , require_all_kernel_expressions_and_none_scalar_t< T > * = nullptr>
matrix_cl< double >	softmax (const T &a)
	Return the softmax of the specified vector.
template<typename T , require_all_nonscalar_prim_or_rev_kernel_expression_t< T > * = nullptr>
auto	sort_asc (T &&input)
	Sort the (row)vector in ascending order.
template<typename T , require_all_nonscalar_prim_or_rev_kernel_expression_t< T > * = nullptr>
auto	sort_desc (T &&input)
	Sort the (row)vector in ascending order.
template<typename T_a , typename T_b , require_all_kernel_expressions_and_none_scalar_t< T_a, T_b > * = nullptr>
auto	squared_distance (const T_a &a, const T_b &b)
	Returns the squared distance.
template<typename T_y_cl , require_all_prim_or_rev_kernel_expression_t< T_y_cl > * = nullptr, require_any_not_stan_scalar_t< T_y_cl > * = nullptr>
return_type_t< T_y_cl >	std_normal_cdf (const T_y_cl &y)
	Returns the standard normal cumulative distribution function.
template<typename T_y_cl , require_all_prim_or_rev_kernel_expression_t< T_y_cl > * = nullptr, require_any_not_stan_scalar_t< T_y_cl > * = nullptr>
return_type_t< T_y_cl >	std_normal_lccdf (const T_y_cl &y)
	Returns the log standard normal complementary cumulative distribution function.
template<typename T_y_cl , require_all_prim_or_rev_kernel_expression_t< T_y_cl > * = nullptr, require_any_not_stan_scalar_t< T_y_cl > * = nullptr>
return_type_t< T_y_cl >	std_normal_lcdf (const T_y_cl &y)
	Returns the log standard normal complementary cumulative distribution function.
template<bool propto, typename T_y_cl , require_all_prim_or_rev_kernel_expression_t< T_y_cl > * = nullptr, require_any_not_stan_scalar_t< T_y_cl > * = nullptr>
return_type_t< T_y_cl >	std_normal_lpdf (const T_y_cl &y)
	The log of the normal density for the specified scalar(s) given a location of 0 and a scale of 1.
template<bool propto, typename T_y_cl , typename T_dof_cl , typename T_loc_cl , typename T_scale_cl , require_all_prim_or_rev_kernel_expression_t< T_y_cl, T_dof_cl, T_loc_cl, T_scale_cl > * = nullptr, require_any_not_stan_scalar_t< T_y_cl, T_dof_cl, T_loc_cl, T_scale_cl > * = nullptr>
return_type_t< T_y_cl, T_dof_cl, T_loc_cl, T_scale_cl >	student_t_lpdf (const T_y_cl &y, const T_dof_cl &nu, const T_loc_cl &mu, const T_scale_cl &sigma)
	The log of the Student-t density for the given y, nu, mean, and scale parameter.
template<typename T_x , typename = require_nonscalar_prim_or_rev_kernel_expression_t<T_x>>
auto	sub_col (T_x &&x, size_t i, size_t j, size_t nrows)
	Return a 1 x ncols subrow starting at (i-1, j-1).
template<typename T_x , typename = require_nonscalar_prim_or_rev_kernel_expression_t<T_x>>
auto	sub_row (T_x &&x, size_t i, size_t j, size_t ncols)
	Return a 1 x ncols subrow starting at (i-1, j-1).
template<typename T_x , require_all_kernel_expressions_and_none_scalar_t< T_x > * = nullptr>
auto	symmetrize_from_lower_tri (T_x &&x)
	Return a symmetric matrix using elements from the upper triangular part of the input matrix.
template<typename T_x , require_all_kernel_expressions_and_none_scalar_t< T_x > * = nullptr>
auto	symmetrize_from_upper_tri (T_x &&x)
	Return a symmetric matrix using elements from the lower triangular part of the input matrix.
template<typename T_x , require_nonscalar_prim_or_rev_kernel_expression_t< T_x > * = nullptr>
auto	tail (T_x &&x, size_t n)
	Return the specified number of elements as a vector or row vector (same as input) from the back of the specified vector or row vector.
template<typename T_A , typename = require_all_kernel_expressions_and_none_scalar_t<T_A>>
matrix_cl< typename std::decay_t< T_A >::Scalar >	tcrossprod (T_A &&A)
	Returns the result of post-multiplying a matrix by its own transpose.
template<typename T_x , require_nonscalar_prim_or_rev_kernel_expression_t< T_x > * = nullptr>
auto	to_array_1d (T_x &&x)
	Returns input matrix reshaped into a vector.
template<typename T_x , require_nonscalar_prim_or_rev_kernel_expression_t< T_x > * = nullptr>
T_x	to_array_2d (T_x &&x)
	Returns input matrix converted into a nested std vector.
template<typename T_x , require_nonscalar_prim_or_rev_kernel_expression_t< T_x > * = nullptr>
T_x	to_matrix (T_x &&x)
	Returns input matrix.
template<typename T_x , require_all_kernel_expressions_and_none_scalar_t< T_x > * = nullptr>
matrix_cl< return_type_t< T_x > >	to_matrix (const T_x &x, int m, int n)
	Returns a matrix representation of a vector or matrix in column-major order with the specified number of rows and columns.
template<typename T_x , require_nonscalar_prim_or_rev_kernel_expression_t< T_x > * = nullptr>
auto	to_matrix (const T_x &x, int m, int n, bool col_major) -> decltype(to_matrix(x, m, n))
	Returns a matrix representation of the vector or matrix in column-major or row major order with the specified number of rows and columns.
template<typename T_x , require_nonscalar_prim_or_rev_kernel_expression_t< T_x > * = nullptr>
auto	to_row_vector (T_x &&x)
	Returns input matrix reshaped into a row vector.
template<typename T_x , require_nonscalar_prim_or_rev_kernel_expression_t< T_x > * = nullptr>
auto	to_vector (T_x &&x)
	Returns input matrix reshaped into a vector.
template<typename T , require_all_kernel_expressions_and_none_scalar_t< T > * = nullptr>
value_type_t< T >	trace (const T &m)
	Calculates trace (sum of diagonal) of given kernel generator expression.
template<typename T_y_cl , typename T_low_cl , typename T_high_cl , require_all_prim_or_rev_kernel_expression_t< T_y_cl, T_low_cl, T_high_cl > * = nullptr, require_any_not_stan_scalar_t< T_y_cl, T_low_cl, T_high_cl > * = nullptr>
return_type_t< T_y_cl, T_low_cl, T_high_cl >	uniform_cdf (const T_y_cl &y, const T_low_cl &alpha, const T_high_cl &beta)
	Returns the uniform cumulative distribution function for the given location, and scale.
template<typename T_y_cl , typename T_low_cl , typename T_high_cl , require_all_prim_or_rev_kernel_expression_t< T_y_cl, T_low_cl, T_high_cl > * = nullptr, require_any_not_stan_scalar_t< T_y_cl, T_low_cl, T_high_cl > * = nullptr>
return_type_t< T_y_cl, T_low_cl, T_high_cl >	uniform_lccdf (const T_y_cl &y, const T_low_cl &alpha, const T_high_cl &beta)
	Returns the log uniform complementary cumulative distribution function for the given location, and scale.
template<typename T_y_cl , typename T_low_cl , typename T_high_cl , require_all_prim_or_rev_kernel_expression_t< T_y_cl, T_low_cl, T_high_cl > * = nullptr, require_any_not_stan_scalar_t< T_y_cl, T_low_cl, T_high_cl > * = nullptr>
return_type_t< T_y_cl, T_low_cl, T_high_cl >	uniform_lcdf (const T_y_cl &y, const T_low_cl &alpha, const T_high_cl &beta)
	Returns the log uniform cumulative distribution function for the given location, and scale.
template<bool propto, typename T_y_cl , typename T_low_cl , typename T_high_cl , require_all_prim_or_rev_kernel_expression_t< T_y_cl, T_low_cl, T_high_cl > * = nullptr, require_any_not_stan_scalar_t< T_y_cl, T_low_cl, T_high_cl > * = nullptr>
return_type_t< T_y_cl, T_low_cl, T_high_cl >	uniform_lpdf (const T_y_cl &y, const T_low_cl &alpha, const T_high_cl &beta)
	The log of a uniform density for the given y, lower, and upper bound.
template<typename T , require_all_kernel_expressions_and_none_scalar_t< T > * = nullptr>
double	variance (const T &a)
	Return the sample variance of the var_value matrix Raise domain error if size is not greater than zero.
template<typename T_y_cl , typename T_shape_cl , typename T_scale_cl , require_all_prim_or_rev_kernel_expression_t< T_y_cl, T_shape_cl, T_scale_cl > * = nullptr, require_any_not_stan_scalar_t< T_y_cl, T_shape_cl, T_scale_cl > * = nullptr>
return_type_t< T_y_cl, T_shape_cl, T_scale_cl >	weibull_cdf (const T_y_cl &y, const T_shape_cl &alpha, const T_scale_cl &sigma)
	Returns the weibull cumulative distribution function for the given location, and scale.
template<typename T_y_cl , typename T_shape_cl , typename T_scale_cl , require_all_prim_or_rev_kernel_expression_t< T_y_cl, T_shape_cl, T_scale_cl > * = nullptr, require_any_not_stan_scalar_t< T_y_cl, T_shape_cl, T_scale_cl > * = nullptr>
return_type_t< T_y_cl, T_shape_cl, T_scale_cl >	weibull_lccdf (const T_y_cl &y, const T_shape_cl &alpha, const T_scale_cl &sigma)
	Returns the weibull log cumulative complementary distribution function for the given location, and scale.
template<typename T_y_cl , typename T_shape_cl , typename T_scale_cl , require_all_prim_or_rev_kernel_expression_t< T_y_cl, T_shape_cl, T_scale_cl > * = nullptr, require_any_not_stan_scalar_t< T_y_cl, T_shape_cl, T_scale_cl > * = nullptr>
return_type_t< T_y_cl, T_shape_cl, T_scale_cl >	weibull_lcdf (const T_y_cl &y, const T_shape_cl &alpha, const T_scale_cl &sigma)
	Returns the weibull log cumulative distribution function for the given location, and scale.
template<bool propto, typename T_y_cl , typename T_shape_cl , typename T_scale_cl , require_all_prim_or_rev_kernel_expression_t< T_y_cl, T_shape_cl, T_scale_cl > * = nullptr, require_any_not_stan_scalar_t< T_y_cl, T_shape_cl, T_scale_cl > * = nullptr>
return_type_t< T_y_cl, T_shape_cl, T_scale_cl >	weibull_lpdf (const T_y_cl &y, const T_shape_cl &alpha, const T_scale_cl &sigma)
	Returns the Weibull log probability density for the given location and scale.
template<bool need_Q = true>
void	qr_decomposition_cl (const matrix_cl< double > &A, matrix_cl< double > &Q, matrix_cl< double > &R, int r=100)
	Calculates QR decomposition of A using the block Householder algorithm.
template<typename T , require_all_kernel_expressions_and_none_scalar_t< T > * = nullptr>
var_value< matrix_cl< double > >	acos (const var_value< T > &A)
	Returns the elementwise acos() of a var_value<matrix_cl<double>> in radians.
template<typename T , require_all_kernel_expressions_and_none_scalar_t< T > * = nullptr>
var_value< matrix_cl< double > >	acosh (const var_value< T > &A)
	Returns the elementwise acosh() of a var_value<matrix_cl<double>> in radians.
template<typename T_a , typename T_b , require_all_prim_or_rev_kernel_expression_t< T_a, T_b > * = nullptr, require_any_var_t< T_a, T_b > * = nullptr, require_any_not_stan_scalar_t< T_a, T_b > * = nullptr>
auto	add (T_a &&a, T_b &&b)
	Addition of two reverse mode matrices and/or kernel generator expressions.
template<typename T_a , typename T_b , require_all_nonscalar_prim_or_rev_kernel_expression_t< T_a, T_b > * = nullptr, require_any_var_t< T_a, T_b > * = nullptr>
auto	operator+ (const T_a &a, const T_b &b)
	Addition of two reverse mode matrices and/or kernel generator expressions.
template<typename T_m , typename T_a , require_all_nonscalar_prim_or_rev_kernel_expression_t< T_m > * = nullptr, require_all_prim_or_rev_kernel_expression_t< T_a > * = nullptr, require_any_var_t< T_m, T_a > * = nullptr>
auto	add_diag (const T_m &mat, const T_a &to_add)
	Returns a Matrix with values added along the main diagonal.
template<typename... T_results>
adjoint_results_cl< T_results... >	adjoint_results (T_results &&... results)
	Deduces types for constructing adjoint_results_cl object.
template<typename T_a , typename T_b , require_all_prim_or_rev_kernel_expression_t< T_a, T_b > * = nullptr, require_any_var_t< T_a, T_b > * = nullptr, require_any_not_stan_scalar_t< T_a, T_b > * = nullptr>
var_value< matrix_cl< double > >	append_col (T_a &&a, T_b &&b)
	Return the result of appending the second argument matrix after the first argument matrix, that is, putting them side by side, with the first matrix followed by the second matrix.
template<typename T_a , typename T_b , require_all_prim_or_rev_kernel_expression_t< T_a, T_b > * = nullptr, require_any_var_t< T_a, T_b > * = nullptr, require_any_not_stan_scalar_t< T_a, T_b > * = nullptr>
var_value< matrix_cl< double > >	append_row (T_a &&a, T_b &&b)
	Return the result of stacking the rows of the first argument matrix on top of the second argument matrix.
template<typename T , require_all_nonscalar_prim_or_rev_kernel_expression_t< T > * = nullptr, require_any_var_t< T > * = nullptr>
auto	as_column_vector_or_scalar (const T &m)
	Converts kernel generator expression row or column vector to a column vector.
template<typename T , require_all_kernel_expressions_and_none_scalar_t< T > * = nullptr>
var_value< matrix_cl< double > >	asin (const var_value< T > &A)
	Returns the elementwise asin() of a var_value<matrix_cl<double>> in radians.
template<typename T , require_all_kernel_expressions_and_none_scalar_t< T > * = nullptr>
var_value< matrix_cl< double > >	asinh (const var_value< T > &A)
	Returns the elementwise asinh() of a var_value<matrix_cl<double>> in radians.
template<typename T , require_all_kernel_expressions_and_none_scalar_t< T > * = nullptr>
var_value< matrix_cl< double > >	atan (const var_value< T > &A)
	Returns the elementwise atan() of a var_value<matrix_cl<double>> in radians.
template<typename T , require_all_kernel_expressions_and_none_scalar_t< T > * = nullptr>
var_value< matrix_cl< double > >	atanh (const var_value< T > &A)
	Returns the elementwise atanh() of a var_value<matrix_cl<double>> in radians.
template<typename T_a , typename T_b , require_all_prim_or_rev_kernel_expression_t< T_a, T_b > * = nullptr, require_any_var_t< T_a, T_b > * = nullptr, require_any_not_stan_scalar_t< T_a, T_b > * = nullptr>
auto	beta (T_a &&a, T_b &&b)
	Return the elementwise beta() on two input kernel generator expression.
template<typename T , require_all_nonscalar_prim_or_rev_kernel_expression_t< T > * = nullptr, require_any_var_t< T > * = nullptr>
auto	block (const T &m, size_t i, size_t j, size_t nrows, size_t ncols)
	Return a nrows x ncols submatrix starting at (i-1, j-1).
template<typename T , require_all_kernel_expressions_and_none_scalar_t< T > * = nullptr>
var_value< matrix_cl< double > >	cbrt (const var_value< T > &A)
	Returns the elementwise cbrt() of the input var_value<matrix_cl<double>>.
template<typename T , require_all_kernel_expressions_and_none_scalar_t< T > * = nullptr>
var_value< matrix_cl< double > >	ceil (const var_value< T > &A)
	Returns the elementwise ceil() of the specified variable.
template<typename T , require_all_kernel_expressions_and_none_scalar_t< T > * = nullptr>
var_value< matrix_cl< double > >	cholesky_decompose (const var_value< T > &A)
	Returns the lower-triangular Cholesky factor (i.e., matrix square root) of the specified square, symmetric reverse mode matrix on the OpenCL device.
template<typename T1 , typename T2 , require_any_var_t< T1, T2 > * = nullptr, require_all_nonscalar_prim_or_rev_kernel_expression_t< T1, T2 > * = nullptr>
var_value< matrix_cl< double > >	columns_dot_product (T1 &&v1, T2 &&v2)
	Returns the dot product of columns of the specified matrices.
template<typename T , require_all_kernel_expressions_and_none_scalar_t< T > * = nullptr>
var_value< matrix_cl< double > >	columns_dot_self (const var_value< T > &v)
	Returns the dot product of each column of a matrix with itself.
template<typename T_x , typename T_lb , require_all_prim_or_rev_kernel_expression_t< T_x, T_lb > * = nullptr, require_any_var_t< T_x, T_lb > * = nullptr, require_any_not_stan_scalar_t< T_x, T_lb > * = nullptr>
var_value< matrix_cl< double > >	lb_constrain (T_x &&x, T_lb &&lb)
	Return the lower-bounded value for the specified unconstrained input and specified lower bound.
template<typename T_x , typename T_lb , require_all_prim_or_rev_kernel_expression_t< T_x, T_lb > * = nullptr, require_any_var_t< T_x, T_lb > * = nullptr, require_any_not_stan_scalar_t< T_x, T_lb > * = nullptr>
var_value< matrix_cl< double > >	lb_constrain (T_x &&x, T_lb &&lb, var &lp)
	Return the lower-bounded value for the specified unconstrained input and specified lower bound.
template<typename T_x , typename T_lb , typename T_ub , require_all_prim_or_rev_kernel_expression_t< T_x, T_lb, T_ub > * = nullptr, require_any_var_t< T_x, T_lb, T_ub > * = nullptr, require_any_not_stan_scalar_t< T_x, T_lb, T_ub > * = nullptr>
var_value< matrix_cl< double > >	lub_constrain (T_x &&x, T_lb &&lb, T_ub &&ub)
	Return the bounded value for the specified unconstrained input and specified bounds.
template<typename T_x , typename T_lb , typename T_ub , require_all_prim_or_rev_kernel_expression_t< T_x, T_lb, T_ub > * = nullptr, require_any_var_t< T_x, T_lb, T_ub > * = nullptr, require_any_not_stan_scalar_t< T_x, T_lb, T_ub > * = nullptr>
var_value< matrix_cl< double > >	lub_constrain (T_x &&x, T_lb &&lb, T_ub &&ub, var &lp)
	Return the bounded value for the specified unconstrained input and specified bounds.
template<typename T , typename M , typename S , require_all_prim_or_rev_kernel_expression_t< T, M, S > * = nullptr, require_any_not_stan_scalar_t< T, M, S > * = nullptr, require_any_var_t< T, M, S > * = nullptr>
var_value< matrix_cl< double > >	offset_multiplier_constrain (T &&A, M &&mu, S &&sigma)
	Return the linearly transformed value for the specified unconstrained input and specified offset and multiplier.
template<typename T , typename M , typename S , require_all_prim_or_rev_kernel_expression_t< T, M, S > * = nullptr, require_any_not_stan_scalar_t< T, M, S > * = nullptr, require_any_var_t< T, M, S > * = nullptr>
var_value< matrix_cl< double > >	offset_multiplier_constrain (T &&A, M &&mu, S &&sigma, var &lp)
	Return the linearly transformed value for the specified unconstrained input and specified offset and multiplier.
template<typename T_x , typename T_ub , require_all_prim_or_rev_kernel_expression_t< T_x, T_ub > * = nullptr, require_any_var_t< T_x, T_ub > * = nullptr, require_any_not_stan_scalar_t< T_x, T_ub > * = nullptr>
var_value< matrix_cl< double > >	ub_constrain (T_x &&x, T_ub &&ub)
	Return the upper-bounded value for the specified unconstrained input and specified upper bound.
template<typename T_x , typename T_ub , require_all_prim_or_rev_kernel_expression_t< T_x, T_ub > * = nullptr, require_any_var_t< T_x, T_ub > * = nullptr, require_any_not_stan_scalar_t< T_x, T_ub > * = nullptr>
var_value< matrix_cl< double > >	ub_constrain (T_x &&x, T_ub &&ub, var &lp)
	Return the upper-bounded value for the specified unconstrained input and specified upper bound.
template<typename T , require_all_kernel_expressions_and_none_scalar_t< T > * = nullptr>
var_value< matrix_cl< double > >	unit_vector_constrain (const var_value< T > &A)
	Return the unit length vector corresponding to the free vector y.
template<typename T , require_all_kernel_expressions_and_none_scalar_t< T > * = nullptr>
var_value< matrix_cl< double > >	unit_vector_constrain (const var_value< T > &A, var &lp)
	Return the unit length vector corresponding to the free vector y.
template<typename T >
var_value< matrix_cl< value_type_t< T > > >	to_matrix_cl (const var_value< T > &a)
	Copies the source var containing Eigen matrices to destination var that has data stored on the OpenCL device.
template<typename T , require_stan_scalar_t< T > * = nullptr>
var_value< matrix_cl< value_type_t< T > > >	to_matrix_cl (const std::vector< var_value< T > > &a)
	Copies the source std::vector of vars to a destination var that has data stored on the OpenCL device.
template<typename T , require_eigen_vt< is_var, T > * = nullptr>
var_value< matrix_cl< value_type_t< value_type_t< T > > > >	to_matrix_cl (const T &src)
	Copies the source Eigen matrix of vars to the destination matrix that is stored on the OpenCL device.
template<typename T , require_eigen_vt< is_var, T > * = nullptr>
var_value< matrix_cl< value_type_t< value_type_t< T > > > >	to_matrix_cl (const std::vector< T > &src)
	Copies the source vector of Eigen matrices of vars to the destination matrix that is stored on the OpenCL device.
template<typename T_dst , typename T , require_var_vt< is_eigen, T_dst > * = nullptr, require_all_kernel_expressions_t< T > * = nullptr>
T_dst	from_matrix_cl (const var_value< T > &a)
	Copies the source var that has data stored on the OpenCL device to destination var containing Eigen matrix.
template<typename T_dst , typename T , require_std_vector_vt< is_var, T_dst > * = nullptr, require_all_stan_scalar_t< value_type_t< T_dst > > * = nullptr, require_all_kernel_expressions_t< T > * = nullptr>
T_dst	from_matrix_cl (const var_value< T > &a)
	Copies the source var that has data stored on the OpenCL device to destination std::vector containing vars.
template<typename T , require_all_kernel_expressions_t< T > * = nullptr>
auto	from_matrix_cl (const var_value< T > &src)
	Copies the source var that has data stored on the OpenCL device to destination Eigen matrix containing vars.
template<typename T , require_all_kernel_expressions_and_none_scalar_t< T > * = nullptr>
var_value< matrix_cl< double > >	cos (const var_value< T > &A)
	Returns the elementwise cos() of a var_value<matrix_cl<double>> in radians.
template<typename T , require_all_kernel_expressions_and_none_scalar_t< T > * = nullptr>
var_value< matrix_cl< double > >	cosh (const var_value< T > &A)
	Returns the elementwise cosh() of a var_value<matrix_cl<double>> in radians.
template<typename T , require_all_kernel_expressions_and_none_scalar_t< T > * = nullptr>
var_value< matrix_cl< double > >	crossprod (const var_value< T > &M)
	Returns the result of pre-multiplying a matrix by its own transpose.
template<typename T , require_all_kernel_expressions_and_none_scalar_t< T > * = nullptr>
var_value< matrix_cl< double > >	cumulative_sum (const var_value< T > &A)
	Return the cumulative sum of the specified vector.
template<typename T , require_all_kernel_expressions_and_none_scalar_t< T > * = nullptr>
var_value< matrix_cl< double > >	diag_matrix (const var_value< T > &v)
	Return a square diagonal matrix with the specified vector of coefficients as the diagonal values.
template<typename T1 , typename T2 , require_any_var_t< T1, T2 > * = nullptr, require_all_nonscalar_prim_or_rev_kernel_expression_t< T1, T2 > * = nullptr>
var_value< matrix_cl< double > >	diag_post_multiply (T1 &&v1, T2 &&v2)
	Return the product of a matrix and the diagonal matrix formed from the vector or row_vector.
template<typename T1 , typename T2 , require_any_var_t< T1, T2 > * = nullptr, require_all_nonscalar_prim_or_rev_kernel_expression_t< T1, T2 > * = nullptr>
var_value< matrix_cl< double > >	diag_pre_multiply (T1 &&v1, T2 &&v2)
	Return the product of the diagonal matrix formed from the vector or row_vector and a matrix.
template<typename T , require_all_kernel_expressions_and_none_scalar_t< T > * = nullptr>
var_value< matrix_cl< double > >	diagonal (const var_value< T > &M)
	Return a column vector of the diagonal elements of the specified matrix.
var_value< matrix_cl< double > >	digamma (const var_value< matrix_cl< double > > &A)
	Returns the elementwise digamma() of a var_value<matrix_cl<double>>.
template<typename T_a , typename T_b , require_stan_scalar_t< T_b > * = nullptr, require_all_nonscalar_prim_or_rev_kernel_expression_t< T_a > * = nullptr, require_any_var_t< T_a, T_b > * = nullptr>
var_value< matrix_cl< double > >	divide (T_a &&a, T_b &&b)
	Elementwise division of a kernel generator expression and a scalar.
template<typename T1 , typename T2 , require_any_var_t< T1, T2 > * = nullptr, require_all_nonscalar_prim_or_rev_kernel_expression_t< T1, T2 > * = nullptr>
var	dot_product (T1 &&v1, T2 &&v2)
	Returns the dot product.
template<typename T , require_all_kernel_expressions_and_none_scalar_t< T > * = nullptr>
var	dot_self (const var_value< T > &v)
	Returns the dot product of a vector of var with itself.
template<typename T_a , typename T_b , require_all_prim_or_rev_kernel_expression_t< T_a, T_b > * = nullptr, require_any_var_t< T_a, T_b > * = nullptr, require_any_not_stan_scalar_t< T_a, T_b > * = nullptr>
var_value< matrix_cl< double > >	elt_divide (T_a &&a, T_b &&b)
	Elementwise division of two reverse mode matrices and/or kernel generator expressions.
template<typename T_a , typename T_b , require_all_nonscalar_prim_or_rev_kernel_expression_t< T_a, T_b > * = nullptr, require_any_var_t< T_a, T_b > * = nullptr>
var_value< matrix_cl< double > >	elt_multiply (T_a &&a, T_b &&b)
	Elementwise multiplication of two reverse mode matrices and/or kernel generator expressions.
template<typename T , require_all_kernel_expressions_and_none_scalar_t< T > * = nullptr>
var_value< matrix_cl< double > >	erf (const var_value< T > &A)
	Returns the elementwise erf() of a var_value<matrix_cl<double>>.
template<typename T , require_all_kernel_expressions_and_none_scalar_t< T > * = nullptr>
var_value< matrix_cl< double > >	erfc (const var_value< T > &A)
	Returns the elementwise erfc() of a var_value<matrix_cl<double>>.
template<typename T , require_all_kernel_expressions_and_none_scalar_t< T > * = nullptr>
var_value< matrix_cl< double > >	exp (const var_value< T > &A)
	Returns the elementwise exp() of a var_value<matrix_cl<double>>.
template<typename T , require_all_kernel_expressions_and_none_scalar_t< T > * = nullptr>
var_value< matrix_cl< double > >	exp2 (const var_value< T > &A)
	Returns the elementwise exp2() of a var_value<matrix_cl<double>>.
template<typename T , require_all_kernel_expressions_and_none_scalar_t< T > * = nullptr>
var_value< matrix_cl< double > >	expm1 (const var_value< T > &A)
	Returns the elementwise expm1() of a var_value<matrix_cl<double>>.
template<typename T , require_all_kernel_expressions_and_none_scalar_t< T > * = nullptr>
var_value< matrix_cl< double > >	fabs (const var_value< T > &A)
	Returns the elementwise fabs() of the input var_value<matrix_cl<double>>.
template<typename T_a , typename T_b , require_all_prim_or_rev_kernel_expression_t< T_a, T_b > * = nullptr, require_any_var_t< T_a, T_b > * = nullptr, require_any_not_stan_scalar_t< T_a, T_b > * = nullptr>
var_value< matrix_cl< double > >	fdim (T_a &&a, T_b &&b)
	Return the positive difference between the first variable's the value and the second's (C99, C++11).
template<typename T , require_all_kernel_expressions_and_none_scalar_t< T > * = nullptr>
var_value< matrix_cl< double > >	floor (const var_value< T > &A)
	Returns the elementwise floor() of the input var_value<matrix_cl<double>>.
template<typename T_a , typename T_b , require_all_prim_or_rev_kernel_expression_t< T_a, T_b > * = nullptr, require_any_var_t< T_a, T_b > * = nullptr, require_any_not_stan_scalar_t< T_a, T_b > * = nullptr>
var_value< matrix_cl< double > >	fmax (T_a &&a, T_b &&b)
	Return the greater of the two specified arguments.
template<typename T_a , typename T_b , require_all_prim_or_rev_kernel_expression_t< T_a, T_b > * = nullptr, require_any_var_t< T_a, T_b > * = nullptr, require_any_not_stan_scalar_t< T_a, T_b > * = nullptr>
var_value< matrix_cl< double > >	fmin (T_a &&a, T_b &&b)
	Return the lesser of the two specified arguments.
template<typename T_a , typename T_b , require_all_prim_or_rev_kernel_expression_t< T_a, T_b > * = nullptr, require_any_var_t< T_a, T_b > * = nullptr, require_any_not_stan_scalar_t< T_a, T_b > * = nullptr>
var_value< matrix_cl< double > >	fmod (T_a &&a, T_b &&b)
	Return the floating point remainder after dividing the first variable by the second (cmath).
void	grad (var &v, var_value< matrix_cl< double > > &x, Eigen::VectorXd &g)
	Propagate chain rule to calculate gradients starting from the specified variable.
template<typename T_a , typename T_b , require_all_prim_or_rev_kernel_expression_t< T_a, T_b > * = nullptr, require_any_var_t< T_a, T_b > * = nullptr, require_any_not_stan_scalar_t< T_a, T_b > * = nullptr>
var_value< matrix_cl< double > >	hypot (T_a &&a, T_b &&b)
	Returns the elementwise hypot() of the input.
template<typename T , require_all_kernel_expressions_and_none_scalar_t< T > * = nullptr>
var_value< matrix_cl< double > >	inv (const var_value< T > &A)
	Returns the elementwise inv() of a var_value<matrix_cl<double>>.
template<typename T , require_all_kernel_expressions_and_none_scalar_t< T > * = nullptr>
var_value< matrix_cl< double > >	inv_cloglog (const var_value< T > &A)
	Returns the elementwise inv_cloglog() of a var_value<matrix_cl<double>>.
template<typename T , require_all_kernel_expressions_and_none_scalar_t< T > * = nullptr>
var_value< matrix_cl< double > >	inv_logit (const var_value< T > &A)
	Returns the elementwise inv_logit() of a var_value<matrix_cl<double>>.
template<typename T , require_all_kernel_expressions_and_none_scalar_t< T > * = nullptr>
var_value< matrix_cl< double > >	inv_Phi (const var_value< T > &A)
	Returns the elementwise inv_Phi() of a var_value<matrix_cl<double>>.
template<typename T , require_all_kernel_expressions_and_none_scalar_t< T > * = nullptr>
var_value< matrix_cl< double > >	inv_sqrt (const var_value< T > &A)
	Returns the elementwise inv_sqrt() of a var_value<matrix_cl<double>>.
template<typename T , require_all_kernel_expressions_and_none_scalar_t< T > * = nullptr>
var_value< matrix_cl< double > >	inv_square (const var_value< T > &A)
	Returns the elementwise inv_square() of a var_value<matrix_cl<double>>.
template<typename T_a , typename T_b , require_all_prim_or_rev_kernel_expression_t< T_a, T_b > * = nullptr, require_any_var_t< T_a, T_b > * = nullptr, require_any_not_stan_scalar_t< T_a, T_b > * = nullptr>
auto	lbeta (T_a &&a, T_b &&b)
	Return the elementwise lbeta() on two input kernel generator expression.
template<typename T_a , typename T_b , require_all_kernel_expressions_t< T_a, T_b > * = nullptr, require_st_integral< T_b > * = nullptr>
var_value< matrix_cl< double > >	ldexp (const var_value< T_a > &a, T_b &&b)
	Returns the elementwise ldexp() of the input var_value<matrix_cl<double>> and kernel generator expression.
template<typename T , require_all_kernel_expressions_and_none_scalar_t< T > * = nullptr>
var_value< matrix_cl< double > >	lgamma (const var_value< T > &A)
	Returns the elementwise lgamma() of a var_value<matrix_cl<double>>.
template<typename T_a , typename T_b , require_all_prim_or_rev_kernel_expression_t< T_a, T_b > * = nullptr, require_any_var_t< T_a, T_b > * = nullptr, require_any_not_stan_scalar_t< T_a, T_b > * = nullptr>
var_value< matrix_cl< double > >	lmultiply (T_a &&a, T_b &&b)
	Returns the elementwise lmultiply() of the input.
template<typename T , require_all_kernel_expressions_and_none_scalar_t< T > * = nullptr>
var_value< matrix_cl< double > >	log (const var_value< T > &A)
	Returns the elementwise log() of a var_value<matrix_cl<double>>.
template<typename T , require_all_kernel_expressions_and_none_scalar_t< T > * = nullptr>
var_value< matrix_cl< double > >	log10 (const var_value< T > &A)
	Returns the elementwise log10() of a var_value<matrix_cl<double>>.
template<typename T , require_all_kernel_expressions_and_none_scalar_t< T > * = nullptr>
var_value< matrix_cl< double > >	log1m (const var_value< T > &A)
	Returns the elementwise log1m() of a var_value<matrix_cl<double>>.
template<typename T , require_all_kernel_expressions_and_none_scalar_t< T > * = nullptr>
var_value< matrix_cl< double > >	log1m_exp (const var_value< T > &A)
	Returns the elementwise log1m_exp() of a var_value<matrix_cl<double>>.
template<typename T , require_all_kernel_expressions_and_none_scalar_t< T > * = nullptr>
var_value< matrix_cl< double > >	log1m_inv_logit (const var_value< T > &A)
	Returns the elementwise log1m_inv_logit() of a var_value<matrix_cl<double>>.
template<typename T , require_all_kernel_expressions_and_none_scalar_t< T > * = nullptr>
var_value< matrix_cl< double > >	log1p (const var_value< T > &A)
	Returns the elementwise log1p() of a var_value<matrix_cl<double>>.
template<typename T , require_all_kernel_expressions_and_none_scalar_t< T > * = nullptr>
var_value< matrix_cl< double > >	log1p_exp (const var_value< T > &A)
	Returns the elementwise log1p_exp() of a var_value<matrix_cl<double>>.
template<typename T , require_all_kernel_expressions_and_none_scalar_t< T > * = nullptr>
var_value< matrix_cl< double > >	log2 (const var_value< T > &A)
	Returns the elementwise log2() of a var_value<matrix_cl<double>>.
template<typename T_x , typename T_y , require_all_prim_or_rev_kernel_expression_t< T_x, T_y > * = nullptr, require_any_var_t< T_x, T_y > * = nullptr, require_any_not_stan_scalar_t< T_x, T_y > * = nullptr>
var_value< matrix_cl< double > >	log_diff_exp (T_x &&x, T_y &&y)
	Returns the natural logarithm of the difference of the natural exponentiation of x and the natural exponentiation of y.
template<typename T , require_all_kernel_expressions_and_none_scalar_t< T > * = nullptr>
var_value< matrix_cl< double > >	log_inv_logit (const var_value< T > &A)
	Returns the elementwise log_inv_logit() of a var_value<matrix_cl<double>>.
template<typename T_x , typename T_y , require_all_prim_or_rev_kernel_expression_t< T_x, T_y > * = nullptr, require_any_var_t< T_x, T_y > * = nullptr, require_any_not_stan_scalar_t< T_x, T_y > * = nullptr>
var_value< matrix_cl< double > >	log_inv_logit_diff (T_x &&x, T_y &&y)
	Returns the natural logarithm of the difference of the inverse logits of the specified arguments.
template<typename T , require_all_kernel_expressions_and_none_scalar_t< T > * = nullptr>
var_value< matrix_cl< double > >	log_softmax (const var_value< T > &A)
	Return log of the softmax of the specified vector.
template<typename T , require_all_kernel_expressions_and_none_scalar_t< T > * = nullptr>
var	log_sum_exp (const var_value< T > &A)
	Return the log of the sum of the exponentiated values of the specified matrix of values.
template<typename T , require_all_kernel_expressions_and_none_scalar_t< T > * = nullptr>
var_value< matrix_cl< double > >	logit (const var_value< T > &A)
	Returns the elementwise logit() of a var_value<matrix_cl<double>>.
template<typename T , require_all_kernel_expressions_and_none_scalar_t< T > * = nullptr>
var_value< matrix_cl< double > >	matrix_power (const var_value< T > &M, const int n)
	Returns the nth power of the specific matrix.
template<typename T1 , typename T2 , require_all_nonscalar_prim_or_rev_kernel_expression_t< T1, T2 > * = nullptr, require_any_var_t< T1, T2 > * = nullptr>
var_value< matrix_cl< double > >	mdivide_left_tri_low (T1 &&A, T2 &&b)
	Returns the solution of the system Ax=b when A is lower triangular.
template<typename T , require_all_kernel_expressions_and_none_scalar_t< T > * = nullptr>
var_value< matrix_cl< double > >	mdivide_left_tri_low (const var_value< T > &A)
	Returns the solution of the system Ax=b when A is triangular and b=I.
template<typename T1 , typename T2 , require_all_nonscalar_prim_or_rev_kernel_expression_t< T1, T2 > * = nullptr, require_any_var_t< T1, T2 > * = nullptr>
var_value< matrix_cl< double > >	mdivide_right_tri_low (T2 &&b, T1 &&A)
	Returns the solution of the system Ax=b when A is lower triangular.
template<typename T_a , typename T_b , require_all_nonscalar_prim_or_rev_kernel_expression_t< T_a, T_b > * = nullptr, require_any_var_t< T_a, T_b > * = nullptr>
auto	multiply (T_a &&A, T_b &&B)
	Matrix multiplication of two reverse mode matrices and/or kernel generator expressions.
template<typename T_a , typename T_b , require_all_nonscalar_prim_or_rev_kernel_expression_t< T_a, T_b > * = nullptr, require_any_var_t< T_a, T_b > * = nullptr>
auto	operator* (const T_a &A, const T_b &B)
	Matrix multiplication of two reverse mode matrices and/or kernel generator expressions.
template<typename T1 , typename T2 , require_stan_scalar_t< T1 > * = nullptr, require_all_nonscalar_prim_or_rev_kernel_expression_t< T2 > * = nullptr, require_any_var_t< T1, T2 > * = nullptr>
auto	multiply (const T1 &A, T2 &&B)
	Return matrix multiplied by a scalar.
template<typename T1 , typename T2 , require_stan_scalar_t< T2 > * = nullptr, require_all_nonscalar_prim_or_rev_kernel_expression_t< T1 > * = nullptr, require_any_var_t< T1, T2 > * = nullptr>
auto	multiply (const T1 &A, const T2 &B)
	Return matrix multiplied by a scalar.
template<typename T_a , typename T_b , require_all_prim_or_rev_kernel_expression_t< T_a, T_b > * = nullptr, require_any_var_t< T_a, T_b > * = nullptr, require_any_not_stan_scalar_t< T_a, T_b > * = nullptr>
var_value< matrix_cl< double > >	multiply_log (T_a &&a, T_b &&b)
	Returns the elementwise multiply_log() of the input.
template<typename T , require_all_kernel_expressions_and_none_scalar_t< T > * = nullptr>
var_value< matrix_cl< double > >	multiply_lower_tri_self_transpose (const var_value< T > &A)
	Returns the result of multiplying the lower triangular portion of the input matrix by its own transpose.
template<typename T , require_all_kernel_expressions_and_none_scalar_t< T > * = nullptr>
var_value< matrix_cl< double > >	operator- (const var_value< T > &M)
	Returns the unary minus of the input.
template<typename T , require_var_vt< is_kernel_expression_and_not_scalar, T > * = nullptr>
T	operator+ (T &&M)
	Returns the unary plus of the input.
template<typename T , require_all_kernel_expressions_and_none_scalar_t< T > * = nullptr>
var_value< matrix_cl< double > >	Phi (const var_value< T > &A)
	Returns the elementwise Phi() of a var_value<matrix_cl<double>>.
template<typename T , require_all_kernel_expressions_and_none_scalar_t< T > * = nullptr>
var_value< matrix_cl< double > >	Phi_approx (const var_value< T > &A)
	Returns the elementwise Phi_approx() of a var_value<matrix_cl<double>>.
template<typename T_a , typename T_b , require_all_prim_or_rev_kernel_expression_t< T_a, T_b > * = nullptr, require_any_var_t< T_a, T_b > * = nullptr, require_any_not_stan_scalar_t< T_a, T_b > * = nullptr>
var_value< matrix_cl< double > >	pow (T_a &&a, T_b &&b)
	Return the first argument raised to the power of the second argument.
template<typename T , require_all_kernel_expressions_and_none_scalar_t< T > * = nullptr>
var	prod (const var_value< T > &x)
	Returns the pro