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

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

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

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

class	gevv_vvv_vari

class	mdivide_left_vv_vari

class	mdivide_left_dv_vari

class	mdivide_left_vd_vari

class	mdivide_left_tri_vv_vari

class	mdivide_left_tri_dv_vari

class	mdivide_left_tri_vd_vari

class	determinant_vari

class	log_determinant_vari

struct	needs_promotion

struct	assigner

struct	assigner< false, LHS, RHS >

struct	assigner< true, LHS, RHS >

class	partials_vari

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

Typedefs
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
static void	recover_memory ()
	Recover memory used for all variables for reuse.

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

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

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

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

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

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.

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

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

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

void	fill (var &x, const var &y)

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

template<int R, int C>
void	fill (Eigen::Matrix< var, R, C > &x, const var &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.

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.

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

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 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<int R, int C>
var	determinant (const Eigen::Matrix< var, R, C > &m)

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

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

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

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

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 >
void	assign (LHS &var, const RHS &val)

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

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	acosh (const stan::agrad::var &a)
	The inverse hyperbolic cosine function for variables (C99).

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

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

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

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	lgamma (const stan::agrad::var &a)
	The log gamma function for variables (C99).

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

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

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	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	log2 (const stan::agrad::var &a)
	Returns the base 2 logarithm of the specified variable (C99).

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

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

var	trunc (const stan::agrad::var &a)
	Returns the truncatation of the specified variable (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	tgamma (const stan::agrad::var &a)
	Return the Gamma function applied to the specified variable (C99).

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

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

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

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

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

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

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

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.

var	square (const var &x)
	Return the square of the input 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	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	ibeta (const var &a, const var &b, const var &x)
	The normalized incomplete beta function of a, b, and x.

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

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

Variables
std::vector< chainable * >	var_stack_

std::vector< chainable * >	var_nochain_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 261 of file matrix.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 277 of file matrix.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 269 of file matrix.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 2168 of file agrad.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 1895 of file agrad.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 661 of file special_functions.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 1611 of file special_functions.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 1910 of file agrad.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 677 of file special_functions.hpp.

template<typename LHS , typename RHS >

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

inline

Definition at line 1908 of file matrix.hpp.

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

inline

Definition at line 1848 of file matrix.hpp.

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

inline

Definition at line 1851 of file matrix.hpp.

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

inline

Definition at line 1855 of file matrix.hpp.

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

inline

Definition at line 1859 of file matrix.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 1864 of file matrix.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 1870 of file matrix.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 1925 of file agrad.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::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 1943 of file agrad.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 1959 of file agrad.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 1975 of file agrad.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 693 of file special_functions.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 1178 of file special_functions.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 2092 of file agrad.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 11 of file matrix_error_handling.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 756 of file matrix.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 769 of file matrix.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 782 of file matrix.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 745 of file matrix.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 1852 of file agrad.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 1991 of file agrad.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 1842 of file matrix.hpp.

template<int R, int C>

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

inline

Definition at line 1466 of file matrix.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 1523 of file matrix.hpp.

template<typename T1 , typename T2 >

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

inline

Definition at line 1528 of file matrix.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 1540 of file matrix.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 802 of file matrix.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 819 of file matrix.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 836 of file matrix.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 851 of file matrix.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 862 of file matrix.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 873 of file matrix.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 884 of file matrix.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 897 of file matrix.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 910 of file matrix.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 733 of file matrix.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 709 of file special_functions.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 725 of file special_functions.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 1735 of file agrad.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 741 of file special_functions.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 757 of file special_functions.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 2042 of file agrad.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 1241 of file special_functions.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 1266 of file special_functions.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 1289 of file special_functions.hpp.

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

Definition at line 13 of file matrix.hpp.

template<typename T >

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

Definition at line 17 of file matrix.hpp.

template<int R, int C>

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

Definition at line 22 of file matrix.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 2070 of file agrad.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 824 of file special_functions.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 848 of file special_functions.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 872 of file special_functions.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 894 of file special_functions.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 916 of file special_functions.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 938 of file special_functions.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 962 of file special_functions.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 986 of file special_functions.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 1007 of file special_functions.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 1028 of file special_functions.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 1046 of file special_functions.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 1065 of file special_functions.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 1086 of file special_functions.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.

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 2113 of file agrad.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 2130 of file agrad.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 2147 of file agrad.hpp.

static void stan::agrad::free_memory ( )

static

Return all memory used for gradients back to the system.

Definition at line 2191 of file agrad.hpp.

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 2207 of file agrad.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 21 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 1107 of file special_functions.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 1126 of file special_functions.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 1145 of file special_functions.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 1582 of file special_functions.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 1531 of file special_functions.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 1543 of file special_functions.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 1558 of file special_functions.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 283 of file matrix.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 292 of file matrix.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 301 of file matrix.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 1350 of file special_functions.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 1382 of file special_functions.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 2252 of file agrad.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 771 of file special_functions.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 1749 of file agrad.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 1763 of file agrad.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 800 of file special_functions.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 786 of file special_functions.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 1431 of file special_functions.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 1162 of file special_functions.hpp.

template<int R, int C>

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

inline

Definition at line 1510 of file matrix.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 1420 of file special_functions.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 1438 of file special_functions.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 1445 of file special_functions.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 1452 of file special_functions.hpp.

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

inline

Returns the log sum of exponentials.

Definition at line 1459 of file special_functions.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 1100 of file matrix.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 1124 of file matrix.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 1148 of file matrix.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 1360 of file matrix.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 1383 of file matrix.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 1406 of file matrix.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 1555 of file matrix.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 1566 of file matrix.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 1580 of file matrix.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 1596 of file matrix.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 1640 of file matrix.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 1685 of file matrix.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 1729 of file matrix.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 1745 of file matrix.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 1760 of file matrix.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 1489 of file special_functions.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 1502 of file special_functions.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 1516 of file special_functions.hpp.

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

inline

Definition at line 1767 of file matrix.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 1420 of file agrad.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.

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 1227 of file agrad.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 1240 of file agrad.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 1253 of file agrad.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 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 1573 of file agrad.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 1588 of file agrad.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 1605 of file agrad.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+ ( 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 1442 of file agrad.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 1471 of file agrad.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 1487 of file agrad.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 1504 of file agrad.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 1670 of file agrad.hpp.

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

inline

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

Returns: Input variable.

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.

Definition at line 1686 of file agrad.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- ( 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 1454 of file agrad.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 1524 of file agrad.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 1539 of file agrad.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 1556 of file agrad.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 1705 of file agrad.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.

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.
dummy	Unused dummy variable used to distinguish suffix operator from prefix operator.

Returns: Input variable.

Definition at line 1721 of file agrad.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.

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 1625 of file agrad.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 1640 of file agrad.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 1657 of file agrad.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 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 1264 of file agrad.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 1276 of file agrad.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 1288 of file agrad.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 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 1336 of file agrad.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 1349 of file agrad.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 1362 of file agrad.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 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 1190 of file agrad.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 1203 of file agrad.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 1215 of file agrad.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 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 1299 of file agrad.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 1311 of file agrad.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 1323 of file agrad.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.

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 1375 of file agrad.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 1388 of file agrad.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 1401 of file agrad.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 1366 of file special_functions.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 1394 of file special_functions.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.

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 1797 of file agrad.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 1813 of file agrad.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 1835 of file agrad.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 199 of file agrad.hpp.

static void stan::agrad::recover_memory ( )

static

Recover memory used for all variables for reuse.

Definition at line 2182 of file agrad.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 1196 of file special_functions.hpp.

static void stan::agrad::set_zero_all_adjoints ( )

static

Reset all adjoint values in the stack to zero.

Definition at line 2219 of file agrad.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 1866 of file agrad.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 2005 of file agrad.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 1780 of file agrad.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 1472 of file special_functions.hpp.

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

Definition at line 1912 of file matrix.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 1332 of file special_functions.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 923 of file matrix.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 1880 of file agrad.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 2019 of file agrad.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 1804 of file matrix.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 1312 of file special_functions.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 315 of file matrix.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 326 of file matrix.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 337 of file matrix.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 352 of file matrix.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 364 of file matrix.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 379 of file matrix.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 391 of file matrix.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 406 of file matrix.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 1213 of file special_functions.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 1601 of file special_functions.hpp.

Variable Documentation

memory::stack_alloc stan::agrad::memalloc_

Definition at line 12 of file agrad.cpp.

std::vector< chainable * > stan::agrad::var_nochain_stack_

Definition at line 11 of file agrad.cpp.

std::vector< chainable * > stan::agrad::var_stack_

Definition at line 10 of file agrad.cpp.

Classes

Typedefs

Functions

Variables

Detailed Description

Typedef Documentation

Function Documentation

Variable Documentation