Function gradients via reverse-mode automatic differentiation. More...

Classes
class	vari
	The variable implementation base class. More...

class	var
	Independent (input) and dependent (output) variables for gradients. More...

class	partials_vari

struct	OperandsAndPartials
	A variable implementation that stores operands and derivatives with respect to the variable. More...

class	chainable
	Abstract base class for variable implementations that handles memory management and applying the chain rule. More...

class	op_ddv_vari

class	op_dv_vari

class	op_dvd_vari

class	op_dvv_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	precomp_v_vari

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...

Typedefs
typedef Eigen::Matrix< double, Eigen::Dynamic, Eigen::Dynamic > ::size_type	size_type

typedef Eigen::Matrix< var, Eigen::Dynamic, Eigen::Dynamic >	matrix_v
	The type of a matrix holding `stan::agrad::var` values.

typedef Eigen::Matrix< var, Eigen::Dynamic, 1 >	vector_v
	The type of a (column) vector holding `stan::agrad::var` values.

typedef Eigen::Matrix< var, 1, Eigen::Dynamic >	row_vector_v
	The type of a row vector holding `stan::agrad::var` values.

Functions
bool	operator== (const var &a, const var &b)
	Equality operator comparing two variables' values (C++).

bool	operator== (const var &a, const double &b)
	Equality operator comparing a variable's value and a double (C++).

bool	operator== (const double &a, const var &b)
	Equality operator comparing a scalar and a variable's value (C++).

bool	operator!= (const var &a, const var &b)
	Inequality operator comparing two variables' values (C++).

bool	operator!= (const var &a, const double &b)
	Inequality operator comparing a variable's value and a double (C++).

bool	operator!= (const double &a, const var &b)
	Inequality operator comparing a double and a variable's value (C++).

bool	operator< (const var &a, const var &b)
	Less than operator comparing variables' values (C++).

bool	operator< (const var &a, const double &b)
	Less than operator comparing variable's value and a double (C++).

bool	operator< (const double &a, const var &b)
	Less than operator comparing a double and variable's value (C++).

bool	operator> (const var &a, const var &b)
	Greater than operator comparing variables' values (C++).

bool	operator> (const var &a, const double &b)
	Greater than operator comparing variable's value and double (C++).

bool	operator> (const double &a, const var &b)
	Greater than operator comparing a double and a variable's value (C++).

bool	operator<= (const var &a, const var &b)
	Less than or equal operator comparing two variables' values (C++).

bool	operator<= (const var &a, const double &b)
	Less than or equal operator comparing a variable's value and a scalar (C++).

bool	operator<= (const double &a, const var &b)
	Less than or equal operator comparing a double and variable's value (C++).

bool	operator>= (const var &a, const var &b)
	Greater than or equal operator comparing two variables' values (C++).

bool	operator>= (const var &a, const double &b)
	Greater than or equal operator comparing variable's value and double (C++).

bool	operator>= (const double &a, const var &b)
	Greater than or equal operator comparing double and variable's value (C++).

bool	operator! (const var &a)
	Prefix logical negation for the value of variables (C++).

var	operator+ (const var &a)
	Unary plus operator for variables (C++).

var	operator- (const var &a)
	Unary negation operator for variables (C++).

var	operator+ (const var &a, const var &b)
	Addition operator for variables (C++).

var	operator+ (const var &a, const double &b)
	Addition operator for variable and scalar (C++).

var	operator+ (const double &a, const var &b)
	Addition operator for scalar and variable (C++).

var	operator- (const var &a, const var &b)
	Subtraction operator for variables (C++).

var	operator- (const var &a, const double &b)
	Subtraction operator for variable and scalar (C++).

var	operator- (const double &a, const var &b)
	Subtraction operator for scalar and variable (C++).

var	operator* (const var &a, const var &b)
	Multiplication operator for two variables (C++).

var	operator* (const var &a, const double &b)
	Multiplication operator for a variable and a scalar (C++).

var	operator* (const double &a, const var &b)
	Multiplication operator for a scalar and a variable (C++).

var	operator/ (const var &a, const var &b)
	Division operator for two variables (C++).

var	operator/ (const var &a, const double &b)
	Division operator for dividing a variable by a scalar (C++).

var	operator/ (const double &a, const var &b)
	Division operator for dividing a scalar by a variable (C++).

var &	operator++ (var &a)
	Prefix increment operator for variables (C++).

var	operator++ (var &a, int)
	Postfix increment operator for variables (C++).

var &	operator-- (var &a)
	Prefix decrement operator for variables (C++).

var	operator-- (var &a, int)
	Postfix decrement operator for variables (C++).

var	exp (const var &a)
	Return the exponentiation of the specified variable (cmath).

var	log (const var &a)
	Return the natural log of the specified variable (cmath).

var	log10 (const var &a)
	Return the base 10 log of the specified variable (cmath).

var	sqrt (const var &a)
	Return the square root of the specified variable (cmath).

var	pow (const var &base, const var &exponent)
	Return the base raised to the power of the exponent (cmath).

var	pow (const var &base, const double &exponent)
	Return the base variable raised to the power of the exponent scalar (cmath).

var	pow (const double &base, const var &exponent)
	Return the base scalar raised to the power of the exponent variable (cmath).

var	cos (const var &a)
	Return the cosine of a radian-scaled variable (cmath).

var	sin (const var &a)
	Return the sine of a radian-scaled variable (cmath).

var	tan (const var &a)
	Return the tangent of a radian-scaled variable (cmath).

var	acos (const var &a)
	Return the principal value of the arc cosine of a variable, in radians (cmath).

var	asin (const var &a)
	Return the principal value of the arc sine, in radians, of the specified variable (cmath).

var	atan (const var &a)
	Return the principal value of the arc tangent, in radians, of the specified variable (cmath).

var	atan2 (const var &a, const var &b)
	Return the principal value of the arc tangent, in radians, of the first variable divided by the second (cmath).

var	atan2 (const var &a, const double &b)
	Return the principal value of the arc tangent, in radians, of the first variable divided by the second scalar (cmath).

var	atan2 (const double &a, const var &b)
	Return the principal value of the arc tangent, in radians, of the first scalar divided by the second variable (cmath).

var	cosh (const var &a)
	Return the hyperbolic cosine of the specified variable (cmath).

var	sinh (const var &a)
	Return the hyperbolic sine of the specified variable (cmath).

var	tanh (const var &a)
	Return the hyperbolic tangent of the specified variable (cmath).

var	fabs (const var &a)
	Return the absolute value of the variable (cmath).

var	floor (const var &a)
	Return the floor of the specified variable (cmath).

var	ceil (const var &a)
	Return the ceiling of the specified variable (cmath).

var	fmod (const var &a, const var &b)
	Return the floating point remainder after dividing the first variable by the second (cmath).

var	fmod (const var &a, const double &b)
	Return the floating point remainder after dividing the the first variable by the second scalar (cmath).

var	fmod (const double &a, const var &b)
	Return the floating point remainder after dividing the first scalar by the second variable (cmath).

var	abs (const var &a)
	Return the absolute value of the variable (std).

template<class F >
double	hessian (const F &f, const std::vector< double > &x, const std::vector< double > &v, std::vector< double > &Hv)

var	acosh (const stan::agrad::var &a)
	The inverse hyperbolic cosine function for variables (C99).

int	as_bool (const agrad::var &v)
	Return 1 if the argument is unequal to zero and 0 otherwise.

var	asinh (const stan::agrad::var &a)
	The inverse hyperbolic sine function for variables (C99).

var	atan2 (const var &a, const double b)
	Return the principal value of the arc tangent, in radians, of the first variable divided by the second scalar (cmath).

var	atan2 (const double a, const var &b)
	Return the principal value of the arc tangent, in radians, of the first scalar divided by the second variable (cmath).

var	atanh (const stan::agrad::var &a)
	The inverse hyperbolic tangent function for variables (C99).

double	calculate_chain (const double &x, const double &val)

var	cbrt (const stan::agrad::var &a)
	Returns the cube root of the specified variable (C99).

static void	set_zero_all_adjoints ()
	Reset all adjoint values in the stack to zero.

static void	grad (chainable *vi)
	Compute the gradient for all variables starting from the specified root variable implementation.

var	erf (const stan::agrad::var &a)
	The error function for variables (C99).

var	erfc (const stan::agrad::var &a)
	The complementary error function for variables (C99).

template<typename T_result , class Policy >
bool	check_pos_definite (const char function, const Eigen::Matrix< var, Eigen::Dynamic, Eigen::Dynamic > &y, const char name, T_result *result, const Policy &)

var	exp2 (const stan::agrad::var &a)
	Exponentiation base 2 function for variables (C99).

var	expm1 (const stan::agrad::var &a)
	The exponentiation of the specified variable minus 1 (C99).

var	fdim (const stan::agrad::var &a, const stan::agrad::var &b)
	Return the positive difference between the first variable's the value and the second's (C99).

var	fdim (const double &a, const stan::agrad::var &b)
	Return the positive difference between the first value and the value of the second variable (C99).

var	fdim (const stan::agrad::var &a, const double &b)
	Return the positive difference between the first variable's value and the second value (C99).

var	fma (const stan::agrad::var &a, const stan::agrad::var &b, const stan::agrad::var &c)
	The fused multiply-add function for three variables (C99).

var	fma (const stan::agrad::var &a, const stan::agrad::var &b, const double &c)
	The fused multiply-add function for two variables and a value (C99).

var	fma (const stan::agrad::var &a, const double &b, const stan::agrad::var &c)
	The fused multiply-add function for a variable, value, and variable (C99).

var	fma (const stan::agrad::var &a, const double &b, const double &c)
	The fused multiply-add function for a variable and two values (C99).

var	fma (const double &a, const stan::agrad::var &b, const double &c)
	The fused multiply-add function for a value, variable, and value (C99).

var	fma (const double &a, const double &b, const stan::agrad::var &c)
	The fused multiply-add function for two values and a variable, and value (C99).

var	fma (const double &a, const stan::agrad::var &b, const stan::agrad::var &c)
	The fused multiply-add function for a value and two variables (C99).

var	fmax (const stan::agrad::var &a, const stan::agrad::var &b)
	Returns the maximum of the two variable arguments (C99).

var	fmax (const stan::agrad::var &a, const double &b)
	Returns the maximum of the variable and scalar, promoting the scalar to a variable if it is larger (C99).

var	fmax (const double &a, const stan::agrad::var &b)
	Returns the maximum of a scalar and variable, promoting the scalar to a variable if it is larger (C99).

var	fmin (const stan::agrad::var &a, const stan::agrad::var &b)
	Returns the minimum of the two variable arguments (C99).

var	fmin (const stan::agrad::var &a, const double &b)
	Returns the minimum of the variable and scalar, promoting the scalar to a variable if it is larger (C99).

var	fmin (const double &a, const stan::agrad::var &b)
	Returns the minimum of a scalar and variable, promoting the scalar to a variable if it is larger (C99).

var	fmod (const var &a, const double b)
	Return the floating point remainder after dividing the the first variable by the second scalar (cmath).

var	fmod (const double a, const var &b)
	Return the floating point remainder after dividing the first scalar by the second variable (cmath).

var	hypot (const stan::agrad::var &a, const stan::agrad::var &b)
	Returns the length of the hypoteneuse of a right triangle with sides of the specified lengths (C99).

var	hypot (const stan::agrad::var &a, const double &b)
	Returns the length of the hypoteneuse of a right triangle with sides of the specified lengths (C99).

var	hypot (const double &a, const stan::agrad::var &b)
	Returns the length of the hypoteneuse of a right triangle with sides of the specified lengths (C99).

var	ibeta (const var &a, const var &b, const var &x)
	The normalized incomplete beta function of a, b, and x.

var	if_else (bool c, const var &y_true, const var &y_false)
	If the specified condition is true, return the first variable, otherwise return the second variable.

var	if_else (bool c, double y_true, const var &y_false)
	If the specified condition is true, return a new variable constructed from the first scalar, otherwise return the second variable.

var	if_else (bool c, const var &y_true, const double y_false)
	If the specified condition is true, return the first variable, otherwise return a new variable constructed from the second scalar.

var	inv_cloglog (const stan::agrad::var &a)
	Return the inverse complementary log-log function applied specified variable (stan).

var	inv_logit (const stan::agrad::var &a)
	The inverse logit function for variables (stan).

template<typename T >
bool	is_uninitialized (T x)

bool	is_uninitialized (var x)

void	jacobian (std::vector< var > &dependents, std::vector< var > &independents, std::vector< std::vector< double > > &jacobian)
	Return the Jacobian of the function producing the specified dependent variables with respect to the specified independent variables.

var	lgamma (const stan::agrad::var &a)
	The log gamma function for variables (C99).

var	log1m (const stan::agrad::var &a)
	The log (1 - x) function for variables.

var	log1p (const stan::agrad::var &a)
	The log (1 + x) function for variables (C99).

var	log1p_exp (const stan::agrad::var &a)
	Return the log of 1 plus the exponential of the specified variable.

var	log2 (const stan::agrad::var &a)
	Returns the base 2 logarithm of the specified variable (C99).

var	log_loss (const int &y, const stan::agrad::var &y_hat)
	The log loss function for variables (stan).

var	log_sum_exp (const stan::agrad::var &a, const stan::agrad::var &b)
	Returns the log sum of exponentials.

var	log_sum_exp (const stan::agrad::var &a, const double &b)
	Returns the log sum of exponentials.

var	log_sum_exp (const double &a, const stan::agrad::var &b)
	Returns the log sum of exponentials.

var	log_sum_exp (const std::vector< var > &x)
	Returns the log sum of exponentials.

template<typename LHS , typename RHS >
void	assign (Eigen::Block< LHS > var, const RHS &val)

template<typename LHS , typename RHS >
void	assign (LHS &var, const RHS &val)

void	assign_to_var (stan::agrad::var &var, const double &val)

void	assign_to_var (stan::agrad::var &var, const stan::agrad::var &val)

void	assign_to_var (int &n_lhs, const int &n_rhs)

void	assign_to_var (double &n_lhs, const double &n_rhs)

template<typename LHS , typename RHS >
void	assign_to_var (std::vector< LHS > &x, const std::vector< RHS > &y)

template<typename LHS , typename RHS , int R, int C>
void	assign_to_var (Eigen::Matrix< LHS, R, C > &x, const Eigen::Matrix< RHS, R, C > &y)

template<typename LHS , typename RHS , int R, int C>
void	assign_to_var (Eigen::Block< LHS > &x, const Eigen::Matrix< RHS, R, C > &y)

matrix_v	crossprod (const matrix_v &M)
	Returns the result of pre-multiplying a matrix by its own transpose.

template<int R, int C>
var	determinant (const Eigen::Matrix< var, R, C > &m)

template<int R1, int C1, int R2, int C2>
var	squared_dist (const Eigen::Matrix< var, R1, C1 > &v1, const Eigen::Matrix< var, R2, C2 > &v2)

template<int R1, int C1, int R2, int C2>
var	squared_dist (const Eigen::Matrix< var, R1, C1 > &v1, const Eigen::Matrix< double, R2, C2 > &v2)

template<int R1, int C1, int R2, int C2>
var	squared_dist (const Eigen::Matrix< double, R1, C1 > &v1, const Eigen::Matrix< var, R2, C2 > &v2)

template<int R1, int C1, int R2, int C2>
var	dist (const Eigen::Matrix< var, R1, C1 > &v1, const Eigen::Matrix< var, R2, C2 > &v2)

template<int R1, int C1, int R2, int C2>
var	dist (const Eigen::Matrix< var, R1, C1 > &v1, const Eigen::Matrix< double, R2, C2 > &v2)

template<int R1, int C1, int R2, int C2>
var	dist (const Eigen::Matrix< double, R1, C1 > &v1, const Eigen::Matrix< var, R2, C2 > &v2)

double	divide (double x, double y)
	Return the division of the first scalar by the second scalar.

template<typename T1 , typename T2 >
var	divide (const T1 &v, const T2 &c)

template<typename T1 , typename T2 , int R, int C>
Eigen::Matrix< var, R, C >	divide (const Eigen::Matrix< T1, R, C > &v, const T2 &c)
	Return the division of the specified column vector by the specified scalar.

template<int R1, int C1, int R2, int C2>
var	dot_product (const Eigen::Matrix< var, R1, C1 > &v1, const Eigen::Matrix< var, R2, C2 > &v2)
	Returns the dot product.

template<int R1, int C1, int R2, int C2>
var	dot_product (const Eigen::Matrix< var, R1, C1 > &v1, const Eigen::Matrix< double, R2, C2 > &v2)
	Returns the dot product.

template<int R1, int C1, int R2, int C2>
var	dot_product (const Eigen::Matrix< double, R1, C1 > &v1, const Eigen::Matrix< var, R2, C2 > &v2)
	Returns the dot product.

var	dot_product (const var v1, const var v2, size_t length)
	Returns the dot product.

var	dot_product (const var v1, const double v2, size_t length)
	Returns the dot product.

var	dot_product (const double v1, const var v2, size_t length)
	Returns the dot product.

var	dot_product (const std::vector< var > &v1, const std::vector< var > &v2)
	Returns the dot product.

var	dot_product (const std::vector< var > &v1, const std::vector< double > &v2)
	Returns the dot product.

var	dot_product (const std::vector< double > &v1, const std::vector< var > &v2)
	Returns the dot product.

template<int R1, int C1, int R2, int C2>
Eigen::Matrix< var, 1, C1 >	columns_dot_product (const Eigen::Matrix< var, R1, C1 > &v1, const Eigen::Matrix< var, R2, C2 > &v2)

template<int R1, int C1, int R2, int C2>
Eigen::Matrix< var, 1, C1 >	columns_dot_product (const Eigen::Matrix< var, R1, C1 > &v1, const Eigen::Matrix< double, R2, C2 > &v2)

template<int R1, int C1, int R2, int C2>
Eigen::Matrix< var, 1, C1 >	columns_dot_product (const Eigen::Matrix< double, R1, C1 > &v1, const Eigen::Matrix< var, R2, C2 > &v2)

template<int R1, int C1, int R2, int C2>
Eigen::Matrix< var, R1, 1 >	rows_dot_product (const Eigen::Matrix< var, R1, C1 > &v1, const Eigen::Matrix< var, R2, C2 > &v2)

template<int R1, int C1, int R2, int C2>
Eigen::Matrix< var, R1, 1 >	rows_dot_product (const Eigen::Matrix< var, R1, C1 > &v1, const Eigen::Matrix< double, R2, C2 > &v2)

template<int R1, int C1, int R2, int C2>
Eigen::Matrix< var, R1, 1 >	rows_dot_product (const Eigen::Matrix< double, R1, C1 > &v1, const Eigen::Matrix< var, R2, C2 > &v2)

template<int R, int C>
var	dot_self (const Eigen::Matrix< var, R, C > &v)
	Returns the dot product of a vector with itself.

template<int R, int C>
Eigen::Matrix< var, 1, C >	columns_dot_self (const Eigen::Matrix< var, R, C > &x)
	Returns the dot product of each column of a matrix with itself.

template<typename T , typename S >
void	fill (T &x, const S &y)

template<typename T , int R, int C, typename S >
void	fill (Eigen::Matrix< T, R, C > &x, const S &y)

template<typename T , typename S >
void	fill (std::vector< T > &x, const S &y)

void	initialize_variable (var &variable, const var &value)
	Initialize variable to value.

template<int R, int C>
void	initialize_variable (Eigen::Matrix< var, R, C > &matrix, const var &value)
	Initialize every cell in the matrix to the specified value.

template<typename T >
void	initialize_variable (std::vector< T > &variables, const var &value)
	Initialize the variables in the standard vector recursively.

template<int R, int C>
var	log_determinant (const Eigen::Matrix< var, R, C > &m)

template<int R, int C>
var	log_determinant_spd (const Eigen::Matrix< var, R, C > &m)

template<int R1, int C1, int R2, int C2>
Eigen::Matrix< var, R1, C2 >	mdivide_left (const Eigen::Matrix< var, R1, C1 > &A, const Eigen::Matrix< var, R2, C2 > &b)

template<int R1, int C1, int R2, int C2>
Eigen::Matrix< var, R1, C2 >	mdivide_left (const Eigen::Matrix< var, R1, C1 > &A, const Eigen::Matrix< double, R2, C2 > &b)

template<int R1, int C1, int R2, int C2>
Eigen::Matrix< var, R1, C2 >	mdivide_left (const Eigen::Matrix< double, R1, C1 > &A, const Eigen::Matrix< var, R2, C2 > &b)

template<int R1, int C1, int R2, int C2>
Eigen::Matrix< var, R1, C2 >	mdivide_left_spd (const Eigen::Matrix< var, R1, C1 > &A, const Eigen::Matrix< var, R2, C2 > &b)

template<int R1, int C1, int R2, int C2>
Eigen::Matrix< var, R1, C2 >	mdivide_left_spd (const Eigen::Matrix< var, R1, C1 > &A, const Eigen::Matrix< double, R2, C2 > &b)

template<int R1, int C1, int R2, int C2>
Eigen::Matrix< var, R1, C2 >	mdivide_left_spd (const Eigen::Matrix< double, R1, C1 > &A, const Eigen::Matrix< var, R2, C2 > &b)

template<int TriView, int R1, int C1, int R2, int C2>
Eigen::Matrix< var, R1, C2 >	mdivide_left_tri (const Eigen::Matrix< var, R1, C1 > &A, const Eigen::Matrix< var, R2, C2 > &b)

template<int TriView, int R1, int C1, int R2, int C2>
Eigen::Matrix< var, R1, C2 >	mdivide_left_tri (const Eigen::Matrix< double, R1, C1 > &A, const Eigen::Matrix< var, R2, C2 > &b)

template<int TriView, int R1, int C1, int R2, int C2>
Eigen::Matrix< var, R1, C2 >	mdivide_left_tri (const Eigen::Matrix< var, R1, C1 > &A, const Eigen::Matrix< double, R2, C2 > &b)

template<typename T1 , typename T2 >
boost::math::tools::promote_args < T1, T2 >::type	multiply (const T1 &v, const T2 &c)
	Return the product of two scalars.

template<typename T1 , typename T2 , int R2, int C2>
Eigen::Matrix< var, R2, C2 >	multiply (const T1 &c, const Eigen::Matrix< T2, R2, C2 > &m)
	Return the product of scalar and matrix.

template<typename T1 , int R1, int C1, typename T2 >
Eigen::Matrix< var, R1, C1 >	multiply (const Eigen::Matrix< T1, R1, C1 > &m, const T2 &c)
	Return the product of scalar and matrix.

template<int R1, int C1, int R2, int C2>
Eigen::Matrix< var, R1, C2 >	multiply (const Eigen::Matrix< var, R1, C1 > &m1, const Eigen::Matrix< var, R2, C2 > &m2)
	Return the product of the specified matrices.

template<int R1, int C1, int R2, int C2>
Eigen::Matrix< var, R1, C2 >	multiply (const Eigen::Matrix< double, R1, C1 > &m1, const Eigen::Matrix< var, R2, C2 > &m2)
	Return the product of the specified matrices.

template<int R1, int C1, int R2, int C2>
Eigen::Matrix< var, R1, C2 >	multiply (const Eigen::Matrix< var, R1, C1 > &m1, const Eigen::Matrix< double, R2, C2 > &m2)
	Return the product of the specified matrices.

template<int C1, int R2>
var	multiply (const Eigen::Matrix< var, 1, C1 > &rv, const Eigen::Matrix< var, R2, 1 > &v)
	Return the scalar product of the specified row vector and specified column vector.

template<int C1, int R2>
var	multiply (const Eigen::Matrix< double, 1, C1 > &rv, const Eigen::Matrix< var, R2, 1 > &v)
	Return the scalar product of the specified row vector and specified column vector.

template<int C1, int R2>
var	multiply (const Eigen::Matrix< var, 1, C1 > &rv, const Eigen::Matrix< double, R2, 1 > &v)
	Return the scalar product of the specified row vector and specified column vector.

matrix_v	multiply_lower_tri_self_transpose (const matrix_v &L)

void	stan_print (std::ostream *o, const var &x)

template<int R, int C>
var	sum (const Eigen::Matrix< var, R, C > &m)
	Returns the sum of the coefficients of the specified matrix, column vector or row vector.

matrix_v	tcrossprod (const matrix_v &M)
	Returns the result of post-multiplying a matrix by its own transpose.

var	to_var (const double &x)
	Converts argument to an automatic differentiation variable.

var	to_var (const var &x)
	Converts argument to an automatic differentiation variable.

matrix_v	to_var (const stan::math::matrix_d &m)
	Converts argument to an automatic differentiation variable.

matrix_v	to_var (const matrix_v &m)
	Converts argument to an automatic differentiation variable.

vector_v	to_var (const stan::math::vector_d &v)
	Converts argument to an automatic differentiation variable.

vector_v	to_var (const vector_v &v)
	Converts argument to an automatic differentiation variable.

row_vector_v	to_var (const stan::math::row_vector_d &rv)
	Converts argument to an automatic differentiation variable.

row_vector_v	to_var (const row_vector_v &rv)
	Converts argument to an automatic differentiation variable.

var	multiply_log (const var &a, const var &b)
	Return the value of a*log(b).

var	multiply_log (const var &a, const double b)
	Return the value of a*log(b).

var	multiply_log (const double a, const var &b)
	Return the value of a*log(b).

var	operator+ (const var &a, const double b)
	Addition operator for variable and scalar (C++).

var	operator+ (const double a, const var &b)
	Addition operator for scalar and variable (C++).

var	operator/ (const var &a, const double b)
	Division operator for dividing a variable by a scalar (C++).

var	operator/ (const double a, const var &b)
	Division operator for dividing a scalar by a variable (C++).

bool	operator== (const var &a, const double b)
	Equality operator comparing a variable's value and a double (C++).

bool	operator== (const double a, const var &b)
	Equality operator comparing a scalar and a variable's value (C++).

bool	operator> (const var &a, const double b)
	Greater than operator comparing variable's value and double (C++).

bool	operator> (const double a, const var &b)
	Greater than operator comparing a double and a variable's value (C++).

bool	operator>= (const var &a, const double b)
	Greater than or equal operator comparing variable's value and double (C++).

bool	operator>= (const double a, const var &b)
	Greater than or equal operator comparing double and variable's value (C++).

bool	operator< (const var &a, const double b)
	Less than operator comparing variable's value and a double (C++).

bool	operator< (const double a, const var &b)
	Less than operator comparing a double and variable's value (C++).

bool	operator<= (const var &a, const double b)
	Less than or equal operator comparing a variable's value and a scalar (C++).

bool	operator<= (const double a, const var &b)
	Less than or equal operator comparing a double and variable's value (C++).

var	operator* (const var &a, const double b)
	Multiplication operator for a variable and a scalar (C++).

var	operator* (const double a, const var &b)
	Multiplication operator for a scalar and a variable (C++).

bool	operator!= (const var &a, const double b)
	Inequality operator comparing a variable's value and a double (C++).

bool	operator!= (const double a, const var &b)
	Inequality operator comparing a double and a variable's value (C++).

var	operator- (const var &a, const double b)
	Subtraction operator for variable and scalar (C++).

var	operator- (const double a, const var &b)
	Subtraction operator for scalar and variable (C++).

var	owens_t (const var &h, const var &a)
	The Owen's T function of h and a.

var	owens_t (const var &h, const double &a)
	The Owen's T function of h and a.

var	owens_t (const double &h, const var &a)
	The Owen's T function of h and a.

var	Phi (const stan::agrad::var &a)
	The unit normal cumulative density function for variables (stan).

var	Phi_approx (const stan::agrad::var &a)
	Approximation of the unit normal CDF for variables (stan).

var	pow (const var &base, const double exponent)
	Return the base variable raised to the power of the exponent scalar (cmath).

var	pow (const double base, const var &exponent)
	Return the base scalar raised to the power of the exponent variable (cmath).

void	print_stack (std::ostream &o)
	Prints the auto-dif variable stack.

var	round (const stan::agrad::var &a)
	Returns the rounded form of the specified variable (C99).

var	square (const var &x)
	Return the square of the input variable.

var	step (const stan::agrad::var &a)
	Return the step, or heaviside, function applied to the specified variable (stan).

var	tgamma (const stan::agrad::var &a)
	Return the Gamma function applied to the specified variable (C99).

var	trunc (const stan::agrad::var &a)
	Returns the truncatation of the specified variable (C99).

double	value_of (const agrad::var &v)
	Return the value of the specified variable.

static void	recover_memory ()

static void	grad (chainable *vi)

static void	recover_memory ()
	Recover memory used for all variables for reuse.

static void	free_memory ()
	Return all memory used for gradients back to the system.

Variables
std::vector< chainable * >	var_stack_

std::vector< chainable * >	var_nochain_stack_

std::vector< chainable_alloc * >	var_alloc_stack_

memory::stack_alloc	memalloc_

Detailed Description

Function gradients via reverse-mode automatic differentiation.

Typedef Documentation

typedef Eigen::Matrix<var,Eigen::Dynamic,Eigen::Dynamic> stan::agrad::matrix_v

The type of a matrix holding stan::agrad::var values.

Definition at line 17 of file typedefs.hpp.

typedef Eigen::Matrix<var,1,Eigen::Dynamic> stan::agrad::row_vector_v

The type of a row vector holding stan::agrad::var values.

Definition at line 33 of file typedefs.hpp.

typedef Eigen::Matrix<double,Eigen::Dynamic,Eigen::Dynamic>::size_type stan::agrad::size_type

Definition at line 9 of file typedefs.hpp.

typedef Eigen::Matrix<var,Eigen::Dynamic,1> stan::agrad::vector_v

The type of a (column) vector holding stan::agrad::var values.

Definition at line 25 of file typedefs.hpp.

Function Documentation

var stan::agrad::abs ( const var & a )

inline

Return the absolute value of the variable (std).

The value at the undifferentiable point 0 is conveniently set 0, so that

$\frac{d}{dx}|x| = \mbox{sgn}(x)$ .

The function fabs() provides identical behavior, with abs() defined in stdlib.h and fabs() defined in cmath.

Parameters

a	Variable input.

Returns: Absolute value of variable.

Definition at line 1998 of file agrad_thread_safe.hpp.

var stan::agrad::acos ( const var & a )

inline

Return the principal value of the arc cosine of a variable, in radians (cmath).

The derivative is defined by

$\frac{d}{dx} \arccos x = \frac{-1}{\sqrt{1 - x^2}}$ .

Parameters

a	Variable in range [-1,1].

Returns: Arc cosine of variable, in radians.

Definition at line 1725 of file agrad_thread_safe.hpp.

var stan::agrad::acosh ( const stan::agrad::var & a )

inline

The inverse hyperbolic cosine function for variables (C99).

For non-variable function, see boost::math::acosh().

The derivative is defined by

$\frac{d}{dx} \mbox{acosh}(x) = \frac{x}{x^2 - 1}$ .

Parameters

a	The variable.

Returns: Inverse hyperbolic cosine of the variable.

Definition at line 36 of file acosh.hpp.

int stan::agrad::as_bool ( const agrad::var & v )

inline

Return 1 if the argument is unequal to zero and 0 otherwise.

Parameters

x Value.

Returns: 1 if argument is equal to zero and 0 otherwise.

Definition at line 15 of file as_bool.hpp.

var stan::agrad::asin ( const var & a )

inline

Return the principal value of the arc sine, in radians, of the specified variable (cmath).

The derivative is defined by

$\frac{d}{dx} \arcsin x = \frac{1}{\sqrt{1 - x^2}}$ .

Parameters

a	Variable in range [-1,1].

Returns: Arc sine of variable, in radians.

Definition at line 1740 of file agrad_thread_safe.hpp.

var stan::agrad::asinh ( const stan::agrad::var & a )

inline

The inverse hyperbolic sine function for variables (C99).

For non-variable function, see boost::math::asinh().

The derivative is defined by

$\frac{d}{dx} \mbox{asinh}(x) = \frac{x}{x^2 + 1}$ .

Parameters

a	The variable.

Returns: Inverse hyperbolic sine of the variable.

Definition at line 36 of file asinh.hpp.

template<typename LHS , typename RHS >

void stan::agrad::assign	(	Eigen::Block< LHS >	var,
		const RHS &	val
	)

inline

Definition at line 47 of file assign.hpp.

template<typename LHS , typename RHS >

void stan::agrad::assign	(	LHS &	var,
		const RHS &	val
	)

inline

Definition at line 52 of file assign.hpp.

void stan::agrad::assign_to_var	(	stan::agrad::var &	var,
		const double &	val
	)

inline

Definition at line 17 of file assign_to_var.hpp.

void stan::agrad::assign_to_var	(	stan::agrad::var &	var,
		const stan::agrad::var &	val
	)

inline

Definition at line 20 of file assign_to_var.hpp.

void stan::agrad::assign_to_var	(	int &	n_lhs,
		const int &	n_rhs
	)

inline

Definition at line 24 of file assign_to_var.hpp.

void stan::agrad::assign_to_var	(	double &	n_lhs,
		const double &	n_rhs
	)

inline

Definition at line 28 of file assign_to_var.hpp.

template<typename LHS , typename RHS >

void stan::agrad::assign_to_var	(	std::vector< LHS > &	x,
		const std::vector< RHS > &	y
	)

inline

Definition at line 33 of file assign_to_var.hpp.

template<typename LHS , typename RHS , int R, int C>

void stan::agrad::assign_to_var	(	Eigen::Matrix< LHS, R, C > &	x,
		const Eigen::Matrix< RHS, R, C > &	y
	)

inline

Definition at line 39 of file assign_to_var.hpp.

template<typename LHS , typename RHS , int R, int C>

void stan::agrad::assign_to_var	(	Eigen::Block< LHS > &	x,
		const Eigen::Matrix< RHS, R, C > &	y
	)

inline

Definition at line 48 of file assign_to_var.hpp.

var stan::agrad::atan ( const var & a )

inline

Return the principal value of the arc tangent, in radians, of the specified variable (cmath).

The derivative is defined by

$\frac{d}{dx} \arctan x = \frac{1}{1 + x^2}$ .

Parameters

a	Variable in range [-1,1].

Returns: Arc tangent of variable, in radians.

Definition at line 1755 of file agrad_thread_safe.hpp.

var stan::agrad::atan2	(	const var &	a,
		const double	b
	)

inline

Return the principal value of the arc tangent, in radians, of the first variable divided by the second scalar (cmath).

The derivative with respect to the variable is

$ $\frac{d}{d x} \arctan \frac{x}{c} = \frac{c}{x^2 + c^2}$ .

Parameters

a	Numerator variable.
b	Denominator scalar.

Returns: The arc tangent of the fraction, in radians.

Definition at line 79 of file atan2.hpp.

var stan::agrad::atan2	(	const double	a,
		const var &	b
	)

inline

Return the principal value of the arc tangent, in radians, of the first scalar divided by the second variable (cmath).

The derivative with respect to the variable is

$ $\frac{\partial}{\partial y} \arctan \frac{c}{y} = \frac{-c}{c^2 + y^2}$ .

Parameters

a	Numerator scalar.
b	Denominator variable.

Returns: The arc tangent of the fraction, in radians.

Definition at line 95 of file atan2.hpp.

var stan::agrad::atan2	(	const var &	a,
		const var &	b
	)

inline

Return the principal value of the arc tangent, in radians, of the first variable divided by the second (cmath).

The partial derivatives are defined by

$ $\frac{\partial}{\partial x} \arctan \frac{x}{y} = \frac{y}{x^2 + y^2}$ , and

$ $\frac{\partial}{\partial y} \arctan \frac{x}{y} = \frac{-x}{x^2 + y^2}$ .

Parameters

a	Numerator variable.
b	Denominator variable.

Returns: The arc tangent of the fraction, in radians.

Definition at line 1774 of file agrad_thread_safe.hpp.

var stan::agrad::atan2	(	const var &	a,
		const double &	b
	)

inline

Return the principal value of the arc tangent, in radians, of the first variable divided by the second scalar (cmath).

The derivative with respect to the variable is

$ $\frac{d}{d x} \arctan \frac{x}{c} = \frac{c}{x^2 + c^2}$ .

Parameters

a	Numerator variable.
b	Denominator scalar.

Returns: The arc tangent of the fraction, in radians.

Definition at line 1790 of file agrad_thread_safe.hpp.

var stan::agrad::atan2	(	const double &	a,
		const var &	b
	)

inline

Return the principal value of the arc tangent, in radians, of the first scalar divided by the second variable (cmath).

The derivative with respect to the variable is

$ $\frac{\partial}{\partial y} \arctan \frac{c}{y} = \frac{-c}{c^2 + y^2}$ .

Parameters

a	Numerator scalar.
b	Denominator variable.

Returns: The arc tangent of the fraction, in radians.

Definition at line 1806 of file agrad_thread_safe.hpp.

var stan::agrad::atanh ( const stan::agrad::var & a )

inline

The inverse hyperbolic tangent function for variables (C99).

For non-variable function, see boost::math::atanh().

The derivative is defined by

$\frac{d}{dx} \mbox{atanh}(x) = \frac{1}{1 - x^2}$ .

Parameters

a	The variable.

Returns: Inverse hyperbolic tangent of the variable.

Definition at line 36 of file atanh.hpp.

double stan::agrad::calculate_chain	(	const double &	x,
		const double &	val
	)

inline

Definition at line 8 of file calculate_chain.hpp.

var stan::agrad::cbrt ( const stan::agrad::var & a )

inline

Returns the cube root of the specified variable (C99).

See boost::math::cbrt() for the double-based version.

The derivative is

$\frac{d}{dx} x^{1/3} = \frac{1}{3 x^{2/3}}$ .

Parameters

a	Specified variable.

Returns: Cube root of the variable.

Definition at line 35 of file cbrt.hpp.

var stan::agrad::ceil ( const var & a )

inline

Return the ceiling of the specified variable (cmath).

The derivative of the ceiling function is defined and zero everywhere but at integers, and we set them to zero for convenience,

$\frac{d}{dx} {\lceil x \rceil} = 0$ .

The ceiling function rounds up. For double values, this is the smallest integral value that is not less than the specified value. Although this function is not differentiable because it is discontinuous at integral values, its gradient is returned as zero everywhere.

Parameters

a	Input variable.

Returns: Ceiling of the variable.

Definition at line 1922 of file agrad_thread_safe.hpp.

template<typename T_result , class Policy >

bool stan::agrad::check_pos_definite	(	const char *	function,
		const Eigen::Matrix< var, Eigen::Dynamic, Eigen::Dynamic > &	y,
		const char *	name,
		T_result *	result,
		const Policy &
	)

inline

Definition at line 14 of file check_pos_definite.hpp.

template<int R1, int C1, int R2, int C2>

Eigen::Matrix<var, 1, C1> stan::agrad::columns_dot_product	(	const Eigen::Matrix< var, R1, C1 > &	v1,
		const Eigen::Matrix< var, R2, C2 > &	v2
	)

inline

Definition at line 341 of file dot_product.hpp.

template<int R1, int C1, int R2, int C2>

Eigen::Matrix<var, 1, C1> stan::agrad::columns_dot_product	(	const Eigen::Matrix< var, R1, C1 > &	v1,
		const Eigen::Matrix< double, R2, C2 > &	v2
	)

inline

Definition at line 353 of file dot_product.hpp.

template<int R1, int C1, int R2, int C2>

Eigen::Matrix<var, 1, C1> stan::agrad::columns_dot_product	(	const Eigen::Matrix< double, R1, C1 > &	v1,
		const Eigen::Matrix< var, R2, C2 > &	v2
	)

inline

Definition at line 365 of file dot_product.hpp.

template<int R, int C>

Eigen::Matrix<var,1,C> stan::agrad::columns_dot_self ( const Eigen::Matrix< var, R, C > & x )

inline

Returns the dot product of each column of a matrix with itself.

Parameters

x Matrix.

Template Parameters

T	scalar type

Definition at line 89 of file dot_self.hpp.

var stan::agrad::cos ( const var & a )

inline

Return the cosine of a radian-scaled variable (cmath).

The derivative is defined by

$\frac{d}{dx} \cos x = - \sin x$ .

Parameters

a	Variable for radians of angle.

Returns: Cosine of variable.

Definition at line 1682 of file agrad_thread_safe.hpp.

var stan::agrad::cosh ( const var & a )

inline

Return the hyperbolic cosine of the specified variable (cmath).

The derivative is defined by

$\frac{d}{dx} \cosh x = \sinh x$ .

Parameters

a Variable.

Returns: Hyperbolic cosine of variable.

Definition at line 1822 of file agrad_thread_safe.hpp.

matrix_v stan::agrad::crossprod ( const matrix_v & M )

inline

Returns the result of pre-multiplying a matrix by its own transpose.

Parameters

M	Matrix to multiply.

Returns: Transpose of M times M

Definition at line 17 of file crossprod.hpp.

template<int R, int C>

var stan::agrad::determinant ( const Eigen::Matrix< var, R, C > & m )

inline

Definition at line 68 of file determinant.hpp.

template<int R1, int C1, int R2, int C2>

var stan::agrad::dist	(	const Eigen::Matrix< var, R1, C1 > &	v1,
		const Eigen::Matrix< var, R2, C2 > &	v2
	)

inline

Definition at line 119 of file dist.hpp.

template<int R1, int C1, int R2, int C2>

var stan::agrad::dist	(	const Eigen::Matrix< var, R1, C1 > &	v1,
		const Eigen::Matrix< double, R2, C2 > &	v2
	)

inline

Definition at line 127 of file dist.hpp.

template<int R1, int C1, int R2, int C2>

var stan::agrad::dist	(	const Eigen::Matrix< double, R1, C1 > &	v1,
		const Eigen::Matrix< var, R2, C2 > &	v2
	)

inline

Definition at line 135 of file dist.hpp.

double stan::agrad::divide	(	double	x,
		double	y
	)

inline

Return the division of the first scalar by the second scalar.

Parameters

[in]	v	Specified vector.
[in]	c	Specified scalar.

Returns: Vector divided by the scalar.

Definition at line 25 of file divide.hpp.

template<typename T1 , typename T2 >

var stan::agrad::divide	(	const T1 &	v,
		const T2 &	c
	)

inline

Definition at line 30 of file divide.hpp.

template<typename T1 , typename T2 , int R, int C>

Eigen::Matrix<var,R,C> stan::agrad::divide	(	const Eigen::Matrix< T1, R, C > &	v,
		const T2 &	c
	)

inline

Return the division of the specified column vector by the specified scalar.

Parameters

[in]	v	Specified vector.
[in]	c	Specified scalar.

Returns: Vector divided by the scalar.

Definition at line 42 of file divide.hpp.

template<int R1, int C1, int R2, int C2>

var stan::agrad::dot_product	(	const Eigen::Matrix< var, R1, C1 > &	v1,
		const Eigen::Matrix< var, R2, C2 > &	v2
	)

inline

Returns the dot product.

Parameters

[in]	v1	First column vector.
[in]	v2	Second column vector.

Returns: Dot product of the vectors.

Exceptions

std::domain_error if length of v1 is not equal to length of v2.

Definition at line 225 of file dot_product.hpp.

template<int R1, int C1, int R2, int C2>

var stan::agrad::dot_product	(	const Eigen::Matrix< var, R1, C1 > &	v1,
		const Eigen::Matrix< double, R2, C2 > &	v2
	)

inline

Returns the dot product.

Parameters

[in]	v1	First column vector.
[in]	v2	Second column vector.

Returns: Dot product of the vectors.

Exceptions

std::domain_error if length of v1 is not equal to length of v2 or either v1 or v2 are not vectors.

Definition at line 242 of file dot_product.hpp.

template<int R1, int C1, int R2, int C2>

var stan::agrad::dot_product	(	const Eigen::Matrix< double, R1, C1 > &	v1,
		const Eigen::Matrix< var, R2, C2 > &	v2
	)

inline

Returns the dot product.

Parameters

[in]	v1	First column vector.
[in]	v2	Second column vector.

Returns: Dot product of the vectors.

Exceptions

std::domain_error if length of v1 is not equal to length of v2 or either v1 or v2 are not vectors.

Definition at line 259 of file dot_product.hpp.

var stan::agrad::dot_product	(	const var *	v1,
		const var *	v2,
		size_t	length
	)

inline

Returns the dot product.

Parameters

[in]	v1	First array.
[in]	v2	Second array.
[in]	length	Length of both arrays.

Returns: Dot product of the arrays.

Definition at line 274 of file dot_product.hpp.

var stan::agrad::dot_product	(	const var *	v1,
		const double *	v2,
		size_t	length
	)

inline

Returns the dot product.

Parameters

[in]	v1	First array.
[in]	v2	Second array.
[in]	length	Length of both arrays.

Returns: Dot product of the arrays.

Definition at line 285 of file dot_product.hpp.

var stan::agrad::dot_product	(	const double *	v1,
		const var *	v2,
		size_t	length
	)

inline

Returns the dot product.

Parameters

[in]	v1	First array.
[in]	v2	Second array.
[in]	length	Length of both arrays.

Returns: Dot product of the arrays.

Definition at line 296 of file dot_product.hpp.

var stan::agrad::dot_product	(	const std::vector< var > &	v1,
		const std::vector< var > &	v2
	)

inline

Returns the dot product.

Parameters

[in]	v1	First vector.
[in]	v2	Second vector.

Returns: Dot product of the vectors.

Exceptions

std::domain_error if sizes of v1 and v2 do not match.

Definition at line 307 of file dot_product.hpp.

var stan::agrad::dot_product	(	const std::vector< var > &	v1,
		const std::vector< double > &	v2
	)

inline

Returns the dot product.

Parameters

[in]	v1	First vector.
[in]	v2	Second vector.

Returns: Dot product of the vectors.

Exceptions

std::domain_error if sizes of v1 and v2 do not match.

Definition at line 320 of file dot_product.hpp.

var stan::agrad::dot_product	(	const std::vector< double > &	v1,
		const std::vector< var > &	v2
	)

inline

Returns the dot product.

Parameters

[in]	v1	First vector.
[in]	v2	Second vector.

Returns: Dot product of the vectors.

Exceptions

std::domain_error if sizes of v1 and v2 do not match.

Definition at line 333 of file dot_product.hpp.

template<int R, int C>

var stan::agrad::dot_self ( const Eigen::Matrix< var, R, C > & v )

inline

Returns the dot product of a vector with itself.

Parameters

[in] v Vector.

Returns: Dot product of the vector with itself.

Template Parameters

R	number of rows or `Eigen::Dynamic` for dynamic; one of R or C must be 1
C	number of rows or `Eigen::Dyanmic` for dynamic; one of R or C must be 1

Definition at line 77 of file dot_self.hpp.

var stan::agrad::erf ( const stan::agrad::var & a )

inline

The error function for variables (C99).

For non-variable function, see boost::math::erf()

The derivative is

$\frac{d}{dx} \mbox{erf}(x) = \frac{2}{\sqrt{\pi}} \exp(-x^2)$ .

Parameters

a	The variable.

Returns: Error function applied to the variable.

Definition at line 37 of file erf.hpp.

var stan::agrad::erfc ( const stan::agrad::var & a )

inline

The complementary error function for variables (C99).

For non-variable function, see boost::math::erfc().

The derivative is

$\frac{d}{dx} \mbox{erfc}(x) = - \frac{2}{\sqrt{\pi}} \exp(-x^2)$ .

Parameters

a	The variable.

Returns: Complementary error function applied to the variable.

Definition at line 37 of file erfc.hpp.

var stan::agrad::exp ( const var & a )

inline

Return the exponentiation of the specified variable (cmath).

Parameters

a	Variable to exponentiate.

Returns: Exponentiated variable.

Definition at line 1571 of file agrad_thread_safe.hpp.

var stan::agrad::exp2 ( const stan::agrad::var & a )

inline

Exponentiation base 2 function for variables (C99).

For non-variable function, see boost::math::exp2().

The derivatie is

$\frac{d}{dx} 2^x = (\log 2) 2^x$ .

Parameters

a	The variable.

Returns: Two to the power of the specified variable.

Definition at line 36 of file exp2.hpp.

var stan::agrad::expm1 ( const stan::agrad::var & a )

inline

The exponentiation of the specified variable minus 1 (C99).

For non-variable function, see boost::math::expm1().

The derivative is given by

$\frac{d}{dx} \exp(a) - 1 = \exp(a)$ .

Parameters

a	The variable.

Returns: Two to the power of the specified variable.

Definition at line 36 of file expm1.hpp.

var stan::agrad::fabs ( const var & a )

inline

Return the absolute value of the variable (cmath).

Choosing an arbitrary value at the non-differentiable point 0,

$\frac{d}{dx}|x| = \mbox{sgn}(x)$ .

where $\mbox{sgn}(x)$ is the signum function, taking values -1 if $x < 0$ , 0 if $x == 0$ , and 1 if $x == 1$ .

The function abs() provides the same behavior, with abs() defined in stdlib.h and fabs() defined in cmath.

Parameters

a	Input variable.

Returns: Absolute value of variable.

Definition at line 1873 of file agrad_thread_safe.hpp.

var stan::agrad::fdim	(	const stan::agrad::var &	a,
		const stan::agrad::var &	b
	)

inline

Return the positive difference between the first variable's the value and the second's (C99).

See stan::math::fdim() for the double-based version.

The partial derivative with respect to the first argument is

$\frac{\partial}{\partial x} \mbox{fdim}(x,y) = 0.0$ if $x < y$ , and

$\frac{\partial}{\partial x} \mbox{fdim}(x,y) = 1.0$ if $x \geq y$ .

With respect to the second argument, the partial is

$\frac{\partial}{\partial y} \mbox{fdim}(x,y) = 0.0$ if $x < y$ , and

$\frac{\partial}{\partial y} \mbox{fdim}(x,y) = -\lfloor\frac{x}{y}\rfloor$ if $x \geq y$ .

Parameters

a	First variable.
b	Second variable.

Returns: The positive difference between the first and second variable.

Definition at line 68 of file fdim.hpp.

var stan::agrad::fdim	(	const double &	a,
		const stan::agrad::var &	b
	)

inline

Return the positive difference between the first value and the value of the second variable (C99).

See fdim(var,var) for definitions of values and derivatives.

The derivative with respect to the variable is

$\frac{d}{d y} \mbox{fdim}(c,y) = 0.0$ if $c < y$ , and

$\frac{d}{d y} \mbox{fdim}(c,y) = -\lfloor\frac{c}{y}\rfloor$ if $c \geq y$ .

Parameters

a	First value.
b	Second variable.

Returns: The positive difference between the first and second arguments.

Definition at line 93 of file fdim.hpp.

var stan::agrad::fdim	(	const stan::agrad::var &	a,
		const double &	b
	)

inline

Return the positive difference between the first variable's value and the second value (C99).

See fdim(var,var) for definitions of values and derivatives.

The derivative with respect to the variable is

$\frac{d}{d x} \mbox{fdim}(x,c) = 0.0$ if $x < c$ , and

$\frac{d}{d x} \mbox{fdim}(x,c) = 1.0$ if $x \geq yc$ .

Parameters

a	First value.
b	Second variable.

Returns: The positive difference between the first and second arguments.

Definition at line 116 of file fdim.hpp.

template<typename T , typename S >

void stan::agrad::fill	(	T &	x,
		const S &	y
	)

Definition at line 11 of file fill.hpp.

template<typename T , int R, int C, typename S >

void stan::agrad::fill	(	Eigen::Matrix< T, R, C > &	x,
		const S &	y
	)

Definition at line 16 of file fill.hpp.

template<typename T , typename S >

void stan::agrad::fill	(	std::vector< T > &	x,
		const S &	y
	)

Definition at line 21 of file fill.hpp.

var stan::agrad::floor ( const var & a )

inline

Return the floor of the specified variable (cmath).

The derivative of the floor function is defined and zero everywhere but at integers, so we set these derivatives to zero for convenience,

$\frac{d}{dx} {\lfloor x \rfloor} = 0$ .

The floor function rounds down. For double values, this is the largest integral value that is not greater than the specified value. Although this function is not differentiable because it is discontinuous at integral values, its gradient is returned as zero everywhere.

Parameters

a	Input variable.

Returns: Floor of the variable.

Definition at line 1900 of file agrad_thread_safe.hpp.

var stan::agrad::fma	(	const stan::agrad::var &	a,
		const stan::agrad::var &	b,
		const stan::agrad::var &	c
	)

inline

The fused multiply-add function for three variables (C99).

This function returns the product of the first two arguments plus the third argument.

See boost::math::fma() for the double-based version.

The partial derivatives are

$\frac{\partial}{\partial x} (x * y) + z = y$ , and

$\frac{\partial}{\partial y} (x * y) + z = x$ , and

$\frac{\partial}{\partial z} (x * y) + z = 1$ .

Parameters

a	First multiplicand.
b	Second multiplicand.
c	Summand.

Returns: Product of the multiplicands plus the summand, ($a * $b) + $c.

Definition at line 98 of file fma.hpp.

var stan::agrad::fma	(	const stan::agrad::var &	a,
		const stan::agrad::var &	b,
		const double &	c
	)

inline

The fused multiply-add function for two variables and a value (C99).

This function returns the product of the first two arguments plus the third argument.

See boost::math::fma() for the double-based version.

The partial derivatives are

$\frac{\partial}{\partial x} (x * y) + c = y$ , and

$\frac{\partial}{\partial y} (x * y) + c = x$ .

Parameters

a	First multiplicand.
b	Second multiplicand.
c	Summand.

Returns: Product of the multiplicands plus the summand, ($a * $b) + $c.

Definition at line 122 of file fma.hpp.

var stan::agrad::fma	(	const stan::agrad::var &	a,
		const double &	b,
		const stan::agrad::var &	c
	)

inline

The fused multiply-add function for a variable, value, and variable (C99).

This function returns the product of the first two arguments plus the third argument.

See boost::math::fma() for the double-based version.

The partial derivatives are

$\frac{\partial}{\partial x} (x * c) + z = c$ , and

$\frac{\partial}{\partial z} (x * c) + z = 1$ .

Parameters

a	First multiplicand.
b	Second multiplicand.
c	Summand.

Returns: Product of the multiplicands plus the summand, ($a * $b) + $c.

Definition at line 146 of file fma.hpp.

var stan::agrad::fma	(	const stan::agrad::var &	a,
		const double &	b,
		const double &	c
	)

inline

The fused multiply-add function for a variable and two values (C99).

This function returns the product of the first two arguments plus the third argument.

See boost::math::fma() for the double-based version.

The derivative is

$\frac{d}{d x} (x * c) + d = c$ .

Parameters

a	First multiplicand.
b	Second multiplicand.
c	Summand.

Returns: Product of the multiplicands plus the summand, ($a * $b) + $c.

Definition at line 168 of file fma.hpp.

var stan::agrad::fma	(	const double &	a,
		const stan::agrad::var &	b,
		const double &	c
	)

inline

The fused multiply-add function for a value, variable, and value (C99).

This function returns the product of the first two arguments plus the third argument.

See boost::math::fma() for the double-based version.

The derivative is

$\frac{d}{d y} (c * y) + d = c$ , and

Parameters

a	First multiplicand.
b	Second multiplicand.
c	Summand.

Returns: Product of the multiplicands plus the summand, ($a * $b) + $c.

Definition at line 190 of file fma.hpp.

var stan::agrad::fma	(	const double &	a,
		const double &	b,
		const stan::agrad::var &	c
	)

inline

The fused multiply-add function for two values and a variable, and value (C99).

This function returns the product of the first two arguments plus the third argument.

See boost::math::fma() for the double-based version.

The derivative is

$\frac{\partial}{\partial z} (c * d) + z = 1$ .

Parameters

a	First multiplicand.
b	Second multiplicand.
c	Summand.

Returns: Product of the multiplicands plus the summand, ($a * $b) + $c.

Definition at line 212 of file fma.hpp.

var stan::agrad::fma	(	const double &	a,
		const stan::agrad::var &	b,
		const stan::agrad::var &	c
	)

inline

The fused multiply-add function for a value and two variables (C99).

This function returns the product of the first two arguments plus the third argument.

See boost::math::fma() for the double-based version.

The partial derivaties are

$\frac{\partial}{\partial y} (c * y) + z = c$ , and

$\frac{\partial}{\partial z} (c * y) + z = 1$ .

Parameters

a	First multiplicand.
b	Second multiplicand.
c	Summand.

Returns: Product of the multiplicands plus the summand, ($a * $b) + $c.

Definition at line 236 of file fma.hpp.

var stan::agrad::fmax	(	const stan::agrad::var &	a,
		const stan::agrad::var &	b
	)

inline

Returns the maximum of the two variable arguments (C99).

See boost::math::fmax() for the double-based version.

No new variable implementations are created, with this function defined as if by

fmax(a,b) = a if a's value is greater than b's, and .

fmax(a,b) = b if b's value is greater than or equal to a's.

Parameters

a	First variable.
b	Second variable.

Returns: If the first variable's value is larger than the second's, the first variable, otherwise the second variable.

Definition at line 26 of file fmax.hpp.

var stan::agrad::fmax	(	const stan::agrad::var &	a,
		const double &	b
	)

inline

Returns the maximum of the variable and scalar, promoting the scalar to a variable if it is larger (C99).

See boost::math::fmax() for the double-based version.

For fmax(a,b), if a's value is greater than b, then a is returned, otherwise a fesh variable implementation wrapping the value b is returned.

Parameters

a	First variable.
b	Second value

Returns: If the first variable's value is larger than or equal to the second value, the first variable, otherwise the second value promoted to a fresh variable.

Definition at line 47 of file fmax.hpp.

var stan::agrad::fmax	(	const double &	a,
		const stan::agrad::var &	b
	)

inline

Returns the maximum of a scalar and variable, promoting the scalar to a variable if it is larger (C99).

See boost::math::fmax() for the double-based version.

For fmax(a,b), if a is greater than b's value, then a fresh variable implementation wrapping a is returned, otherwise b is returned.

Parameters

a	First value.
b	Second variable.

Returns: If the first value is larger than the second variable's value, return the first value promoted to a variable, otherwise return the second variable.

Definition at line 68 of file fmax.hpp.

var stan::agrad::fmin	(	const stan::agrad::var &	a,
		const stan::agrad::var &	b
	)

inline

Returns the minimum of the two variable arguments (C99).

See boost::math::fmin() for the double-based version.

For fmin(a,b), if a's value is less than b's, then a is returned, otherwise b is returned.

Parameters

a	First variable.
b	Second variable.

Returns: If the first variable's value is smaller than the second's, the first variable, otherwise the second variable.

Definition at line 22 of file fmin.hpp.

var stan::agrad::fmin	(	const stan::agrad::var &	a,
		const double &	b
	)

inline

Returns the minimum of the variable and scalar, promoting the scalar to a variable if it is larger (C99).

See boost::math::fmin() for the double-based version.

For fmin(a,b), if a's value is less than b, then a is returned, otherwise a fresh variable wrapping b is returned.

Parameters

a	First variable.
b	Second value

Returns: If the first variable's value is less than or equal to the second value, the first variable, otherwise the second value promoted to a fresh variable.

Definition at line 41 of file fmin.hpp.

var stan::agrad::fmin	(	const double &	a,
		const stan::agrad::var &	b
	)

inline

Returns the minimum of a scalar and variable, promoting the scalar to a variable if it is larger (C99).

See boost::math::fmin() for the double-based version.

For fmin(a,b), if a is less than b's value, then a fresh variable implementation wrapping a is returned, otherwise b is returned.

Parameters

a	First value.
b	Second variable.

Returns: If the first value is smaller than the second variable's value, return the first value promoted to a variable, otherwise return the second variable.

Definition at line 62 of file fmin.hpp.

var stan::agrad::fmod	(	const var &	a,
		const double	b
	)

inline

Return the floating point remainder after dividing the the first variable by the second scalar (cmath).

The derivative with respect to the variable is

$\frac{d}{d x} \mbox{fmod}(x,c) = \frac{1}{c}$ .

Parameters

a	First variable.
b	Second scalar.

Returns: Floating pointer remainder of dividing the first variable by the second scalar.

Definition at line 81 of file fmod.hpp.

var stan::agrad::fmod	(	const double	a,
		const var &	b
	)

inline

Return the floating point remainder after dividing the first scalar by the second variable (cmath).

The derivative with respect to the variable is

$\frac{d}{d y} \mbox{fmod}(c,y) = -\lfloor \frac{c}{y} \rfloor$ .

Parameters

a	First scalar.
b	Second variable.

Returns: Floating pointer remainder of dividing first scalar by the second variable.

Definition at line 98 of file fmod.hpp.

var stan::agrad::fmod	(	const var &	a,
		const var &	b
	)

inline

Return the floating point remainder after dividing the first variable by the second (cmath).

The partial derivatives with respect to the variables are defined everywhere but where $x = y$ , but we set these to match other values, with

$\frac{\partial}{\partial x} \mbox{fmod}(x,y) = 1$ , and

$\frac{\partial}{\partial y} \mbox{fmod}(x,y) = -\lfloor \frac{x}{y} \rfloor$ .

Parameters

a	First variable.
b	Second variable.

Returns: Floating pointer remainder of dividing the first variable by the second.

Definition at line 1943 of file agrad_thread_safe.hpp.

var stan::agrad::fmod	(	const var &	a,
		const double &	b
	)

inline

Return the floating point remainder after dividing the the first variable by the second scalar (cmath).

The derivative with respect to the variable is

$\frac{d}{d x} \mbox{fmod}(x,c) = \frac{1}{c}$ .

Parameters

a	First variable.
b	Second scalar.

Returns: Floating pointer remainder of dividing the first variable by the second scalar.

Definition at line 1960 of file agrad_thread_safe.hpp.

var stan::agrad::fmod	(	const double &	a,
		const var &	b
	)

inline

Return the floating point remainder after dividing the first scalar by the second variable (cmath).

The derivative with respect to the variable is

$\frac{d}{d y} \mbox{fmod}(c,y) = -\lfloor \frac{c}{y} \rfloor$ .

Parameters

a	First scalar.
b	Second variable.

Returns: Floating pointer remainder of dividing first scalar by the second variable.

Definition at line 1977 of file agrad_thread_safe.hpp.

static void stan::agrad::free_memory ( )

static

Return all memory used for gradients back to the system.

Definition at line 49 of file var_stack.hpp.

static void stan::agrad::grad ( chainable * vi )

static

static void stan::agrad::grad ( chainable * vi )

static

Compute the gradient for all variables starting from the specified root variable implementation.

Does not recover memory. This chainable variable's adjoint is initialized using the method init_dependent() and then the chain rule is applied working down the stack from this chainable and calling each chainable's chain() method in turn.

Parameters

vi	Variable implementation for root of partial derivative propagation.

Definition at line 92 of file chainable.hpp.

template<class F >

double stan::agrad::hessian	(	const F &	f,
		const std::vector< double > &	x,
		const std::vector< double > &	v,
		std::vector< double > &	Hv
	)

Definition at line 20 of file hessian.hpp.

var stan::agrad::hypot	(	const stan::agrad::var &	a,
		const stan::agrad::var &	b
	)

inline

Returns the length of the hypoteneuse of a right triangle with sides of the specified lengths (C99).

See boost::math::hypot() for double-based function.

The partial derivatives are given by

$\frac{\partial}{\partial x} \sqrt{x^2 + y^2} = \frac{x}{\sqrt{x^2 + y^2}}$ , and

$\frac{\partial}{\partial y} \sqrt{x^2 + y^2} = \frac{y}{\sqrt{x^2 + y^2}}$ .

Parameters

a	Length of first side.
b	Length of second side.

Returns: Length of hypoteneuse.

Definition at line 54 of file hypot.hpp.

var stan::agrad::hypot	(	const stan::agrad::var &	a,
		const double &	b
	)

inline

Returns the length of the hypoteneuse of a right triangle with sides of the specified lengths (C99).

See boost::math::hypot() for double-based function.

The derivative is

$\frac{d}{d x} \sqrt{x^2 + c^2} = \frac{x}{\sqrt{x^2 + c^2}}$ .

Parameters

a	Length of first side.
b	Length of second side.

Returns: Length of hypoteneuse.

Definition at line 73 of file hypot.hpp.

var stan::agrad::hypot	(	const double &	a,
		const stan::agrad::var &	b
	)

inline

Returns the length of the hypoteneuse of a right triangle with sides of the specified lengths (C99).

See boost::math::hypot() for double-based function.

The derivative is

$\frac{d}{d y} \sqrt{c^2 + y^2} = \frac{y}{\sqrt{c^2 + y^2}}$ .

Parameters

a	Length of first side.
b	Length of second side.

Returns: Length of hypoteneuse.

Definition at line 92 of file hypot.hpp.

var stan::agrad::ibeta	(	const var &	a,
		const var &	b,
		const var &	x
	)

inline

The normalized incomplete beta function of a, b, and x.

Used to compute the cumulative density function for the beta distribution.

Partial derivatives are those specified by wolfram alpha. The values were checked using both finite differences and by independent code for calculating the derivatives found in JSS (paper by Boik and Robison-Cox).

Parameters

a	Shape parameter.
b	Shape parameter.
x	Random variate.

Returns: The normalized incomplete beta function.

Definition at line 222 of file ibeta.hpp.

var stan::agrad::if_else	(	bool	c,
		const var &	y_true,
		const var &	y_false
	)

inline

If the specified condition is true, return the first variable, otherwise return the second variable.

Parameters

c	Boolean condition.
y_true	Variable to return if condition is true.
y_false	Variable to return if condition is false.

Definition at line 17 of file if_else.hpp.

var stan::agrad::if_else	(	bool	c,
		double	y_true,
		const var &	y_false
	)

inline

If the specified condition is true, return a new variable constructed from the first scalar, otherwise return the second variable.

Parameters

c	Boolean condition.
y_true	Value to promote to variable and return if condition is true.
y_false	Variable to return if condition is false.

Definition at line 29 of file if_else.hpp.

var stan::agrad::if_else	(	bool	c,
		const var &	y_true,
		const double	y_false
	)

inline

If the specified condition is true, return the first variable, otherwise return a new variable constructed from the second scalar.

Parameters

c	Boolean condition.
y_true	Variable to return if condition is true.
y_false	Value to promote to variable and return if condition is false.

Definition at line 44 of file if_else.hpp.

void stan::agrad::initialize_variable	(	var &	variable,
		const var &	value
	)

inline

Initialize variable to value.

(Function may look pointless, but its needed to bottom out recursion.)

Definition at line 15 of file initialize_variable.hpp.

template<int R, int C>

void stan::agrad::initialize_variable	(	Eigen::Matrix< var, R, C > &	matrix,
		const var &	value
	)

inline

Initialize every cell in the matrix to the specified value.

Definition at line 24 of file initialize_variable.hpp.

template<typename T >

void stan::agrad::initialize_variable	(	std::vector< T > &	variables,
		const var &	value
	)

inline

Initialize the variables in the standard vector recursively.

Definition at line 33 of file initialize_variable.hpp.

var stan::agrad::inv_cloglog ( const stan::agrad::var & a )

inline

Return the inverse complementary log-log function applied specified variable (stan).

See stan::math::inv_cloglog() for the double-based version.

The derivative is given by

$\frac{d}{dx} \mbox{cloglog}^{-1}(x) = \exp (x - \exp (x))$ .

Parameters

a	Variable argument.

Returns: The inverse complementary log-log of the specified argument.

Definition at line 37 of file inv_cloglog.hpp.

var stan::agrad::inv_logit ( const stan::agrad::var & a )

inline

The inverse logit function for variables (stan).

See stan::math::inv_logit() for the double-based version.

The derivative of inverse logit is

$\frac{d}{dx} \mbox{logit}^{-1}(x) = \mbox{logit}^{-1}(x) (1 - \mbox{logit}^{-1}(x))$ .

Parameters

a	Argument variable.

Returns: Inverse logit of argument.

Definition at line 35 of file inv_logit.hpp.

template<typename T >

bool stan::agrad::is_uninitialized ( T x )

inline

Definition at line 12 of file is_uninitialized.hpp.

bool stan::agrad::is_uninitialized ( var x )

inline

Definition at line 15 of file is_uninitialized.hpp.

void stan::agrad::jacobian	(	std::vector< var > &	dependents,
		std::vector< var > &	independents,
		std::vector< std::vector< double > > &	jacobian
	)

inline

Return the Jacobian of the function producing the specified dependent variables with respect to the specified independent variables.

A typical use case would be to take the Jacobian of a function from independent variables to dependentant variables. For instance,

std::vector<var> f(std::vector<var>& x) { ... }
std::vector<var> x = ...;
std::vector<var> y = f(x);
std::vector<std::vector<double> > J;
jacobian(y,x,J);

After executing this code, J will contain the Jacobian, stored as a standard vector of gradients. Specifically, J[m] will be the gradient of y[m] with respect to x, and thus J[m][n] will be dy[m]/dx[n].

Parameters

[in]	dependents	Dependent (output) variables.
[in]	independents	Indepent (input) variables.
[out]	jacobian	Jacobian of the transform.

Definition at line 36 of file jacobian.hpp.

var stan::agrad::lgamma ( const stan::agrad::var & a )

inline

The log gamma function for variables (C99).

The derivatie is the digamma function,

$\frac{d}{dx} \Gamma(x) = \psi^{(0)}(x)$ .

Parameters

a	The variable.

Returns: Log gamma of the variable.

Definition at line 36 of file lgamma.hpp.

var stan::agrad::log ( const var & a )

inline

Return the natural log of the specified variable (cmath).

The derivative is defined by

$\frac{d}{dx} \log x = \frac{1}{x}$ .

Parameters

a	Variable whose log is taken.

Returns: Natural log of variable.

Definition at line 1585 of file agrad_thread_safe.hpp.

var stan::agrad::log10 ( const var & a )

inline

Return the base 10 log of the specified variable (cmath).

The derivative is defined by

$\frac{d}{dx} \log_{10} x = \frac{1}{x \log 10}$ .

Parameters

a	Variable whose log is taken.

Returns: Base 10 log of variable.

Definition at line 1599 of file agrad_thread_safe.hpp.

var stan::agrad::log1m ( const stan::agrad::var & a )

inline

The log (1 - x) function for variables.

The derivative is given by

$\frac{d}{dx} \log (1 - x) = -\frac{1}{1 - x}$ .

Parameters

a	The variable.

Returns: The variable representing log of 1 minus the variable.

Definition at line 35 of file log1m.hpp.

var stan::agrad::log1p ( const stan::agrad::var & a )

inline

The log (1 + x) function for variables (C99).

The derivative is given by

$\frac{d}{dx} \log (1 + x) = \frac{1}{1 + x}$ .

Parameters

a	The variable.

Returns: The log of 1 plus the variable.

Definition at line 35 of file log1p.hpp.

var stan::agrad::log1p_exp ( const stan::agrad::var & a )

inline

Return the log of 1 plus the exponential of the specified variable.

Definition at line 29 of file log1p_exp.hpp.

var stan::agrad::log2 ( const stan::agrad::var & a )

inline

Returns the base 2 logarithm of the specified variable (C99).

See stan::math::log2() for the double-based version.

The derivative is

$\frac{d}{dx} \log_2 x = \frac{1}{x \log 2}$ .

Parameters

a	Specified variable.

Returns: Base 2 logarithm of the variable.

Definition at line 36 of file log2.hpp.

template<int R, int C>

var stan::agrad::log_determinant ( const Eigen::Matrix< var, R, C > & m )

inline

Definition at line 70 of file log_determinant.hpp.

template<int R, int C>

var stan::agrad::log_determinant_spd ( const Eigen::Matrix< var, R, C > & m )

inline

Definition at line 98 of file log_determinant_spd.hpp.

var stan::agrad::log_loss	(	const int &	y,
		const stan::agrad::var &	y_hat
	)

inline

The log loss function for variables (stan).

See stan::math::log_loss() for the double-based version.

The derivative with respect to the variable $\hat{y}$ is

$\frac{d}{d\hat{y}} \mbox{logloss}(1,\hat{y}) = - \frac{1}{\hat{y}}$ , and

$\frac{d}{d\hat{y}} \mbox{logloss}(0,\hat{y}) = \frac{1}{1 - \hat{y}}$ .

Parameters

y	Reference value.
y_hat	Response variable.

Returns: Log loss of response versus reference value.

Definition at line 48 of file log_loss.hpp.

var stan::agrad::log_sum_exp	(	const stan::agrad::var &	a,
		const stan::agrad::var &	b
	)

inline

Returns the log sum of exponentials.

Definition at line 81 of file log_sum_exp.hpp.

var stan::agrad::log_sum_exp	(	const stan::agrad::var &	a,
		const double &	b
	)

inline

Returns the log sum of exponentials.

Definition at line 88 of file log_sum_exp.hpp.

var stan::agrad::log_sum_exp	(	const double &	a,
		const stan::agrad::var &	b
	)

inline

Returns the log sum of exponentials.

Definition at line 95 of file log_sum_exp.hpp.

var stan::agrad::log_sum_exp ( const std::vector< var > & x )

inline

Returns the log sum of exponentials.

Definition at line 102 of file log_sum_exp.hpp.

template<int R1, int C1, int R2, int C2>

Eigen::Matrix<var,R1,C2> stan::agrad::mdivide_left	(	const Eigen::Matrix< var, R1, C1 > &	A,
		const Eigen::Matrix< var, R2, C2 > &	b
	)

inline

Definition at line 264 of file mdivide_left.hpp.

template<int R1, int C1, int R2, int C2>

Eigen::Matrix<var,R1,C2> stan::agrad::mdivide_left	(	const Eigen::Matrix< var, R1, C1 > &	A,
		const Eigen::Matrix< double, R2, C2 > &	b
	)

inline

Definition at line 287 of file mdivide_left.hpp.

template<int R1, int C1, int R2, int C2>

Eigen::Matrix<var,R1,C2> stan::agrad::mdivide_left	(	const Eigen::Matrix< double, R1, C1 > &	A,
		const Eigen::Matrix< var, R2, C2 > &	b
	)

inline

Definition at line 310 of file mdivide_left.hpp.

template<int R1, int C1, int R2, int C2>

Eigen::Matrix<var,R1,C2> stan::agrad::mdivide_left_spd	(	const Eigen::Matrix< var, R1, C1 > &	A,
		const Eigen::Matrix< var, R2, C2 > &	b
	)

inline

Definition at line 244 of file mdivide_left_spd.hpp.

template<int R1, int C1, int R2, int C2>

Eigen::Matrix<var,R1,C2> stan::agrad::mdivide_left_spd	(	const Eigen::Matrix< var, R1, C1 > &	A,
		const Eigen::Matrix< double, R2, C2 > &	b
	)

inline

Definition at line 267 of file mdivide_left_spd.hpp.

template<int R1, int C1, int R2, int C2>

Eigen::Matrix<var,R1,C2> stan::agrad::mdivide_left_spd	(	const Eigen::Matrix< double, R1, C1 > &	A,
		const Eigen::Matrix< var, R2, C2 > &	b
	)

inline

Definition at line 290 of file mdivide_left_spd.hpp.

template<int TriView, int R1, int C1, int R2, int C2>

Eigen::Matrix<var,R1,C2> stan::agrad::mdivide_left_tri	(	const Eigen::Matrix< var, R1, C1 > &	A,
		const Eigen::Matrix< var, R2, C2 > &	b
	)

inline

Definition at line 296 of file mdivide_left_tri.hpp.

template<int TriView, int R1, int C1, int R2, int C2>

Eigen::Matrix<var,R1,C2> stan::agrad::mdivide_left_tri	(	const Eigen::Matrix< double, R1, C1 > &	A,
		const Eigen::Matrix< var, R2, C2 > &	b
	)

inline

Definition at line 318 of file mdivide_left_tri.hpp.

template<int TriView, int R1, int C1, int R2, int C2>

Eigen::Matrix<var,R1,C2> stan::agrad::mdivide_left_tri	(	const Eigen::Matrix< var, R1, C1 > &	A,
		const Eigen::Matrix< double, R2, C2 > &	b
	)

inline

Definition at line 340 of file mdivide_left_tri.hpp.

template<typename T1 , typename T2 >

boost::math::tools::promote_args<T1,T2>::type stan::agrad::multiply	(	const T1 &	v,
		const T2 &	c
	)

inline

Return the product of two scalars.

Parameters

[in]	v	First scalar.
[in]	c	Specified scalar.

Returns: Product of scalars.

Definition at line 29 of file multiply.hpp.

template<typename T1 , typename T2 , int R2, int C2>

Eigen::Matrix<var,R2,C2> stan::agrad::multiply	(	const T1 &	c,
		const Eigen::Matrix< T2, R2, C2 > &	m
	)

inline

Return the product of scalar and matrix.

Parameters

[in]	c	Specified scalar.
[in]	m	Matrix.

Returns: Product of scalar and matrix.

Definition at line 40 of file multiply.hpp.

template<typename T1 , int R1, int C1, typename T2 >

Eigen::Matrix<var,R1,C1> stan::agrad::multiply	(	const Eigen::Matrix< T1, R1, C1 > &	m,
		const T2 &	c
	)

inline

Return the product of scalar and matrix.

Parameters

[in]	m	Matrix.
[in]	c	Specified scalar.

Returns: Product of scalar and matrix.

Definition at line 54 of file multiply.hpp.

template<int R1, int C1, int R2, int C2>

Eigen::Matrix<var,R1,C2> stan::agrad::multiply	(	const Eigen::Matrix< var, R1, C1 > &	m1,
		const Eigen::Matrix< var, R2, C2 > &	m2
	)

inline

Return the product of the specified matrices.

The number of columns in the first matrix must be the same as the number of rows in the second matrix.

Parameters

[in]	m1	First matrix.
[in]	m2	Second matrix.

Returns: The product of the first and second matrices.

Exceptions

std::domain_error if the number of columns of m1 does not match the number of rows of m2.

Definition at line 70 of file multiply.hpp.

template<int R1, int C1, int R2, int C2>

Eigen::Matrix<var,R1,C2> stan::agrad::multiply	(	const Eigen::Matrix< double, R1, C1 > &	m1,
		const Eigen::Matrix< var, R2, C2 > &	m2
	)

inline

Return the product of the specified matrices.

The number of columns in the first matrix must be the same as the number of rows in the second matrix.

Parameters

[in]	m1	First matrix.
[in]	m2	Second matrix.

Returns: The product of the first and second matrices.

Exceptions

std::domain_error if the number of columns of m1 does not match the number of rows of m2.

Definition at line 114 of file multiply.hpp.

template<int R1, int C1, int R2, int C2>

Eigen::Matrix<var,R1,C2> stan::agrad::multiply	(	const Eigen::Matrix< var, R1, C1 > &	m1,
		const Eigen::Matrix< double, R2, C2 > &	m2
	)

inline

Return the product of the specified matrices.

The number of columns in the first matrix must be the same as the number of rows in the second matrix.

Parameters

[in]	m1	First matrix.
[in]	m2	Second matrix.

Returns: The product of the first and second matrices.

Exceptions

std::domain_error if the number of columns of m1 does not match the number of rows of m2.

Definition at line 159 of file multiply.hpp.

template<int C1, int R2>

var stan::agrad::multiply	(	const Eigen::Matrix< var, 1, C1 > &	rv,
		const Eigen::Matrix< var, R2, 1 > &	v
	)

inline

Return the scalar product of the specified row vector and specified column vector.

The return is the same as the dot product. The two vectors must be the same size.

Parameters

[in]	rv	Row vector.
[in]	v	Column vector.

Returns: Scalar result of multiplying row vector by column vector.

Exceptions

std::domain_error if rv and v are not the same size

Definition at line 203 of file multiply.hpp.

template<int C1, int R2>

var stan::agrad::multiply	(	const Eigen::Matrix< double, 1, C1 > &	rv,
		const Eigen::Matrix< var, R2, 1 > &	v
	)

inline

Return the scalar product of the specified row vector and specified column vector.

The return is the same as the dot product. The two vectors must be the same size.

Parameters

[in]	rv	Row vector.
[in]	v	Column vector.

Returns: Scalar result of multiplying row vector by column vector.

Exceptions

std::domain_error if rv and v are not the same size

Definition at line 219 of file multiply.hpp.

template<int C1, int R2>

var stan::agrad::multiply	(	const Eigen::Matrix< var, 1, C1 > &	rv,
		const Eigen::Matrix< double, R2, 1 > &	v
	)

inline

Return the scalar product of the specified row vector and specified column vector.

The return is the same as the dot product. The two vectors must be the same size.

Parameters

[in]	rv	Row vector.
[in]	v	Column vector.

Returns: Scalar result of multiplying row vector by column vector.

Exceptions

std::domain_error if rv and v are not the same size

Definition at line 234 of file multiply.hpp.

var stan::agrad::multiply_log	(	const var &	a,
		const var &	b
	)

inline

Return the value of a*log(b).

When both a and b are 0, the value returned is 0. The partial deriviative with respect to a is log(b). The partial deriviative with respect to b is a/b. When a and b are both 0, this is set to Inf.

Parameters

a	First variable.
b	Second variable.

Returns: Value of a*log(b)

Definition at line 66 of file multiply_log.hpp.

var stan::agrad::multiply_log	(	const var &	a,
		const double	b
	)

inline

Return the value of a*log(b).

When both a and b are 0, the value returned is 0. The partial deriviative with respect to a is log(b).

Parameters

a	First variable.
b	Second scalar.

Returns: Value of a*log(b)

Definition at line 79 of file multiply_log.hpp.

var stan::agrad::multiply_log	(	const double	a,
		const var &	b
	)

inline

Return the value of a*log(b).

When both a and b are 0, the value returned is 0. The partial deriviative with respect to b is a/b. When a and b are both 0, this is set to Inf.

Parameters

a	First scalar.
b	Second variable.

Returns: Value of a*log(b)

Definition at line 93 of file multiply_log.hpp.

matrix_v stan::agrad::multiply_lower_tri_self_transpose ( const matrix_v & L )

inline

Definition at line 21 of file multiply_lower_tri_self_transpose.hpp.

bool stan::agrad::operator! ( const var & a )

inline

Prefix logical negation for the value of variables (C++).

The expression (!a) is equivalent to negating the scalar value of the variable a.

Note that this is the only logical operator defined for variables. Overridden logical conjunction (&&) and disjunction (||) operators do not apply the same "short circuit" rules as the built-in logical operators.

Parameters

a	Variable to negate.

Returns: True if variable is non-zero.

Definition at line 1265 of file agrad_thread_safe.hpp.

bool stan::agrad::operator!=	(	const var &	a,
		const double	b
	)

inline

Inequality operator comparing a variable's value and a double (C++).

Parameters

a	First variable.
b	Second value.

Returns: True if the first variable's value is not the same as the second value.

Definition at line 30 of file operator_not_equal.hpp.

bool stan::agrad::operator!=	(	const double	a,
		const var &	b
	)

inline

Inequality operator comparing a double and a variable's value (C++).

Parameters

a	First value.
b	Second variable.

Returns: True if the first value is not the same as the second variable's value.

Definition at line 43 of file operator_not_equal.hpp.

bool stan::agrad::operator!=	(	const var &	a,
		const var &	b
	)

inline

Inequality operator comparing two variables' values (C++).

Parameters

a	First variable.
b	Second variable.

Returns: True if the first variable's value is not the same as the second's.

Definition at line 1072 of file agrad_thread_safe.hpp.

bool stan::agrad::operator!=	(	const var &	a,
		const double &	b
	)

inline

Inequality operator comparing a variable's value and a double (C++).

Parameters

a	First variable.
b	Second value.

Returns: True if the first variable's value is not the same as the second value.

Definition at line 1085 of file agrad_thread_safe.hpp.

bool stan::agrad::operator!=	(	const double &	a,
		const var &	b
	)

inline

Inequality operator comparing a double and a variable's value (C++).

Parameters

a	First value.
b	Second variable.

Returns: True if the first value is not the same as the second variable's value.

Definition at line 1098 of file agrad_thread_safe.hpp.

var stan::agrad::operator*	(	const var &	a,
		const double	b
	)

inline

Multiplication operator for a variable and a scalar (C++).

The partial derivative for the variable is

$\frac{\partial}{\partial x} (x * c) = c$ , and

Parameters

a	Variable operand.
b	Scalar operand.

Returns: Variable result of multiplying operands.

Definition at line 62 of file operator_multiplication.hpp.

var stan::agrad::operator*	(	const double	a,
		const var &	b
	)

inline

Multiplication operator for a scalar and a variable (C++).

The partial derivative for the variable is

$\frac{\partial}{\partial y} (c * y) = c$ .

Parameters

a	Scalar operand.
b	Variable operand.

Returns: Variable result of multiplying the operands.

Definition at line 79 of file operator_multiplication.hpp.

var stan::agrad::operator*	(	const var &	a,
		const var &	b
	)

inline

Multiplication operator for two variables (C++).

The partial derivatives are

$\frac{\partial}{\partial x} (x * y) = y$ , and

$\frac{\partial}{\partial y} (x * y) = x$ .

Parameters

a	First variable operand.
b	Second variable operand.

Returns: Variable result of multiplying operands.

Definition at line 1411 of file agrad_thread_safe.hpp.

var stan::agrad::operator*	(	const var &	a,
		const double &	b
	)

inline

Multiplication operator for a variable and a scalar (C++).

The partial derivative for the variable is

$\frac{\partial}{\partial x} (x * c) = c$ , and

Parameters

a	Variable operand.
b	Scalar operand.

Returns: Variable result of multiplying operands.

Definition at line 1426 of file agrad_thread_safe.hpp.

var stan::agrad::operator*	(	const double &	a,
		const var &	b
	)

inline

Multiplication operator for a scalar and a variable (C++).

The partial derivative for the variable is

$\frac{\partial}{\partial y} (c * y) = c$ .

Parameters

a	Scalar operand.
b	Variable operand.

Returns: Variable result of multiplying the operands.

Definition at line 1441 of file agrad_thread_safe.hpp.

var stan::agrad::operator+	(	const var &	a,
		const double	b
	)

inline

Addition operator for variable and scalar (C++).

The derivative with respect to the variable is

$\frac{d}{dx} (x + c) = 1$ .

Parameters

a	First variable operand.
b	Second scalar operand.

Returns: Result of adding variable and scalar.

Definition at line 62 of file operator_addition.hpp.

var stan::agrad::operator+	(	const double	a,
		const var &	b
	)

inline

Addition operator for scalar and variable (C++).

The derivative with respect to the variable is

$\frac{d}{dy} (c + y) = 1$ .

Parameters

a	First scalar operand.
b	Second variable operand.

Returns: Result of adding variable and scalar.

Definition at line 79 of file operator_addition.hpp.

var stan::agrad::operator+ ( const var & a )

inline

Unary plus operator for variables (C++).

The function simply returns its input, because

$\frac{d}{dx} +x = \frac{d}{dx} x = 1$ .

The effect of unary plus on a built-in C++ scalar type is integer promotion. Because variables are all double-precision floating point already, promotion is not necessary.

Parameters

a	Argument variable.

Returns: The input reference.

Definition at line 1286 of file agrad_thread_safe.hpp.

var stan::agrad::operator+	(	const var &	a,
		const var &	b
	)

inline

Addition operator for variables (C++).

The partial derivatives are defined by

$\frac{\partial}{\partial x} (x+y) = 1$ , and

$\frac{\partial}{\partial y} (x+y) = 1$ .

Parameters

a	First variable operand.
b	Second variable operand.

Returns: Variable result of adding two variables.

Definition at line 1315 of file agrad_thread_safe.hpp.

var stan::agrad::operator+	(	const var &	a,
		const double &	b
	)

inline

Addition operator for variable and scalar (C++).

The derivative with respect to the variable is

$\frac{d}{dx} (x + c) = 1$ .

Parameters

a	First variable operand.
b	Second scalar operand.

Returns: Result of adding variable and scalar.

Definition at line 1331 of file agrad_thread_safe.hpp.

var stan::agrad::operator+	(	const double &	a,
		const var &	b
	)

inline

Addition operator for scalar and variable (C++).

The derivative with respect to the variable is

$\frac{d}{dy} (c + y) = 1$ .

Parameters

a	First scalar operand.
b	Second variable operand.

Returns: Result of adding variable and scalar.

Definition at line 1346 of file agrad_thread_safe.hpp.

var & stan::agrad::operator++ ( var & a )

inline

Prefix increment operator for variables (C++).

Following C++, (++a) is defined to behave exactly as (a = a + 1.0) does, but is faster and uses less memory. In particular, the result is an assignable lvalue.

Parameters

a	Variable to increment.

Returns: Reference the result of incrementing this input variable.

Definition at line 1502 of file agrad_thread_safe.hpp.

var stan::agrad::operator++	(	var &	a,
		int
	)

inline

Postfix increment operator for variables (C++).

Following C++, the expression (a++) i s defined to behave like the sequence of operations

var temp = a; a = a + 1.0; return temp;

Parameters

a	Variable to increment.
dummy	Unused dummy variable used to distinguish postfix operator from prefix operator.

Returns: Input variable.

Following C++, the expression (a++) is defined to behave like the sequence of operations

var temp = a; a = a + 1.0; return temp;

Parameters

a	Variable to increment.

Returns: Input variable.

Definition at line 1520 of file agrad_thread_safe.hpp.

var stan::agrad::operator-	(	const var &	a,
		const double	b
	)

inline

Subtraction operator for variable and scalar (C++).

The derivative for the variable is

$\frac{\partial}{\partial x} (x-c) = 1$ , and

Parameters

a	First variable operand.
b	Second scalar operand.

Returns: Result of subtracting the scalar from the variable.

Definition at line 74 of file operator_subtraction.hpp.

var stan::agrad::operator-	(	const double	a,
		const var &	b
	)

inline

Subtraction operator for scalar and variable (C++).

The derivative for the variable is

$\frac{\partial}{\partial y} (c-y) = -1$ , and

Parameters

a	First scalar operand.
b	Second variable operand.

Returns: Result of sutracting a variable from a scalar.

Definition at line 91 of file operator_subtraction.hpp.

var stan::agrad::operator- ( const var & a )

inline

Unary negation operator for variables (C++).

$\frac{d}{dx} -x = -1$ .

Parameters

a	Argument variable.

Returns: Negation of variable.

Definition at line 1298 of file agrad_thread_safe.hpp.

var stan::agrad::operator-	(	const var &	a,
		const var &	b
	)

inline

Subtraction operator for variables (C++).

The partial derivatives are defined by

$\frac{\partial}{\partial x} (x-y) = 1$ , and

$\frac{\partial}{\partial y} (x-y) = -1$ .

Parameters

a	First variable operand.
b	Second variable operand.

Returns: Variable result of subtracting the second variable from the first.

Definition at line 1364 of file agrad_thread_safe.hpp.

var stan::agrad::operator-	(	const var &	a,
		const double &	b
	)

inline

Subtraction operator for variable and scalar (C++).

The derivative for the variable is

$\frac{\partial}{\partial x} (x-c) = 1$ , and

Parameters

a	First variable operand.
b	Second scalar operand.

Returns: Result of subtracting the scalar from the variable.

Definition at line 1379 of file agrad_thread_safe.hpp.

var stan::agrad::operator-	(	const double &	a,
		const var &	b
	)

inline

Subtraction operator for scalar and variable (C++).

The derivative for the variable is

$\frac{\partial}{\partial y} (c-y) = -1$ , and

Parameters

a	First scalar operand.
b	Second variable operand.

Returns: Result of sutracting a variable from a scalar.

Definition at line 1394 of file agrad_thread_safe.hpp.

var & stan::agrad::operator-- ( var & a )

inline

Prefix decrement operator for variables (C++).

Following C++, (–a) is defined to behave exactly as

a = a - 1.0)

does, but is faster and uses less memory. In particular, the result is an assignable lvalue.

Parameters

a	Variable to decrement.

Returns: Reference the result of decrementing this input variable.

Definition at line 1539 of file agrad_thread_safe.hpp.

var stan::agrad::operator--	(	var &	a,
		int
	)

inline

Postfix decrement operator for variables (C++).

Following C++, the expression (a–) is defined to behave like the sequence of operations

var temp = a; a = a - 1.0; return temp;

Parameters

a	Variable to decrement.
dummy	Unused dummy variable used to distinguish suffix operator from prefix operator.

Returns: Input variable.

Following C++, the expression (a–) is defined to behave like the sequence of operations

var temp = a; a = a - 1.0; return temp;

Parameters

a	Variable to decrement.

Returns: Input variable.

Definition at line 1557 of file agrad_thread_safe.hpp.

var stan::agrad::operator/	(	const var &	a,
		const double	b
	)

inline

Division operator for dividing a variable by a scalar (C++).

The derivative with respect to the variable is

$\frac{\partial}{\partial x} (x/c) = 1/c$ .

Parameters

a	Variable operand.
b	Scalar operand.

Returns: Variable result of dividing the variable by the scalar.

Definition at line 75 of file operator_division.hpp.

var stan::agrad::operator/	(	const double	a,
		const var &	b
	)

inline

Division operator for dividing a scalar by a variable (C++).

The derivative with respect to the variable is

$\frac{d}{d y} (c/y) = -c / y^2$ .

Parameters

a	Scalar operand.
b	Variable operand.

Returns: Variable result of dividing the scalar by the variable.

Definition at line 92 of file operator_division.hpp.

var stan::agrad::operator/	(	const var &	a,
		const var &	b
	)

inline

Division operator for two variables (C++).

The partial derivatives for the variables are

$\frac{\partial}{\partial x} (x/y) = 1/y$ , and

$\frac{\partial}{\partial y} (x/y) = -x / y^2$ .

Parameters

a	First variable operand.
b	Second variable operand.

Returns: Variable result of dividing the first variable by the second.

Definition at line 1459 of file agrad_thread_safe.hpp.

var stan::agrad::operator/	(	const var &	a,
		const double &	b
	)

inline

Division operator for dividing a variable by a scalar (C++).

The derivative with respect to the variable is

$\frac{\partial}{\partial x} (x/c) = 1/c$ .

Parameters

a	Variable operand.
b	Scalar operand.

Returns: Variable result of dividing the variable by the scalar.

Definition at line 1474 of file agrad_thread_safe.hpp.

var stan::agrad::operator/	(	const double &	a,
		const var &	b
	)

inline

Division operator for dividing a scalar by a variable (C++).

The derivative with respect to the variable is

$\frac{d}{d y} (c/y) = -c / y^2$ .

Parameters

a	Scalar operand.
b	Variable operand.

Returns: Variable result of dividing the scalar by the variable.

Definition at line 1489 of file agrad_thread_safe.hpp.

bool stan::agrad::operator<	(	const var &	a,
		const double	b
	)

inline

Less than operator comparing variable's value and a double (C++).

Parameters

a	First variable.
b	Second value.

Returns: True if first variable's value is less than second value.

Definition at line 28 of file operator_less_than.hpp.

bool stan::agrad::operator<	(	const double	a,
		const var &	b
	)

inline

Less than operator comparing a double and variable's value (C++).

Parameters

a	First value.
b	Second variable.

Returns: True if first value is less than second variable's value.

Definition at line 40 of file operator_less_than.hpp.

bool stan::agrad::operator<	(	const var &	a,
		const var &	b
	)

inline

Less than operator comparing variables' values (C++).

Parameters

a	First variable.
b	Second variable.

Returns: True if first variable's value is less than second's.

Definition at line 1109 of file agrad_thread_safe.hpp.

bool stan::agrad::operator<	(	const var &	a,
		const double &	b
	)

inline

Less than operator comparing variable's value and a double (C++).

Parameters

a	First variable.
b	Second value.

Returns: True if first variable's value is less than second value.

Definition at line 1121 of file agrad_thread_safe.hpp.

bool stan::agrad::operator<	(	const double &	a,
		const var &	b
	)

inline

Less than operator comparing a double and variable's value (C++).

Parameters

a	First value.
b	Second variable.

Returns: True if first value is less than second variable's value.

Definition at line 1133 of file agrad_thread_safe.hpp.

bool stan::agrad::operator<=	(	const var &	a,
		const double	b
	)

inline

Less than or equal operator comparing a variable's value and a scalar (C++).

Parameters

a	First variable.
b	Second value.

Returns: True if first variable's value is less than or equal to the second value.

Definition at line 31 of file operator_less_than_or_equal.hpp.

bool stan::agrad::operator<=	(	const double	a,
		const var &	b
	)

inline

Less than or equal operator comparing a double and variable's value (C++).

Parameters

a	First value.
b	Second variable.

Returns: True if first value is less than or equal to the second variable's value.

Definition at line 44 of file operator_less_than_or_equal.hpp.

bool stan::agrad::operator<=	(	const var &	a,
		const var &	b
	)

inline

Less than or equal operator comparing two variables' values (C++).

Parameters

a	First variable.
b	Second variable.

Returns: True if first variable's value is less than or equal to the second's.

Definition at line 1181 of file agrad_thread_safe.hpp.

bool stan::agrad::operator<=	(	const var &	a,
		const double &	b
	)

inline

Less than or equal operator comparing a variable's value and a scalar (C++).

Parameters

a	First variable.
b	Second value.

Returns: True if first variable's value is less than or equal to the second value.

Definition at line 1194 of file agrad_thread_safe.hpp.

bool stan::agrad::operator<=	(	const double &	a,
		const var &	b
	)

inline

Less than or equal operator comparing a double and variable's value (C++).

Parameters

a	First value.
b	Second variable.

Returns: True if first value is less than or equal to the second variable's value.

Definition at line 1207 of file agrad_thread_safe.hpp.

bool stan::agrad::operator==	(	const var &	a,
		const double	b
	)

inline

Equality operator comparing a variable's value and a double (C++).

Parameters

a	First variable.
b	Second value.

Returns: True if the first variable's value is the same as the second value.

Definition at line 30 of file operator_equal.hpp.

bool stan::agrad::operator==	(	const double	a,
		const var &	b
	)

inline

Equality operator comparing a scalar and a variable's value (C++).

Parameters

a	First scalar.
b	Second variable.

Returns: True if the variable's value is equal to the scalar.

Definition at line 42 of file operator_equal.hpp.

bool stan::agrad::operator==	(	const var &	a,
		const var &	b
	)

inline

Equality operator comparing two variables' values (C++).

Parameters

a	First variable.
b	Second variable.

Returns: True if the first variable's value is the same as the second's.

Definition at line 1035 of file agrad_thread_safe.hpp.

bool stan::agrad::operator==	(	const var &	a,
		const double &	b
	)

inline

Equality operator comparing a variable's value and a double (C++).

Parameters

a	First variable.
b	Second value.

Returns: True if the first variable's value is the same as the second value.

Definition at line 1048 of file agrad_thread_safe.hpp.

bool stan::agrad::operator==	(	const double &	a,
		const var &	b
	)

inline

Equality operator comparing a scalar and a variable's value (C++).

Parameters

a	First scalar.
b	Second variable.

Returns: True if the variable's value is equal to the scalar.

Definition at line 1060 of file agrad_thread_safe.hpp.

bool stan::agrad::operator>	(	const var &	a,
		const double	b
	)

inline

Greater than operator comparing variable's value and double (C++).

Parameters

a	First variable.
b	Second value.

Returns: True if first variable's value is greater than second value.

Definition at line 28 of file operator_greater_than.hpp.

bool stan::agrad::operator>	(	const double	a,
		const var &	b
	)

inline

Greater than operator comparing a double and a variable's value (C++).

Parameters

a	First value.
b	Second variable.

Returns: True if first value is greater than second variable's value.

Definition at line 40 of file operator_greater_than.hpp.

bool stan::agrad::operator>	(	const var &	a,
		const var &	b
	)

inline

Greater than operator comparing variables' values (C++).

Parameters

a	First variable.
b	Second variable.

Returns: True if first variable's value is greater than second's.

Definition at line 1144 of file agrad_thread_safe.hpp.

bool stan::agrad::operator>	(	const var &	a,
		const double &	b
	)

inline

Greater than operator comparing variable's value and double (C++).

Parameters

a	First variable.
b	Second value.

Returns: True if first variable's value is greater than second value.

Definition at line 1156 of file agrad_thread_safe.hpp.

bool stan::agrad::operator>	(	const double &	a,
		const var &	b
	)

inline

Greater than operator comparing a double and a variable's value (C++).

Parameters

a	First value.
b	Second variable.

Returns: True if first value is greater than second variable's value.

Definition at line 1168 of file agrad_thread_safe.hpp.

bool stan::agrad::operator>=	(	const var &	a,
		const double	b
	)

inline

Greater than or equal operator comparing variable's value and double (C++).

Parameters

a	First variable.
b	Second value.

Returns: True if first variable's value is greater than or equal to second value.

Definition at line 31 of file operator_greater_than_or_equal.hpp.

bool stan::agrad::operator>=	(	const double	a,
		const var &	b
	)

inline

Greater than or equal operator comparing double and variable's value (C++).

Parameters

a	First value.
b	Second variable.

Returns: True if the first value is greater than or equal to the second variable's value.

Definition at line 44 of file operator_greater_than_or_equal.hpp.

bool stan::agrad::operator>=	(	const var &	a,
		const var &	b
	)

inline

Greater than or equal operator comparing two variables' values (C++).

Parameters

a	First variable.
b	Second variable.

Returns: True if first variable's value is greater than or equal to the second's.

Definition at line 1220 of file agrad_thread_safe.hpp.

bool stan::agrad::operator>=	(	const var &	a,
		const double &	b
	)

inline

Greater than or equal operator comparing variable's value and double (C++).

Parameters

a	First variable.
b	Second value.

Returns: True if first variable's value is greater than or equal to second value.

Definition at line 1233 of file agrad_thread_safe.hpp.

bool stan::agrad::operator>=	(	const double &	a,
		const var &	b
	)

inline

Greater than or equal operator comparing double and variable's value (C++).

Parameters

a	First value.
b	Second variable.

Returns: True if the first value is greater than or equal to the second variable's value.

Definition at line 1246 of file agrad_thread_safe.hpp.

var stan::agrad::owens_t	(	const var &	h,
		const var &	a
	)

inline

The Owen's T function of h and a.

Used to compute the cumulative density function for the skew normal distribution.

Parameters

h	var parameter.
a	var parameter.

Returns: The Owen's T function.

Definition at line 60 of file owens_t.hpp.

var stan::agrad::owens_t	(	const var &	h,
		const double &	a
	)

inline

The Owen's T function of h and a.

Used to compute the cumulative density function for the skew normal distribution.

Parameters

h	var parameter.
a	double parameter.

Returns: The Owen's T function.

Definition at line 76 of file owens_t.hpp.

var stan::agrad::owens_t	(	const double &	h,
		const var &	a
	)

inline

The Owen's T function of h and a.

Used to compute the cumulative density function for the skew normal distribution.

Parameters

h	double parameter.
a	var parameter.

Returns: The Owen's T function.

Definition at line 92 of file owens_t.hpp.

var stan::agrad::Phi ( const stan::agrad::var & a )

inline

The unit normal cumulative density function for variables (stan).

See stan::math::Phi() for the double-based version.

The derivative is the unit normal density function,

$\frac{d}{dx} \Phi(x) = \mbox{\sf Norm}(x|0,1) = \frac{1}{\sqrt{2\pi}} \exp(-\frac{1}{2} x^2)$ .

Parameters

a	Variable argument.

Returns: The unit normal cdf evaluated at the specified argument.

Definition at line 37 of file Phi.hpp.

var stan::agrad::Phi_approx ( const stan::agrad::var & a )

inline

Approximation of the unit normal CDF for variables (stan).

http://www.jiem.org/index.php/jiem/article/download/60/27

Parameters

a	Variable argument.

Returns: The corresponding unit normal cdf approximation.

Definition at line 19 of file Phi_approx.hpp.

var stan::agrad::pow	(	const var &	base,
		const double	exponent
	)

inline

Return the base variable raised to the power of the exponent scalar (cmath).

The derivative for the variable is

$\frac{d}{dx} \mbox{pow}(x,c) = c x^{c-1}$ .

Parameters

base	Base variable.
exponent	Exponent scalar.

Returns: Base raised to the exponent.

Definition at line 80 of file pow.hpp.

var stan::agrad::pow	(	const double	base,
		const var &	exponent
	)

inline

Return the base scalar raised to the power of the exponent variable (cmath).

The derivative for the variable is

$\frac{d}{d y} \mbox{pow}(c,y) = c^y \log c$ .

Parameters

base	Base scalar.
exponent	Exponent variable.

Returns: Base raised to the exponent.

Definition at line 102 of file pow.hpp.

var stan::agrad::pow	(	const var &	base,
		const var &	exponent
	)

inline

Return the base raised to the power of the exponent (cmath).

The partial derivatives are

$\frac{\partial}{\partial x} \mbox{pow}(x,y) = y x^{y-1}$ , and

$\frac{\partial}{\partial y} \mbox{pow}(x,y) = x^y \ \log x$ .

Parameters

base	Base variable.
exponent	Exponent variable.

Returns: Base raised to the exponent.

Definition at line 1633 of file agrad_thread_safe.hpp.

var stan::agrad::pow	(	const var &	base,
		const double &	exponent
	)

inline

Return the base variable raised to the power of the exponent scalar (cmath).

The derivative for the variable is

$\frac{d}{dx} \mbox{pow}(x,c) = c x^{c-1}$ .

Parameters

base	Base variable.
exponent	Exponent scalar.

Returns: Base raised to the exponent.

Definition at line 1649 of file agrad_thread_safe.hpp.

var stan::agrad::pow	(	const double &	base,
		const var &	exponent
	)

inline

Return the base scalar raised to the power of the exponent variable (cmath).

The derivative for the variable is

$\frac{d}{d y} \mbox{pow}(c,y) = c^y \log c$ .

Parameters

base	Base scalar.
exponent	Exponent variable.

Returns: Base raised to the exponent.

Definition at line 1665 of file agrad_thread_safe.hpp.

void stan::agrad::print_stack ( std::ostream & o )

inline

Prints the auto-dif variable stack.

This function is used for debugging purposes.

Only works if all members of stack are vari* as it casts to vari*.

Parameters

o	ostream to modify

Definition at line 20 of file print_stack.hpp.

static void stan::agrad::recover_memory ( )

static

static void stan::agrad::recover_memory ( )

static

Recover memory used for all variables for reuse.

Definition at line 37 of file var_stack.hpp.

var stan::agrad::round ( const stan::agrad::var & a )

inline

Returns the rounded form of the specified variable (C99).

See boost::math::round() for the double-based version.

The derivative is zero everywhere but numbers half way between whole numbers, so for convenience the derivative is defined to be everywhere zero,

$\frac{d}{dx} \mbox{round}(x) = 0$ .

Parameters

a	Specified variable.

Returns: Rounded variable.

Definition at line 35 of file round.hpp.

template<int R1, int C1, int R2, int C2>

Eigen::Matrix<var, R1, 1> stan::agrad::rows_dot_product	(	const Eigen::Matrix< var, R1, C1 > &	v1,
		const Eigen::Matrix< var, R2, C2 > &	v2
	)

inline

Definition at line 377 of file dot_product.hpp.

template<int R1, int C1, int R2, int C2>

Eigen::Matrix<var, R1, 1> stan::agrad::rows_dot_product	(	const Eigen::Matrix< var, R1, C1 > &	v1,
		const Eigen::Matrix< double, R2, C2 > &	v2
	)

inline

Definition at line 389 of file dot_product.hpp.

template<int R1, int C1, int R2, int C2>

Eigen::Matrix<var, R1, 1> stan::agrad::rows_dot_product	(	const Eigen::Matrix< double, R1, C1 > &	v1,
		const Eigen::Matrix< var, R2, C2 > &	v2
	)

inline

Definition at line 401 of file dot_product.hpp.

static void stan::agrad::set_zero_all_adjoints ( )

static

Reset all adjoint values in the stack to zero.

Definition at line 73 of file chainable.hpp.

var stan::agrad::sin ( const var & a )

inline

Return the sine of a radian-scaled variable (cmath).

The derivative is defined by

$\frac{d}{dx} \sin x = \cos x$ .

Parameters

a	Variable for radians of angle.

Returns: Sine of variable.

Definition at line 1696 of file agrad_thread_safe.hpp.

var stan::agrad::sinh ( const var & a )

inline

Return the hyperbolic sine of the specified variable (cmath).

The derivative is defined by

$\frac{d}{dx} \sinh x = \cosh x$ .

Parameters

a Variable.

Returns: Hyperbolic sine of variable.

Definition at line 1836 of file agrad_thread_safe.hpp.

var stan::agrad::sqrt ( const var & a )

inline

Return the square root of the specified variable (cmath).

The derivative is defined by

$\frac{d}{dx} \sqrt{x} = \frac{1}{2 \sqrt{x}}$ .

Parameters

a	Variable whose square root is taken.

Returns: Square root of variable.

Definition at line 1616 of file agrad_thread_safe.hpp.

var stan::agrad::square ( const var & x )

inline

Return the square of the input variable.

Using square(x) is more efficient than using x * x.

Parameters

x	Variable to square.

Returns: Square of variable.

Definition at line 31 of file square.hpp.

template<int R1, int C1, int R2, int C2>

var stan::agrad::squared_dist	(	const Eigen::Matrix< var, R1, C1 > &	v1,
		const Eigen::Matrix< var, R2, C2 > &	v2
	)

inline

Definition at line 94 of file dist.hpp.

template<int R1, int C1, int R2, int C2>

var stan::agrad::squared_dist	(	const Eigen::Matrix< var, R1, C1 > &	v1,
		const Eigen::Matrix< double, R2, C2 > &	v2
	)

inline

Definition at line 102 of file dist.hpp.

template<int R1, int C1, int R2, int C2>

var stan::agrad::squared_dist	(	const Eigen::Matrix< double, R1, C1 > &	v1,
		const Eigen::Matrix< var, R2, C2 > &	v2
	)

inline

Definition at line 110 of file dist.hpp.

void stan::agrad::stan_print	(	std::ostream *	o,
		const var &	x
	)

Definition at line 10 of file stan_print.hpp.

var stan::agrad::step ( const stan::agrad::var & a )

inline

Return the step, or heaviside, function applied to the specified variable (stan).

See stan::math::step() for the double-based version.

The derivative of the step function is zero everywhere but at 0, so for convenience, it is taken to be everywhere zero,

$\mbox{step}(x) = 0$ .

Parameters

a	Variable argument.

Returns: The constant variable with value 1.0 if the argument's value is greater than or equal to 0.0, and value 0.0 otherwise.

Definition at line 25 of file step.hpp.

template<int R, int C>

var stan::agrad::sum ( const Eigen::Matrix< var, R, C > & m )

inline

Returns the sum of the coefficients of the specified matrix, column vector or row vector.

Parameters

m	Specified matrix or vector.

Returns: Sum of coefficients of matrix.

Definition at line 68 of file sum.hpp.

var stan::agrad::tan ( const var & a )

inline

Return the tangent of a radian-scaled variable (cmath).

The derivative is defined by

$\frac{d}{dx} \tan x = \sec^2 x$ .

Parameters

a	Variable for radians of angle.

Returns: Tangent of variable.

Definition at line 1710 of file agrad_thread_safe.hpp.

var stan::agrad::tanh ( const var & a )

inline

Return the hyperbolic tangent of the specified variable (cmath).

The derivative is defined by

$\frac{d}{dx} \tanh x = \frac{1}{\cosh^2 x}$ .

Parameters

a Variable.

Returns: Hyperbolic tangent of variable.

Definition at line 1850 of file agrad_thread_safe.hpp.

matrix_v stan::agrad::tcrossprod ( const matrix_v & M )

inline

Returns the result of post-multiplying a matrix by its own transpose.

Parameters

M	Matrix to multiply.

Returns: M times its transpose.

Definition at line 27 of file tcrossprod.hpp.

var stan::agrad::tgamma ( const stan::agrad::var & a )

inline

Return the Gamma function applied to the specified variable (C99).

See boost::math::tgamma() for the double-based version.

The derivative with respect to the argument is

$\frac{d}{dx} \Gamma(x) = \Gamma(x) \Psi^{(0)}(x)$

where $\Psi^{(0)}(x)$ is the digamma function.

See boost::math::digamma() for the double-based version.

Parameters

a	Argument to function.

Returns: The Gamma function applied to the specified argument.

Definition at line 39 of file tgamma.hpp.

var stan::agrad::to_var ( const double & x )

inline

Converts argument to an automatic differentiation variable.

Returns a stan::agrad::var variable with the input value.

Parameters

[in] x A scalar value

Returns: An automatic differentiation variable with the input value.

Definition at line 21 of file to_var.hpp.

var stan::agrad::to_var ( const var & x )

inline

Converts argument to an automatic differentiation variable.

Returns a stan::agrad::var variable with the input value.

Parameters

[in] x An automatic differentiation variable.

Returns: An automatic differentiation variable with the input value.

Definition at line 32 of file to_var.hpp.

matrix_v stan::agrad::to_var ( const stan::math::matrix_d & m )

inline

Converts argument to an automatic differentiation variable.

Returns a stan::agrad::var variable with the input value.

Parameters

[in] m A Matrix with scalars

Returns: A Matrix with automatic differentiation variables

Definition at line 43 of file to_var.hpp.

matrix_v stan::agrad::to_var ( const matrix_v & m )

inline

Converts argument to an automatic differentiation variable.

Returns a stan::agrad::var variable with the input value.

Parameters

[in] m A Matrix with automatic differentiation variables.

Returns: A Matrix with automatic differentiation variables.

Definition at line 58 of file to_var.hpp.

vector_v stan::agrad::to_var ( const stan::math::vector_d & v )

inline

Converts argument to an automatic differentiation variable.

Returns a stan::agrad::var variable with the input value.

Parameters

[in] v A Vector of scalars

Returns: A Vector of automatic differentiation variables with values of v

Definition at line 70 of file to_var.hpp.

vector_v stan::agrad::to_var ( const vector_v & v )

inline

Converts argument to an automatic differentiation variable.

Returns a stan::agrad::var variable with the input value.

Parameters

[in] v A Vector of automatic differentiation variables

Returns: A Vector of automatic differentiation variables with values of v

Definition at line 85 of file to_var.hpp.

row_vector_v stan::agrad::to_var ( const stan::math::row_vector_d & rv )

inline

Converts argument to an automatic differentiation variable.

Returns a stan::agrad::var variable with the input value.

Parameters

[in] rv A row vector of scalars

Returns: A row vector of automatic differentation variables with values of rv.

Definition at line 97 of file to_var.hpp.

row_vector_v stan::agrad::to_var ( const row_vector_v & rv )

inline

Converts argument to an automatic differentiation variable.

Returns a stan::agrad::var variable with the input value.

Parameters

[in] rv A row vector with automatic differentiation variables

Returns: A row vector with automatic differentiation variables with values of rv.

Definition at line 112 of file to_var.hpp.

var stan::agrad::trunc ( const stan::agrad::var & a )

inline

Returns the truncatation of the specified variable (C99).

See boost::math::trunc() for the double-based version.

The derivative is zero everywhere but at integer values, so for convenience the derivative is defined to be everywhere zero,

$\frac{d}{dx} \mbox{trunc}(x) = 0$ .

Parameters

a	Specified variable.

Returns: Truncation of the variable.

Definition at line 34 of file trunc.hpp.

double stan::agrad::value_of ( const agrad::var & v )

inline

Return the value of the specified variable.

This function is used internally by auto-dif functions along with stan::math::value_of(T x) to extract the double value of either a scalar or an auto-dif variable. This function will be called when the argument is a stan::agrad::var even if the function is not referred to by namespace because of argument-dependent lookup.

Parameters

v Variable.

Returns: Value of variable.

Definition at line 22 of file value_of.hpp.

Variable Documentation

memory::stack_alloc stan::agrad::memalloc_

Definition at line 13 of file var_stack.cpp.

std::vector< chainable_alloc * > stan::agrad::var_alloc_stack_

Definition at line 12 of file var_stack.cpp.

std::vector< chainable * > stan::agrad::var_nochain_stack_

Definition at line 11 of file var_stack.cpp.

std::vector< chainable * > stan::agrad::var_stack_

Definition at line 10 of file var_stack.cpp.

Classes

Typedefs

Functions

Variables

Detailed Description

Typedef Documentation

Function Documentation

Variable Documentation