Automatic Differentiation
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

 internal
 A comparator that works for any container type that has the brackets operator.
 
 opencl
 
 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
 
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
 
struct  append_return_type< Eigen::Matrix< T1, R, C >, Eigen::Matrix< T2, R, C > >
 
struct  append_return_type< int, int >
 
struct  append_return_type< std::vector< T1 >, std::vector< T2 > >
 
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 > >
 Specialisation for use with nested containers (std::vectors). More...
 
struct  apply_vector_unary< T, require_std_vector_vt< is_stan_scalar, T > >
 Specialisation for use with (non-nested) std::vectors. More...
 
struct  apply_vector_unary< T, require_var_matrix_t< T > >
 Specialisation 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_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...
 
struct  child_type
 
struct  child_type< T_struct< T_child > >
 
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
 
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...
 
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
 
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
 
struct  include_summand< propto, T >
 
struct  index_type
 
struct  index_type< T, require_eigen_t< T > >
 
struct  index_type< T, require_std_vector_t< T > >
 
struct  index_type< T, std::enable_if_t< std::is_pointer< T >::value > >
 
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
 
class  opencl_context_base
 
class  operands_and_partials
 
class  operands_and_partials< Op1, Op2, Op3, Op4, Op5, fvar< Dx > >
 
class  operands_and_partials< Op1, Op2, Op3, Op4, Op5, var >
 
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_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, 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  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. More...
 
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 >
using as_operation_cl_t = std::conditional_t< std::is_lvalue_reference< T >::value, decltype(as_operation_cl(std::declval< T >())), std::remove_reference_t< decltype(as_operation_cl(std::declval< T >()))> >
 Type that results when converting any valid kernel generator expression into operation. More...
 
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. More...
 
template<typename... Types>
using common_scalar_t = typename std::common_type_t< typename std::remove_reference_t< Types >::Scalar... >
 
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. More...
 
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. More...
 
using matrix_d = Eigen::Matrix< double, Eigen::Dynamic, Eigen::Dynamic >
 Type for matrix of double values. More...
 
using vector_d = Eigen::Matrix< double, Eigen::Dynamic, 1 >
 Type for (column) vector of double values. More...
 
using row_vector_d = Eigen::Matrix< double, 1, Eigen::Dynamic >
 Type for (row) vector of double values. More...
 
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
More...
 
template<typename T >
using require_not_tuple_t = require_not_t< is_tuple< std::decay_t< T > >>
 Require type does not satisfy is_tuple
More...
 
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
More...
 
template<typename... Types>
using require_any_tuple_t = require_any_t< is_tuple< std::decay_t< Types > >... >
 Require any of the types satisfy is_tuple
More...
 
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
More...
 
template<typename... Types>
using require_any_not_tuple_t = require_any_not_t< is_tuple< std::decay_t< Types > >... >
 Require at least one of the types do not satisfy is_tuple
More...
 
template<typename T >
using require_vt_tuple = require_t< is_tuple< value_type_t< std::decay_t< T > >> >
 Require value type satisfies is_tuple
More...
 
template<typename T >
using require_not_vt_tuple = require_not_t< is_tuple< value_type_t< std::decay_t< T > >> >
 Require value type does not satisfy is_tuple
More...
 
template<typename... Types>
using require_all_vt_tuple = require_all_t< is_tuple< value_type_t< std::decay_t< Types > >>... >
 Require all of the value types satisfy is_tuple
More...
 
template<typename... Types>
using require_any_vt_tuple = require_any_t< is_tuple< value_type_t< std::decay_t< Types > >>... >
 Require any of the value types satisfy is_tuple
More...
 
template<typename... Types>
using require_all_not_vt_tuple = require_all_not_t< is_tuple< value_type_t< std::decay_t< Types > >>... >
 Require none of the value types satisfy is_tuple
More...
 
template<typename... Types>
using require_any_not_vt_tuple = require_any_not_t< is_tuple< value_type_t< std::decay_t< Types > >>... >
 Require at least one of the value types do not satisfy is_tuple
More...
 
template<typename T >
using require_st_tuple = require_t< is_tuple< scalar_type_t< std::decay_t< T > >> >
 Require scalar type satisfies is_tuple
More...
 
template<typename T >
using require_not_st_tuple = require_not_t< is_tuple< scalar_type_t< std::decay_t< T > >> >
 Require scalar type does not satisfy is_tuple
More...
 
template<typename... Types>
using require_all_st_tuple = require_all_t< is_tuple< scalar_type_t< std::decay_t< Types > >>... >
 Require all of the scalar types satisfy is_tuple
More...
 
template<typename... Types>
using require_any_st_tuple = require_any_t< is_tuple< scalar_type_t< std::decay_t< Types > >>... >
 Require any of the scalar types satisfy is_tuple
More...
 
template<typename... Types>
using require_all_not_st_tuple = require_all_not_t< is_tuple< scalar_type_t< std::decay_t< Types > >>... >
 Require none of the scalar types satisfy is_tuple
More...
 
template<typename... Types>
using require_any_not_st_tuple = require_any_not_t< is_tuple< scalar_type_t< std::decay_t< Types > >>... >
 Any of the scalar types do not satisfy is_tuple
More...
 
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 = std::map< profile_key, profile_info >
 
using matrix_v = Eigen::Matrix< var, Eigen::Dynamic, Eigen::Dynamic >
 The type of a matrix holding var values. More...
 
using vector_v = Eigen::Matrix< var, Eigen::Dynamic, 1 >
 The type of a (column) vector holding var values. More...
 
using row_vector_v = Eigen::Matrix< var, 1, Eigen::Dynamic >
 The type of a row vector holding var values. More...
 
using matrix_vi = Eigen::Matrix< vari *, Eigen::Dynamic, Eigen::Dynamic >
 The type of a matrix holding vari* values. More...
 
using vector_vi = Eigen::Matrix< vari *, Eigen::Dynamic, 1 >
 The type of a (column) vector holding vari* values. More...
 
using row_vector_vi = Eigen::Matrix< vari *, 1, Eigen::Dynamic >
 The type of a row vector holding vari* values. More...
 
using var = var_value< double >
 
using vari = vari_value< double >
 

Enumerations

enum  matrix_cl_view { matrix_cl_view::Diagonal = 0, matrix_cl_view::Lower = 1, matrix_cl_view::Upper = 2, matrix_cl_view::Entire = 3 }
 

Functions

template<typename T >
fvar< T > operator+ (const fvar< T > &x1, const fvar< T > &x2)
 Return the sum of the specified forward mode addends. More...
 
template<typename T >
fvar< T > operator+ (double x1, const fvar< T > &x2)
 Return the sum of the specified double and forward mode addends. More...
 
template<typename T >
fvar< T > operator+ (const fvar< T > &x1, double x2)
 Return the sum of the specified forward mode and double addends. More...
 
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. More...
 
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. More...
 
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. More...
 
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 ==. More...
 
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 ==. More...
 
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 ==. More...
 
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 >. More...
 
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 >. More...
 
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 >. More...
 
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 >=. More...
 
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 >=. More...
 
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 >=. More...
 
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 <. More...
 
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 <. More...
 
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 <. More...
 
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 <=. More...
 
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 <=. More...
 
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 <=. More...
 
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 &&. More...
 
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 &&. More...
 
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 &&. More...
 
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 ||. More...
 
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 ||. More...
 
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 ||. More...
 
template<typename T >
fvar< T > operator* (const fvar< T > &x, const fvar< T > &y)
 Return the product of the two arguments. More...
 
template<typename T >
fvar< T > operator* (double x, const fvar< T > &y)
 Return the product of the two arguments. More...
 
template<typename T >
fvar< T > operator* (const fvar< T > &x, double y)
 Return the product of the two arguments. More...
 
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 !=. More...
 
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 !=. More...
 
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 !=. More...
 
template<typename T >
fvar< T > operator- (const fvar< T > &x1, const fvar< T > &x2)
 Return the difference of the specified arguments. More...
 
template<typename T >
fvar< T > operator- (double x1, const fvar< T > &x2)
 Return the difference of the specified arguments. More...
 
template<typename T >
fvar< T > operator- (const fvar< T > &x1, double x2)
 Return the difference of the specified arguments. More...
 
template<typename T >
fvar< T > operator- (const fvar< T > &x)
 Return the negation of the specified argument. More...
 
template<typename T >
bool operator! (const fvar< T > &x)
 Return the negation of the value of the argument as defined by !. More...
 
template<typename T >
fvar< T > operator+ (const fvar< T > &x)
 Returns the argument. More...
 
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. More...
 
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. More...
 
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. More...
 
template<typename T >
fvar< T > arg (const std::complex< fvar< T >> &z)
 Return the phase angle of the complex argument. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
template<typename T >
std::complex< fvar< T > > atanh (const std::complex< fvar< T >> &z)
 Return the hyperbolic arc tangent of the complex argument. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
template<typename T >
fvar< T > fdim (const fvar< T > &x, const fvar< T > &y)
 Return the positive difference of the specified values (C++11). More...
 
template<typename T >
fvar< T > fdim (const fvar< T > &x, double y)
 Return the positive difference of the specified values (C++11). More...
 
template<typename T >
fvar< T > fdim (double x, const fvar< T > &y)
 Return the positive difference of the specified values (C++11). More...
 
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). More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
template<typename T >
fvar< T > fmax (const fvar< T > &x1, const fvar< T > &x2)
 Return the greater of the two specified arguments. More...
 
template<typename T >
fvar< T > fmax (double x1, const fvar< T > &x2)
 Return the greater of the two specified arguments. More...
 
template<typename T >
fvar< T > fmax (const fvar< T > &x1, double x2)
 Return the greater of the two specified arguments. More...
 
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. More...
 
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)\). More...
 
template<typename Ta , typename Tb , typename Tz , require_all_matrix_t< Ta, Tb > * = nullptr, require_return_type_t< is_fvar, Ta, Tb, Tz > * = nullptr>
return_type_t< Ta, Tb, Tz > hypergeometric_pFq (const Ta &a, const Tb &b, const Tz &z)
 Returns the generalised hypergeometric (pFq) function applied to the input arguments. More...
 
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). More...
 
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). More...
 
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). More...
 
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. More...
 
template<typename T >
fvar< T > inv_logit (const fvar< T > &x)
 Returns the inverse logit function applied to the argument. More...
 
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. More...
 
template<typename T >
int is_inf (const fvar< T > &x)
 Returns 1 if the input's value is infinite and 0 otherwise. More...
 
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. More...
 
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). More...
 
template<typename T >
fvar< T > lgamma (const fvar< T > &x)
 Return the natural logarithm of the gamma function applied to the specified argument. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
template<typename T >
fvar< T > owens_t (double x1, const fvar< T > &x2)
 Return Owen's T function applied to the specified arguments. More...
 
template<typename T >
fvar< T > owens_t (const fvar< T > &x1, double x2)
 Return Owen's T function applied to the specified arguments. More...
 
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). More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
template<typename T >
double primitive_value (const fvar< T > &v)
 Return the primitive value of the specified forward-mode autodiff variable. More...
 
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. More...
 
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 \). More...
 
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 \). More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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). More...
 
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. More...
 
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 >
value_of (const fvar< T > &v)
 Return the value of the specified variable. More...
 
template<typename T >
double value_of_rec (const fvar< T > &v)
 Return the value of the specified variable. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
template<typename T , require_st_arithmetic< T > * = nullptr>
matrix_cl< scalar_type_t< T > > to_matrix_cl (T &&src)
 
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)
 
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)
 
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)
 
template<typename T , require_all_kernel_expressions_t< T > * = nullptr>
auto from_matrix_cl (const T &src)
 
template<typename T , require_matrix_cl_t< T > * = nullptr>
auto packed_copy (const T &src)
 
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)
 
template<typename T , require_matrix_cl_t< T > * = nullptr>
plain_type_t< T > copy_cl (const T &src)
 
template<typename T >
void check_mat_not_size_one (const char *function, const char *name, const matrix_cl< T > &A)
 
void check_opencl_error (const char *function, const cl::Error &e)
 
template<typename T , typename = require_arithmetic_t<T>>
void check_symmetric (const char *function, const char *name, const matrix_cl< T > &y)
 
template<typename T , require_matrix_cl_t< T > * = nullptr>
void check_triangular (const char *function, const char *name, const T &A)
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
template<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. More...
 
template<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. More...
 
scalar_< char > as_operation_cl (const bool a)
 Converts any valid kernel generator expression into an operation. More...
 
template<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 > as_operation_cl (T_matrix_cl &&a)
 Converts any valid kernel generator expression into an operation. More...
 
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. More...
 
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. More...
 
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. More...
 
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). More...
 
template<typename T , typename = require_all_kernel_expressions_and_none_scalar_t<T>>
auto rowwise_broadcast (T &&a)
 Broadcast an expression in rowwise dimmension. More...
 
template<typename T , typename = require_all_kernel_expressions_and_none_scalar_t<T>>
auto colwise_broadcast (T &&a)
 Broadcast an expression in colwise dimmension. More...
 
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. More...
 
template<typename Scalar , typename T , require_stan_scalar_t< T > * = nullptr>
Scalar cast (T a)
 Typecast a scalar. More...
 
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. More...
 
template<typename T , require_all_kernel_expressions_t< T > * = nullptr>
auto colwise_sum (T &&a)
 Column wise sum - reduction of a kernel generator expression. More...
 
template<typename T , require_all_kernel_expressions_t< T > * = nullptr>
auto colwise_prod (T &&a)
 Column wise product - reduction of a kernel generator expression. More...
 
template<typename T , require_all_kernel_expressions_t< T > * = nullptr>
auto colwise_max (T &&a)
 Column wise max - reduction of a kernel generator expression. More...
 
template<typename T , require_all_kernel_expressions_t< T > * = nullptr>
auto colwise_min (T &&a)
 Column wise min - reduction of a kernel generator expression. More...
 
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. More...
 
template<typename T , typename = require_all_kernel_expressions_and_none_scalar_t<T>>
auto diagonal (T &&a)
 Diagonal of a kernel generator expression. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
template<typename... T_expressions>
expressions_cl< T_expressions... > expressions (T_expressions &&... expressions)
 Deduces types for constructing expressions_cl object. More...
 
template<typename... T_results>
results_cl< T_results... > results (T_results &&... results)
 Deduces types for constructing results_cl object. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
template<typename T , require_all_kernel_expressions_t< T > * = nullptr>
auto sum_2d (T &&a)
 Two dimensional sum - reduction of a kernel generator expression. More...
 
template<typename T , require_all_kernel_expressions_t< T > * = nullptr>
auto prod_2d (T &&a)
 Two dimensional product - reduction of a kernel generator expression. More...
 
template<typename T , require_all_kernel_expressions_t< T > * = nullptr>
auto max_2d (T &&a)
 Two dimensional max - reduction of a kernel generator expression. More...
 
template<typename T , require_all_kernel_expressions_t< T > * = nullptr>
auto min_2d (T &&a)
 Two dimensional min - reduction of a kernel generator expression. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
template<typename T_then , typename T_else , require_all_arithmetic_t< T_then, T_else > * = nullptr>
std::common_type_t< T_then, T_else > select (bool condition, T_then then, T_else els)
 Scalar overload of the selection operation. More...
 
template<typename Arg , typename = require_all_kernel_expressions_and_none_scalar_t<Arg>>
auto transpose (Arg &&a)
 Transposes a kernel generator expression. More...
 
template<typename T >
std::string type_str ()
 Determines a string name of a type. More...
 
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. More...
 
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. More...
 
const matrix_cl_view either (const matrix_cl_view left_view, const matrix_cl_view right_view)
 
const matrix_cl_view both (const matrix_cl_view left_view, const matrix_cl_view right_view)
 
bool contains_nonzero (const matrix_cl_view view, const matrix_cl_view part)
 
const matrix_cl_view transpose (const matrix_cl_view view)
 
const matrix_cl_view invert (const matrix_cl_view view)
 
matrix_cl_view from_eigen_uplo_type (Eigen::UpLoType eigen_type)
 
int either (int left_view, int right_view)
 
int both (int left_view, int right_view)
 
bool contains_nonzero (int view, int part)
 
template<typename T , typename = require_arithmetic_t<T>>
matrix_cl< T > multiply_transpose (const matrix_cl< T > &A)
 
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. More...
 
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. More...
 
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)
 
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)
 
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)
 
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)
 
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)
 
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)
 
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)
 
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)
 
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)
 
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)
 
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)
 
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). More...
 
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)
 
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)
 
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)
 
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)
 
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)
 
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)
 
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. More...
 
template<typename T_x , typename = require_nonscalar_prim_or_rev_kernel_expression_t<T_x>>
auto col (T_x &&x, size_t j)
 
template<typename T_x , require_nonscalar_prim_or_rev_kernel_expression_t< T_x > * = nullptr>
int cols (const T_x &x)
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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)
 
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)
 
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. More...
 
template<typename T_a , typename = require_all_kernel_expressions_and_none_scalar_t<T_a>>
auto divide (T_a &&a, double d)
 
template<typename T1 , typename T2 , typename = require_all_arithmetic_t<T1, T2>>
void divide_columns (matrix_cl< T1 > &A, const matrix_cl< T2 > &B)
 
template<typename T1 , typename T2 , typename = require_all_arithmetic_t<T1, T2>>
void divide_columns (matrix_cl< T1 > &A, const T2 &divisor)
 
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. More...
 
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. More...
 
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)
 
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)
 
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)
 
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)
 
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)
 
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)
 
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)
 
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)
 
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)
 
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)
 
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)
 
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)
 
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)
 
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)
 
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)
 
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)
 
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)
 
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)
 
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)
 
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)
 
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)
 
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)
 
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)
 
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)
 
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)
 
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)
 
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)
 
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)
 
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)
 
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)
 
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)
 
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. More...
 
template<typename T_x , require_matrix_cl_t< T_x > * = nullptr>
auto identity_matrix (int K)
 Return a square identity matrix. More...
 
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. More...
 
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)
 
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. More...
 
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)
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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)
 
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)
 
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)
 
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)
 
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)
 
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)
 
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)
 
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)
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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)
 
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)
 
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. More...
 
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. More...
 
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. More...
 
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)
 
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)
 
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)
 
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)
 
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)
 
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)
 
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)
 
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)
 
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)
 
template<typename T , require_nonscalar_prim_or_rev_kernel_expression_t< T > * = nullptr>
size_t num_elements (const T &m)
 Returns the number of the elements of a matrix_cl or var_value<matrix_cl<T>>. More...
 
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. More...
 
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. More...
 
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)
 
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)
 
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)
 
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)
 
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)
 
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)
 
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)
 
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)
 
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)
 
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)
 
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)
 
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)
 
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)
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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]. More...
 
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)
 
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)
 
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)
 
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)
 
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)
 
template<typename T , require_matrix_cl_t< T > * = nullptr>
auto rep_matrix (const value_type_t< T > &x, int n, int m)
 
template<typename T , require_arithmetic_t< T > * = nullptr>
auto rep_matrix (const matrix_cl< T > &x, int m)
 
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)
 
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)
 
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. More...
 
template<typename T_x , typename = require_nonscalar_prim_or_rev_kernel_expression_t<T_x>>
auto row (T_x &&x, size_t j)
 
template<typename T_x , require_nonscalar_prim_or_rev_kernel_expression_t< T_x > * = nullptr>
int rows (const T_x &x)
 
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. More...
 
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. More...
 
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)
 
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. More...
 
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. More...
 
template<typename T , require_all_kernel_expressions_and_none_scalar_t< T > * = nullptr>
auto sign (const T &x)
 Returns signs of the arguments. More...
 
template<typename T , require_nonscalar_prim_or_rev_kernel_expression_t< T > * = nullptr>
size_t size (const T &m)
 Returns the size (number of the elements) of a matrix_cl or var_value<matrix_cl<T>>. More...
 
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)
 
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)
 
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)
 
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)
 
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)
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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)
 
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)
 
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)
 
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)
 
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)
 
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). More...
 
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). More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
template<typename T_x , require_nonscalar_prim_or_rev_kernel_expression_t< T_x > * = nullptr>
auto to_array_1d (T_x &&x)
 
template<typename T_x , require_nonscalar_prim_or_rev_kernel_expression_t< T_x > * = nullptr>
T_x to_array_2d (T_x &&x)
 
template<typename T_x , require_nonscalar_prim_or_rev_kernel_expression_t< T_x > * = nullptr>
T_x to_matrix (T_x &&x)
 
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. More...
 
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. More...
 
template<typename T_x , require_nonscalar_prim_or_rev_kernel_expression_t< T_x > * = nullptr>
auto to_row_vector (T_x &&x)
 
template<typename T_x , require_nonscalar_prim_or_rev_kernel_expression_t< T_x > * = nullptr>
auto to_vector (T_x &&x)
 
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. More...
 
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. More...
 
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. More...
 
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)
 
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)
 
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)
 
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)
 
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. More...
 
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. More...
 
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. More...
 
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)
 
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)
 
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)
 
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)
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
template<typename... T_results>
adjoint_results_cl< T_results... > adjoint_results (T_results &&... results)
 Deduces types for constructing adjoint_results_cl object. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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). More...
 
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>>. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
template<typename T >
var_value< matrix_cl< value_type_t< T > > > to_matrix_cl (const var_value< T > &a)
 
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)
 
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)
 
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)
 
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)
 
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)
 
template<typename T , require_all_kernel_expressions_t< T > * = nullptr>
auto from_matrix_cl (const var_value< T > &src)
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
var_value< matrix_cl< double > > digamma (const var_value< matrix_cl< double >> &A)
 Returns the elementwise digamma() of a var_value<matrix_cl<double>>. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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>>. More...
 
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>>. More...
 
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>>. More...
 
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>>. More...
 
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>>. More...
 
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>>. More...
 
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). More...
 
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>>. More...
 
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. More...
 
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. More...
 
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). More...
 
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. More...
 
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>>. More...
 
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>>. More...
 
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>>. More...
 
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>>. More...
 
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>>. More...
 
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>>. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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>>. More...
 
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. More...
 
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>>. More...
 
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>>. More...
 
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>>. More...
 
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>>. More...
 
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>>. More...
 
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>>. More...
 
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>>. More...
 
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>>. More...
 
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. More...
 
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>>. More...
 
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. More...
 
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. More...
 
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. More...
 
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>>. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
template<typename T , require_var_vt< is_kernel_expression_and_not_scalar, T > * = nullptr>
operator+ (T &&M)
 Returns the unary plus of the input. More...
 
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>>. More...
 
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>>. More...
 
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. More...
 
template<typename T , require_all_kernel_expressions_and_none_scalar_t< T > * = nullptr>
var prod (const var_value< T > &x)
 Returns the prod of the coefficients of the specified matrix on the OpenCL device. More...
 
template<typename T_ret , require_var_vt< is_matrix_cl, T_ret > * = nullptr>
var_value< matrix_cl< double > > rep_matrix (const var &A, int n, int m)
 
template<typename T , require_all_kernel_expressions_and_none_scalar_t< T > * = nullptr>
var_value< matrix_cl< double > > rep_matrix (const var_value< T > &A, int m)
 
template<typename T , require_all_nonscalar_prim_or_rev_kernel_expression_t< T > * = nullptr, require_any_var_t< T > * = nullptr>
auto reverse (const T &m)
 Return reversed view into the specified vector or row vector. More...
 
template<typename T , require_all_kernel_expressions_and_none_scalar_t< T > * = nullptr>
var_value< matrix_cl< double > > round (const var_value< T > &A)
 Returns the elementwise round() of the input var_value<matrix_cl<double>>. More...
 
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 > > rows_dot_product (T1 &&v1, T2 &&v2)
 Returns the dot product of rows of the specified matrices. More...
 
template<typename T , require_all_kernel_expressions_and_none_scalar_t< T > * = nullptr>
var_value< matrix_cl< double > > rows_dot_self (const var_value< T > &v)
 Returns the dot product of each row of a matrix with itself. More...
 
template<typename T , require_all_kernel_expressions_and_none_scalar_t< T > * = nullptr>
var sd (const var_value< T > &A)
 Return the sample standard deviation of the var_value matrix. More...
 
template<typename T , require_all_kernel_expressions_and_none_scalar_t< T > * = nullptr>
var_value< matrix_cl< double > > sin (const var_value< T > &A)
 Returns the elementwise cos() of a var_value<matrix_cl<double>> in radians. More...
 
template<typename T , require_all_kernel_expressions_and_none_scalar_t< T > * = nullptr>
var_value< matrix_cl< double > > sinh (const var_value< T > &A)
 Returns the elementwise cos() of a var_value<matrix_cl<double>> in radians. More...
 
template<typename T , require_all_kernel_expressions_and_none_scalar_t< T > * = nullptr>
var_value< matrix_cl< double > > softmax (const var_value< T > &A)
 Returns softmax of given argument. More...
 
template<typename T , require_all_kernel_expressions_and_none_scalar_t< T > * = nullptr>
var_value< matrix_cl< double > > sqrt (const var_value< T > &A)
 Returns the elementwise sqrt() of a var_value<matrix_cl<double>>. More...
 
template<typename T , require_all_kernel_expressions_and_none_scalar_t< T > * = nullptr>
var_value< matrix_cl< double > > square (const var_value< T > &A)
 Returns the elementwise square() of a var_value<matrix_cl<double>>. More...
 
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< double > squared_distance (T_a &&a, T_b &&b)
 Returns the squared distance. More...
 
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 subtract (T_a &&a, T_b &&b)
 Subtraction of two reverse mode matrices and/or kernel generator expressions. More...
 
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)
 Subtraction of two reverse mode matrices and/or kernel generator expressions. More...
 
template<typename T , require_all_kernel_expressions_and_none_scalar_t< T > * = nullptr>
var sum (const var_value< T > &x)
 Returns the sum of the coefficients of the specified matrix on the OpenCL device. More...
 
template<typename T , require_all_kernel_expressions_and_none_scalar_t< T > * = nullptr>
var_value< matrix_cl< double > > symmetrize_from_lower_tri (const var_value< T > &A)
 Return a symmetric matrix using elements from the upper triangular part of the input matrix. More...
 
template<typename T , require_all_kernel_expressions_and_none_scalar_t< T > * = nullptr>
var_value< matrix_cl< double > > symmetrize_from_upper_tri (const var_value< T > &A)
 Return a symmetric matrix using elements from the upper triangular part of the input matrix. More...
 
template<typename T , require_all_kernel_expressions_and_none_scalar_t< T > * = nullptr>
var_value< matrix_cl< double > > tan (const var_value< T > &A)
 Returns the elementwise tan() of a var_value<matrix_cl<double>> in radians. More...
 
template<typename T , require_all_kernel_expressions_and_none_scalar_t< T > * = nullptr>
var_value< matrix_cl< double > > tanh (const var_value< T > &A)
 Returns the elementwise tanh() of a var_value<matrix_cl<double>> in radians. More...
 
template<typename T , require_all_kernel_expressions_and_none_scalar_t< T > * = nullptr>
var_value< matrix_cl< double > > tcrossprod (const var_value< T > &M)
 Returns the result of post-multiplying a matrix by its own transpose. More...
 
template<typename T , require_all_kernel_expressions_and_none_scalar_t< T > * = nullptr>
var_value< matrix_cl< double > > tgamma (const var_value< T > &A)
 Returns the elementwise tgamma() of a var_value<matrix_cl<double>>. More...
 
template<typename T , require_matrix_cl_t< T > * = nullptr>
arena_t< T > to_arena (const T &a)
 Converts given argument into a type that either has any dynamic allocation on AD stack or schedules its destructor to be called when AD stack memory is recovered. More...
 
template<typename T_x , require_all_kernel_expressions_and_none_scalar_t< T_x > * = nullptr>
var_value< matrix_cl< double > > to_matrix (const var_value< 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. More...
 
template<typename T , require_all_kernel_expressions_and_none_scalar_t< T > * = nullptr>
var trace (const var_value< T > &x)
 Returns the trace (sum of diagonal) of the specified matrix on the OpenCL device. More...
 
template<typename T , require_all_kernel_expressions_and_none_scalar_t< T > * = nullptr>
auto transpose (const var_value< T > &M)
 Transposes a matrix. More...
 
template<typename T , require_all_kernel_expressions_and_none_scalar_t< T > * = nullptr>
var_value< matrix_cl< double > > trunc (const var_value< T > &A)
 Returns the elementwise trunc() of the input var_value<matrix_cl<double>>. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
template<typename T , require_all_kernel_expressions_and_none_scalar_t< T > * = nullptr>
var variance (const var_value< T > &A)
 Return the sample variance of the var_value matrix Raise domain error if size is not greater than zero. More...
 
template<bool need_eigenvectors = true>
void symmetric_eigensolver (const matrix_cl< double > &A, matrix_cl< double > &eigenvalues, matrix_cl< double > &eigenvectors)
 
template<typename T >
ref_type_for_opencl_t< T && > to_ref_for_opencl (T &&a)
 Converts given Eigen expression into one that can be directly copied to an OpenCL device to create matrix_cl. More...
 
template<matrix_cl_view matrix_view = matrix_cl_view::Entire, typename T , require_matrix_cl_st< std::is_floating_point, T > * = nullptr>
plain_type_t< T > tri_inverse (const T &A)
 
tbb::task_scheduler_init & init_threadpool_tbb (int n_threads=0)
 Initialize the Intel TBB threadpool and global scheduler through the tbb::task_scheduler_init object. More...
 
template<typename U , typename V , require_all_stan_scalar_t< U, V > * = nullptr>
complex_return_t< U, V > operator+ (const std::complex< U > &x, const std::complex< V > &y)
 Return the sum of the arguments. More...
 
template<typename U , typename V , require_all_stan_scalar_t< U, V > * = nullptr>
complex_return_t< U, V > operator+ (const std::complex< U > &x, const V &y)
 Return the sum of the arguments. More...
 
template<typename U , typename V , require_all_stan_scalar_t< U, V > * = nullptr>
complex_return_t< U, V > operator+ (const U &x, const std::complex< V > &y)
 Return the sum of the arguments. More...
 
template<typename U , typename V , require_all_stan_scalar_t< U, V > * = nullptr>
complex_return_t< U, V > operator/ (const std::complex< U > &x, const std::complex< V > &y)
 Return the quotient of the arguments. More...
 
template<typename U , typename V , require_all_stan_scalar_t< U, V > * = nullptr>
complex_return_t< U, V > operator/ (const std::complex< U > &x, const V &y)
 Return the quotient of the arguments. More...
 
template<typename U , typename V , require_all_stan_scalar_t< U, V > * = nullptr>
complex_return_t< U, V > operator/ (const U &x, const std::complex< V > &y)
 Return the quotient of the arguments. More...
 
template<typename U , typename V , typename = require_any_autodiff_t<U, V>>
bool operator== (const std::complex< U > &x, const std::complex< V > &y)
 Return true if the complex numbers have equal imaginary and complex parts. More...
 
template<typename U , typename V , typename = require_any_autodiff_t<U, V>>
bool operator== (const std::complex< U > &x, const V &y)
 Return true if the first argument's real part is equal to the second argument and the first argument's imaginary part is zero. More...
 
template<typename U , typename V , typename = require_any_autodiff_t<U, V>>
bool operator== (const U &x, const std::complex< V > &y)
 Return true if the first argument is equal to the real part of the second argument and the imaginary part of the second argument is zero. More...
 
template<typename U , require_autodiff_t< U > >
std::complex< U > operator- (const std::complex< U > &x)
 Return the negation of the argument. More...
 
template<typename U , typename V , require_all_stan_scalar_t< U, V > * = nullptr>
complex_return_t< U, V > operator* (const std::complex< U > &x, const std::complex< V > &y)
 Return the product of the arguments. More...
 
template<typename U , typename V , require_stan_scalar_t< V > * = nullptr>
complex_return_t< U, V > operator* (const std::complex< U > &x, const V &y)
 Return the product of the arguments. More...
 
template<typename U , typename V , require_stan_scalar_t< U > * = nullptr>
complex_return_t< U, V > operator* (const U &x, const std::complex< V > &y)
 Return the product of the arguments. More...
 
template<typename U , typename V , typename = require_any_autodiff_t<U, V>>
bool operator!= (const std::complex< U > &x, const std::complex< V > &y)
 Return true if the complex numbers have unequal imaginary or complex parts. More...
 
template<typename U , typename V , typename = require_any_autodiff_t<U, V>>
bool operator!= (const std::complex< U > &x, const V &y)
 Return true if the first argument's real part is unequal to the second argument or the first argument's imaginary part is unequal to zero. More...
 
template<typename U , typename V , typename = require_any_autodiff_t<U, V>>
bool operator!= (const U &x, const std::complex< V > &y)
 Return true if the first argument is unequal to the real part of the second argument or the imaginary part of the second argument is nonzero. More...
 
template<typename U , require_autodiff_t< U > >
std::complex< U > operator+ (const std::complex< U > &x)
 Return the argument. More...
 
template<typename U , typename V , require_all_stan_scalar_t< U, V > * = nullptr>
complex_return_t< U, V > operator- (const std::complex< U > &x, const std::complex< V > &y)
 Return the difference of the arguments. More...
 
template<typename U , typename V , require_all_stan_scalar_t< U, V > * = nullptr>
complex_return_t< U, V > operator- (const std::complex< U > &x, const V &y)
 Return the difference of the arguments. More...
 
template<typename U , typename V , require_all_stan_scalar_t< U, V > * = nullptr>
complex_return_t< U, V > operator- (const U &x, const std::complex< V > &y)
 Return the difference of the arguments. More...
 
template<typename T_a1 , typename T_a2 , typename T_b1 , typename T_z >
void check_2F1_converges (const char *function, const T_a1 &a1, const T_a2 &a2, const T_b1 &b1, const T_z &z)
 Check if the hypergeometric function (2F1) called with supplied arguments will converge, assuming arguments are finite values. More...
 
template<typename T_a1 , typename T_a2 , typename T_a3 , typename T_b1 , typename T_b2 , typename T_z >
void check_3F2_converges (const char *function, const T_a1 &a1, const T_a2 &a2, const T_a3 &a3, const T_b1 &b1, const T_b2 &b2, const T_z &z)
 Check if the hypergeometric function (3F2) called with supplied arguments will converge, assuming arguments are finite values. More...
 
template<typename T_y , typename T_low , typename T_high >
void check_bounded (const char *function, const char *name, const T_y &y, const T_low &low, const T_high &high)
 Check if the value is between the low and high values, inclusively. More...
 
template<typename Mat , require_matrix_t< Mat > * = nullptr>
void check_cholesky_factor (const char *function, const char *name, const Mat &y)
 Throw an exception if the specified matrix is not a valid Cholesky factor. More...
 
template<typename StdVec , require_std_vector_t< StdVec > * = nullptr>
void check_cholesky_factor (const char *function, const char *name, const StdVec &y)
 Throw an exception if the specified matrix is not a valid Cholesky factor. More...
 
template<typename Mat , require_matrix_t< Mat > * = nullptr>
void check_cholesky_factor_corr (const char *function, const char *name, const Mat &y)
 Throw an exception if the specified matrix is not a valid Cholesky factor of a correlation matrix. More...
 
template<typename StdVec , require_std_vector_t< StdVec > * = nullptr>
void check_cholesky_factor_corr (const char *function, const char *name, const StdVec &y)
 Throw an exception if the specified matrix is not a valid Cholesky factor of a correlation matrix. More...
 
template<typename T_y , require_any_t< is_matrix< T_y >, is_prim_or_rev_kernel_expression< T_y >> * = nullptr>
void check_column_index (const char *function, const char *name, const T_y &y, size_t i)
 Check if the specified index is a valid column of the matrix. More...
 
template<typename T >
void check_consistent_size (const char *function, const char *name, const T &x, size_t expected_size)
 Check if x is consistent with size expected_size. More...
 
void check_consistent_sizes (const char *)
 Trivial no input case, this function is a no-op. More...
 
template<typename T1 >
void check_consistent_sizes (const char *, const char *, const T1 &)
 Base case of recursion, this function is a no-op. More...
 
template<typename T1 , typename T2 , typename... Ts>
void check_consistent_sizes (const char *function, const char *name1, const T1 &x1, const char *name2, const T2 &x2, const Ts &... names_and_xs)
 Check that the inputs are of consistent size. More...
 
void check_consistent_sizes_mvt (const char *)
 Trivial no input case, this function is a no-op. More...
 
template<typename T1 >
void check_consistent_sizes_mvt (const char *, const char *, const T1 &)
 Base case of recursion, this function is a no-op. More...
 
template<typename T1 , typename T2 , typename... Ts>
void check_consistent_sizes_mvt (const char *function, const char *name1, const T1 &x1, const char *name2, const T2 &x2, const Ts &... names_and_xs)
 Check that the provided multivariate inputs are of consistent size with each other. More...
 
template<typename Mat , require_matrix_t< Mat > * = nullptr>
void check_corr_matrix (const char *function, const char *name, const Mat &y)
 Throw an exception if the specified matrix is not a valid correlation matrix. More...
 
template<typename StdVec , require_std_vector_t< StdVec > * = nullptr>
void check_corr_matrix (const char *function, const char *name, const StdVec &y)
 Throw an exception if the specified matrix is not a valid correlation matrix. More...
 
template<typename Mat , require_matrix_t< Mat > * = nullptr>
void check_cov_matrix (const char *function, const char *name, const Mat &y)
 Throw an exception if the specified matrix is not a valid covariance matrix. More...
 
template<typename StdVec , require_std_vector_t< StdVec > * = nullptr>
void check_cov_matrix (const char *function, const char *name, const StdVec &y)
 Throw an exception if the specified matrix is not a valid covariance matrix. More...
 
template<typename T_y >
void check_finite (const char *function, const char *name, const T_y &y)
 Return true if all values in y are finite. More...
 
std::array< std::string, 2 > cvodes_flag_msg (int flag)
 Map cvodes error flag to acutally error msg. More...
 
void cvodes_check (int flag, const char *func_name)
 Throws a std::runtime_error exception when a Sundial function fails (i.e. More...
 
std::array< std::string, 2 > idas_flag_msg (int flag)
 
void idas_check (int flag, const char *func_name)
 
void kinsol_check (int flag, const char *func_name)
 Throws an exception message when the functions in KINSOL fails. More...
 
void kinsol_check (int flag, const char *func_name, long int max_num_steps)
 Throws an exception message when the KINSol() call fails. More...
 
template<typename T_y , typename T_low , require_all_stan_scalar_t< T_y, T_low > * = nullptr, typename... Idxs>
void check_greater (const char *function, const char *name, const T_y &y, const T_low &low, Idxs... idxs)
 Throw an exception if y is not strictly greater than low. More...
 
template<typename T_y , typename T_low , require_stan_scalar_t< T_y > * = nullptr, require_vector_t< T_low > * = nullptr, require_not_std_vector_vt< is_container_or_var_matrix, T_low > * = nullptr, typename... Idxs>
void check_greater (const char *functio