Matrices and templated mathematical functions. More...

Namespaces
namespace	policies
	Extending boost functionality.

Classes
struct	promoter

struct	promoter< T, T >

struct	promoter< std::vector< F >, std::vector< T > >

struct	promoter< std::vector< T >, std::vector< T > >

struct	promoter< Eigen::Matrix< F, R, C >, Eigen::Matrix< T, R, C > >

struct	promoter< Eigen::Matrix< T, R, C >, Eigen::Matrix< T, R, C > >

struct	common_type

struct	common_type< std::vector< T1 >, std::vector< T2 > >

struct	common_type< Eigen::Matrix< T1, R, C >, Eigen::Matrix< T2, R, C > >

struct	array_builder
	Structure for building up arrays in an expression (rather than in statements) using an argumentchaining add() method and a getter method array() to return the result. More...

Typedefs
typedef boost::math::policies::policy	default_policy
	Default error-handling policy from Boost.

typedef Eigen::Matrix< double, Eigen::Dynamic, Eigen::Dynamic >	matrix_d
	Type for matrix of double values.

typedef Eigen::Matrix< double, Eigen::Dynamic, 1 >	vector_d
	Type for (column) vector of double values.

typedef Eigen::Matrix< double, 1, Eigen::Dynamic >	row_vector_d
	Type for (row) vector of double values.

Functions
template<typename T_y , typename T_result , class Policy >
bool	check_not_nan (const char function, const T_y &y, const char name, T_result *result, const Policy &)
	Checks if the variable y is nan.

template<typename T_y , typename T_result >
bool	check_not_nan (const char function, const T_y &y, const char name, T_result *result=0)
	Checks if the variable y is nan.

template<typename T >
bool	check_not_nan (const char function, const T &y, const char name)

template<typename T_y , typename T_result , class Policy >
bool	check_finite (const char function, const T_y &y, const char name, T_result *result, const Policy &)
	Checks if the variable y is finite.

template<typename T_y , typename T_result >
bool	check_finite (const char function, const T_y &y, const char name, T_result *result)

template<typename T >
bool	check_finite (const char function, const T &y, const char name)

template<typename T_y , typename T_low , typename T_result , class Policy >
bool	check_greater (const char function, const T_y &y, const T_low &low, const char name, T_result *result, const Policy &)

template<typename T_y , typename T_low , typename T_result >
bool	check_greater (const char function, const T_y &y, const T_low &low, const char name, T_result *result)

template<typename T_y , typename T_low >
bool	check_greater (const char function, const T_y &y, const T_low &low, const char name)

template<typename T_y , typename T_low , typename T_result , class Policy >
bool	check_greater_or_equal (const char function, const T_y &y, const T_low &low, const char name, T_result *result, const Policy &)

template<typename T_y , typename T_low , typename T_result >
bool	check_greater_or_equal (const char function, const T_y &y, const T_low &low, const char name, T_result *result)

template<typename T_y , typename T_low >
bool	check_greater_or_equal (const char function, const T_y &y, const T_low &low, const char name)

template<typename T_y , typename T_high , typename T_result , class Policy >
bool	check_less (const char function, const T_y &y, const T_high &high, const char name, T_result *result, const Policy &)

template<typename T_y , typename T_high , typename T_result >
bool	check_less (const char function, const T_y &y, const T_high &high, const char name, T_result *result)

template<typename T_y , typename T_high >
bool	check_less (const char function, const T_y &y, const T_high &high, const char name)

template<typename T_y , typename T_high , typename T_result , class Policy >
bool	check_less_or_equal (const char function, const T_y &y, const T_high &high, const char name, T_result *result, const Policy &)

template<typename T_y , typename T_high , typename T_result >
bool	check_less_or_equal (const char function, const T_y &y, const T_high &high, const char name, T_result *result)

template<typename T_y , typename T_high >
bool	check_less_or_equal (const char function, const T_y &y, const T_high &high, const char name)

template<typename T_y , typename T_low , typename T_high , typename T_result , class Policy >
bool	check_bounded (const char function, const T_y &y, const T_low &low, const T_high &high, const char name, T_result *result, const Policy &)

template<typename T_y , typename T_low , typename T_high , typename T_result >
bool	check_bounded (const char function, const T_y &y, const T_low &low, const T_high &high, const char name, T_result *result)

template<typename T_y , typename T_low , typename T_high >
bool	check_bounded (const char function, const T_y &y, const T_low &low, const T_high &high, const char name)

template<typename T_y , typename T_result , class Policy >
bool	check_nonnegative (const char function, const T_y &y, const char name, T_result *result, const Policy &)

template<typename T_y , typename T_result >
bool	check_nonnegative (const char function, const T_y &y, const char name, T_result *result)

template<typename T_y >
bool	check_nonnegative (const char function, const T_y &y, const char name)

template<typename T_y , typename T_result , class Policy >
bool	check_positive (const char function, const T_y &y, const char name, T_result *result, const Policy &)

template<typename T_x , typename T_result >
bool	check_positive (const char function, const T_x &x, const char name, T_result *result)

template<typename T >
bool	check_positive (const char function, const T &x, const char name)

template<typename T , typename T_result , class Policy >
bool	check_consistent_size (size_t max_size, const char function, const T &x, const char name, T_result *result, const Policy &)

template<typename T1 , typename T2 , typename T_result , class Policy >
bool	check_consistent_sizes (const char function, const T1 &x1, const T2 &x2, const char name1, const char name2, T_result result, const Policy &)

template<typename T1 , typename T2 , typename T_result >
bool	check_consistent_sizes (const char function, const T1 &x1, const T2 &x2, const char name1, const char name2, T_result result)

template<typename T1 , typename T2 , typename T3 , typename T_result , class Policy >
bool	check_consistent_sizes (const char function, const T1 &x1, const T2 &x2, const T3 &x3, const char name1, const char name2, const char name3, T_result *result, const Policy &)

template<typename T1 , typename T2 , typename T3 , typename T_result >
bool	check_consistent_sizes (const char function, const T1 &x1, const T2 &x2, const T3 &x3, const char name1, const char name2, const char name3, T_result *result)

template<typename T1 , typename T2 , typename T3 , typename T4 , typename T_result , class Policy >
bool	check_consistent_sizes (const char function, const T1 &x1, const T2 &x2, const T3 &x3, const T4 &x4, const char name1, const char name2, const char name3, const char name4, T_result result, const Policy &)

template<typename T1 , typename T2 , typename T3 , typename T4 , typename T_result >
bool	check_consistent_sizes (const char function, const T1 &x1, const T2 &x2, const T3 &x3, const T4 &x4, const char name1, const char name2, const char name3, const char name4, T_result result)

template<typename T1 , typename T2 , typename F >
common_type< T1, T2 >::type	promote_common (const F &u)

template<typename T >
void	resize (T &x, std::vector< size_t > dims)
	Recursively resize the specified vector of vectors, which must bottom out at scalar values, Eigen vectors or Eigen matrices.

template<typename T >
T &	get_base1 (std::vector< T > &x, size_t i, const char *error_msg, size_t idx)
	Return a reference to the value of the specified vector at the specified base-one index.

template<typename T >
T &	get_base1 (std::vector< std::vector< T > > &x, size_t i1, size_t i2, const char *error_msg, size_t idx)
	Return a reference to the value of the specified vector at the specified base-one indexes.

template<typename T >
T &	get_base1 (std::vector< std::vector< std::vector< T > > > &x, size_t i1, size_t i2, size_t i3, const char *error_msg, size_t idx)
	Return a reference to the value of the specified vector at the specified base-one indexes.

template<typename T >
T &	get_base1 (std::vector< std::vector< std::vector< std::vector< T > > > > &x, size_t i1, size_t i2, size_t i3, size_t i4, const char *error_msg, size_t idx)
	Return a reference to the value of the specified vector at the specified base-one indexes.

template<typename T >
T &	get_base1 (std::vector< std::vector< std::vector< std::vector< std::vector< T > > > > > &x, size_t i1, size_t i2, size_t i3, size_t i4, size_t i5, const char *error_msg, size_t idx)
	Return a reference to the value of the specified vector at the specified base-one indexes.

template<typename T >
T &	get_base1 (std::vector< std::vector< std::vector< std::vector< std::vector< std::vector< T > > > > > > &x, size_t i1, size_t i2, size_t i3, size_t i4, size_t i5, size_t i6, const char *error_msg, size_t idx)
	Return a reference to the value of the specified vector at the specified base-one indexes.

template<typename T >
T &	get_base1 (std::vector< std::vector< std::vector< std::vector< std::vector< std::vector< std::vector< T > > > > > > > &x, size_t i1, size_t i2, size_t i3, size_t i4, size_t i5, size_t i6, size_t i7, const char *error_msg, size_t idx)
	Return a reference to the value of the specified vector at the specified base-one indexes.

template<typename T >
T &	get_base1 (std::vector< std::vector< std::vector< std::vector< std::vector< std::vector< std::vector< std::vector< T > > > > > > > > &x, size_t i1, size_t i2, size_t i3, size_t i4, size_t i5, size_t i6, size_t i7, size_t i8, const char *error_msg, size_t idx)
	Return a reference to the value of the specified vector at the specified base-one indexes.

template<typename T >
Eigen::Matrix< T, 1, Eigen::Dynamic >	get_base1 (Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > &x, size_t m, const char *error_msg, size_t idx)
	Return a copy of the row of the specified vector at the specified base-one row index.

template<typename T >
T &	get_base1 (Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > &x, size_t m, size_t n, const char *error_msg, size_t idx)
	Return a reference to the value of the specified matrix at the specified base-one row and column indexes.

template<typename T >
T &	get_base1 (Eigen::Matrix< T, Eigen::Dynamic, 1 > &x, size_t m, const char *error_msg, size_t idx)
	Return a reference to the value of the specified column vector at the specified base-one index.

template<typename T >
T &	get_base1 (Eigen::Matrix< T, 1, Eigen::Dynamic > &x, size_t n, const char *error_msg, size_t idx)
	Return a reference to the value of the specified row vector at the specified base-one index.

template<typename T , int R, int C>
size_t	rows (const Eigen::Matrix< T, R, C > &m)

template<typename T , int R, int C>
size_t	cols (const Eigen::Matrix< T, R, C > &m)

template<typename T1 , typename T2 >
void	validate_less_or_equal (const T1 &x, const T2 &y, const char x_name, const char y_name, const char *fun_name)

template<typename T1 , typename T2 >
void	validate_less (const T1 &x, const T2 &y, const char x_name, const char y_name, const char *fun_name)

template<typename T1 , typename T2 >
void	validate_greater_or_equal (const T1 &x, const T2 &y, const char x_name, const char y_name, const char *fun_name)

template<typename T1 , typename T2 >
void	validate_greater (const T1 &x, const T2 &y, const char x_name, const char y_name, const char *fun_name)

template<typename T , int R, int C>
void	validate_column_index (const Eigen::Matrix< T, R, C > &m, size_t j, const char *msg)

template<typename T , int R, int C>
void	validate_row_index (const Eigen::Matrix< T, R, C > &m, size_t i, const char *msg)

template<typename T , int R, int C>
void	validate_square (const Eigen::Matrix< T, R, C > &x, const char *msg)

template<typename T , int R, int C>
void	validate_symmetric (const Eigen::Matrix< T, R, C > &x, const char *msg)

template<typename T1 , int R1, int C1, typename T2 , int R2, int C2>
void	validate_matching_dims (const Eigen::Matrix< T1, R1, C1 > &x1, const Eigen::Matrix< T2, R2, C2 > &x2, const char *msg)

template<typename T1 , typename T2 >
void	validate_matching_sizes (const std::vector< T1 > &x1, const std::vector< T2 > &x2, const char *msg)

template<typename T1 , int R1, int C1, typename T2 , int R2, int C2>
void	validate_matching_sizes (const Eigen::Matrix< T1, R1, C1 > &x1, const Eigen::Matrix< T2, R2, C2 > &x2, const char *msg)

template<typename T1 , int R1, int C1, typename T2 , int R2, int C2>
void	validate_multiplicable (const Eigen::Matrix< T1, R1, C1 > &x1, const Eigen::Matrix< T2, R2, C2 > &x2, const char *msg)

template<typename T >
void	validate_nonzero_size (const T &x, const char *msg)

template<typename T , int R, int C>
void	validate_vector (const Eigen::Matrix< T, R, C > &x, const char *msg)

template<typename T , int R, int C>
T	determinant (const Eigen::Matrix< T, R, C > &m)
	Returns the determinant of the specified square matrix.

template<typename T , int R, int C>
T	log_determinant (const Eigen::Matrix< T, R, C > &m)
	Returns the log absolute determinant of the specified square matrix.

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

template<typename T , int R, int C>
Eigen::Matrix< T, 1, C >	columns_dot_self (const Eigen::Matrix< T, 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< double, 1, C1 >	columns_dot_product (const Eigen::Matrix< double, R1, C1 > &v1, const Eigen::Matrix< double, R2, C2 > &v2)
	Returns the dot product of the specified vectors.

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

double	dot_product (const double v1, const double v2, size_t length)
	Returns the dot product of the specified arrays of doubles.

double	dot_product (const std::vector< double > &v1, const std::vector< double > &v2)
	Returns the dot product of the specified arrays of doubles.

int	min (const std::vector< int > &x)
	Returns the minimum coefficient in the specified column vector.

template<typename T >
T	min (const std::vector< T > &x)
	Returns the minimum coefficient in the specified column vector.

template<typename T , int R, int C>
T	min (const Eigen::Matrix< T, R, C > &m)
	Returns the minimum coefficient in the specified matrix, vector, or row vector.

int	max (const std::vector< int > &x)
	Returns the maximum coefficient in the specified column vector.

template<typename T >
T	max (const std::vector< T > &x)
	Returns the maximum coefficient in the specified column vector.

template<typename T , int R, int C>
T	max (const Eigen::Matrix< T, R, C > &m)
	Returns the maximum coefficient in the specified vector, row vector, or matrix.

template<typename T >
boost::math::tools::promote_args < T >::type	mean (const std::vector< T > &v)
	Returns the sample mean (i.e., average) of the coefficients in the specified standard vector.

template<typename T , int R, int C>
boost::math::tools::promote_args < T >::type	mean (const Eigen::Matrix< T, R, C > &m)
	Returns the sample mean (i.e., average) of the coefficients in the specified vector, row vector, or matrix.

template<typename T >
boost::math::tools::promote_args < T >::type	variance (const std::vector< T > &v)
	Returns the sample variance (divide by length - 1) of the coefficients in the specified standard vector.

template<typename T , int R, int C>
boost::math::tools::promote_args < T >::type	variance (const Eigen::Matrix< T, R, C > &m)
	Returns the sample variance (divide by length - 1) of the coefficients in the specified column vector.

template<typename T >
boost::math::tools::promote_args < T >::type	sd (const std::vector< T > &v)
	Returns the unbiased sample standard deviation of the coefficients in the specified column vector.

template<typename T , int R, int C>
boost::math::tools::promote_args < T >::type	sd (const Eigen::Matrix< T, R, C > &m)
	Returns the unbiased sample standard deviation of the coefficients in the specified vector, row vector, or matrix.

template<typename T >
T	sum (const std::vector< T > &xs)
	Return the sum of the values in the specified standard vector.

template<typename T , int R, int C>
double	sum (const Eigen::Matrix< T, R, C > &v)
	Returns the sum of the coefficients of the specified column vector.

template<typename T >
T	prod (const std::vector< T > &v)
	Returns the product of the coefficients of the specified standard vector.

template<typename T , int R, int C>
T	prod (const Eigen::Matrix< T, R, C > &v)
	Returns the product of the coefficients of the specified column vector.

template<typename T >
T	trace (const Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > &m)
	Returns the trace of the specified matrix.

template<typename T , int Rows, int Cols>
Eigen::Matrix< T, Rows, Cols >	log (const Eigen::Matrix< T, Rows, Cols > &m)
	Return the element-wise logarithm of the matrix or vector.

template<typename T , int Rows, int Cols>
Eigen::Matrix< T, Rows, Cols >	exp (const Eigen::Matrix< T, Rows, Cols > &m)
	Return the element-wise exponentiation of the matrix or vector.

template<typename T1 , typename T2 , int R, int C>
Eigen::Matrix< typename boost::math::tools::promote_args < T1, T2 >::type, R, C >	add (const Eigen::Matrix< T1, R, C > &m1, const Eigen::Matrix< T2, R, C > &m2)
	Return the sum of the specified matrices.

template<typename T1 , typename T2 , int R, int C>
Eigen::Matrix< typename boost::math::tools::promote_args < T1, T2 >::type, R, C >	add (const Eigen::Matrix< T1, R, C > &m, const T2 &c)
	Return the sum of the specified matrix and specified scalar.

template<typename T1 , typename T2 , int R, int C>
Eigen::Matrix< typename boost::math::tools::promote_args < T1, T2 >::type, R, C >	add (const T1 &c, const Eigen::Matrix< T2, R, C > &m)
	Return the sum of the specified scalar and specified matrix.

template<typename T1 , typename T2 , int R, int C>
Eigen::Matrix< typename boost::math::tools::promote_args < T1, T2 >::type, R, C >	subtract (const Eigen::Matrix< T1, R, C > &m1, const Eigen::Matrix< T2, R, C > &m2)
	Return the result of subtracting the second specified matrix from the first specified matrix.

template<typename T1 , typename T2 , int R, int C>
Eigen::Matrix< typename boost::math::tools::promote_args < T1, T2 >::type, R, C >	subtract (const T1 &c, const Eigen::Matrix< T2, R, C > &m)

template<typename T1 , typename T2 , int R, int C>
Eigen::Matrix< typename boost::math::tools::promote_args < T1, T2 >::type, R, C >	subtract (const Eigen::Matrix< T1, R, C > &m, const T2 &c)

template<typename T >
T	minus (const T &x)
	Returns the negation of the specified scalar or matrix.

template<int R, int C>
Eigen::Matrix< double, R, C >	divide (const Eigen::Matrix< double, R, C > &m, double c)
	Return specified matrix divided by specified scalar.

template<typename T1 , typename T2 , int R, int C>
Eigen::Matrix< typename boost::math::tools::promote_args < T1, T2 >::type, R, C >	elt_multiply (const Eigen::Matrix< T1, R, C > &m1, const Eigen::Matrix< T2, R, C > &m2)
	Return the elementwise multiplication of the specified matrices.

template<typename T1 , typename T2 , int R1, int C1, int R2, int C2>
Eigen::Matrix< typename boost::math::tools::promote_args < T1, T2 >::type, R2, C2 >	diag_pre_multiply (const Eigen::Matrix< T1, R1, C1 > &m1, const Eigen::Matrix< T2, R2, C2 > &m2)

template<typename T1 , typename T2 , int R1, int C1, int R2, int C2>
Eigen::Matrix< typename boost::math::tools::promote_args < T1, T2 >::type, R1, C1 >	diag_post_multiply (const Eigen::Matrix< T1, R1, C1 > &m1, const Eigen::Matrix< T2, R2, C2 > &m2)

template<typename T1 , typename T2 , int R, int C>
Eigen::Matrix< typename boost::math::tools::promote_args < T1, T2 >::type, R, C >	elt_divide (const Eigen::Matrix< T1, R, C > &m1, const Eigen::Matrix< T2, R, C > &m2)
	Return the elementwise division of the specified matrices matrices.

template<int R, int C>
Eigen::Matrix< double, R, C >	multiply (const Eigen::Matrix< double, R, C > &m, double c)
	Return specified matrix multiplied by specified scalar.

template<int R, int C>
Eigen::Matrix< double, R, C >	multiply (double c, const Eigen::Matrix< double, R, C > &m)
	Return specified scalar multiplied by specified matrix.

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

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

matrix_d	multiply_lower_tri_self_transpose (const matrix_d &L)
	Returns the result of multiplying the lower triangular portion of the input matrix by its own transpose.

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

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

template<typename T >
Eigen::Matrix< T, 1, Eigen::Dynamic >	row (const Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > &m, size_t i)
	Return the specified row of the specified matrix, using start-at-1 indexing.

template<typename T >
Eigen::Matrix< T, Eigen::Dynamic, 1 >	col (const Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > &m, size_t j)
	Return the specified column of the specified matrix using start-at-1 indexing.

template<typename T >
Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic >	block (const Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > &m, size_t i, size_t j, size_t nrows, size_t ncols)
	Return a nrows x ncols submatrix starting at (i,j).

template<typename T >
Eigen::Matrix< T, Eigen::Dynamic, 1 >	diagonal (const Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > &m)
	Return a column vector of the diagonal elements of the specified matrix.

template<typename T >
Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic >	diag_matrix (const Eigen::Matrix< T, Eigen::Dynamic, 1 > &v)
	Return a square diagonal matrix with the specified vector of coefficients as the diagonal values.

template<typename T , int R, int C>
Eigen::Matrix< T, C, R >	transpose (const Eigen::Matrix< T, R, C > &m)

template<typename T >
Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic >	inverse (const Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > &m)
	Returns the inverse of the specified matrix.

template<typename T >
Eigen::Matrix< T, Eigen::Dynamic, 1 >	softmax (const Eigen::Matrix< T, Eigen::Dynamic, 1 > &v)
	Return the softmax of the specified vector.

template<int TriView, typename T1 , typename T2 , int R1, int C1, int R2, int C2>
Eigen::Matrix< typename boost::math::tools::promote_args < T1, T2 >::type, R1, C2 >	mdivide_left_tri (const Eigen::Matrix< T1, R1, C1 > &A, const Eigen::Matrix< T2, R2, C2 > &b)
	Returns the solution of the system Ax=b when A is triangular.

template<int TriView, typename T , int R1, int C1>
Eigen::Matrix< T, R1, C1 >	mdivide_left_tri (const Eigen::Matrix< T, R1, C1 > &A)
	Returns the solution of the system Ax=b when A is triangular and b=I.

template<typename T1 , typename T2 , int R1, int C1, int R2, int C2>
Eigen::Matrix< typename boost::math::tools::promote_args < T1, T2 >::type, R1, C2 >	mdivide_left_tri_low (const Eigen::Matrix< T1, R1, C1 > &A, const Eigen::Matrix< T2, R2, C2 > &b)

template<typename T , int R1, int C1>
Eigen::Matrix< T, R1, C1 >	mdivide_left_tri_low (const Eigen::Matrix< T, R1, C1 > &A)

template<typename T1 , typename T2 , int R1, int C1, int R2, int C2>
Eigen::Matrix< typename boost::math::tools::promote_args < T1, T2 >::type, R1, C2 >	mdivide_left (const Eigen::Matrix< T1, R1, C1 > &A, const Eigen::Matrix< T2, R2, C2 > &b)
	Returns the solution of the system Ax=b.

template<int TriView, typename T1 , typename T2 , int R1, int C1, int R2, int C2>
Eigen::Matrix< typename boost::math::tools::promote_args < T1, T2 >::type, R1, C2 >	mdivide_right_tri (const Eigen::Matrix< T1, R1, C1 > &b, const Eigen::Matrix< T2, R2, C2 > &A)
	Returns the solution of the system Ax=b when A is triangular.

template<typename T1 , typename T2 , int R1, int C1, int R2, int C2>
Eigen::Matrix< typename boost::math::tools::promote_args < T1, T2 >::type, R1, C2 >	mdivide_right_tri_low (const Eigen::Matrix< T1, R1, C1 > &b, const Eigen::Matrix< T2, R2, C2 > &A)
	Returns the solution of the system tri(A)x=b when tri(A) is a lower triangular view of the matrix A.

template<typename T1 , typename T2 , int R1, int C1, int R2, int C2>
Eigen::Matrix< typename boost::math::tools::promote_args < T1, T2 >::type, R1, C2 >	mdivide_right (const Eigen::Matrix< T1, R1, C1 > &b, const Eigen::Matrix< T2, R2, C2 > &A)
	Returns the solution of the system Ax=b.

template<typename T >
Eigen::Matrix< T, Eigen::Dynamic, 1 >	eigenvalues_sym (const Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > &m)
	Return the eigenvalues of the specified symmetric matrix in descending order of magnitude.

template<typename T >
Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic >	eigenvectors_sym (const Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > &m)

template<typename T >
Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic >	cholesky_decompose (const Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > &m)
	Return the lower-triangular Cholesky factor (i.e., matrix square root) of the specified square, symmetric matrix.

template<typename T >
Eigen::Matrix< T, Eigen::Dynamic, 1 >	singular_values (const Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > &m)
	Return the vector of the singular values of the specified matrix in decreasing order of magnitude.

void	validate_non_negative_index (const std::string &var_name, const std::string &expr, int val)

template<typename T_size1 , typename T_size2 , typename T_result , class Policy >
bool	check_size_match (const char function, T_size1 i, const char name_i, T_size2 j, const char name_j, T_result result, const Policy &)

template<typename T_size1 , typename T_size2 , typename T_result >
bool	check_size_match (const char function, T_size1 i, const char name_i, T_size2 j, const char name_j, T_result result)

template<typename T_size1 , typename T_size2 >
bool	check_size_match (const char function, T_size1 i, const char name_i, T_size2 j, const char name_j, T_size1 result=0)

template<typename T_y , typename T_result , class Policy >
bool	check_symmetric (const char function, const Eigen::Matrix< T_y, Eigen::Dynamic, Eigen::Dynamic > &y, const char name, T_result *result, const Policy &)
	Return `true` if the specified matrix is symmetric.

template<typename T_y , typename T_result >
bool	check_symmetric (const char function, const Eigen::Matrix< T_y, Eigen::Dynamic, Eigen::Dynamic > &y, const char name, T_result *result)

template<typename T >
bool	check_symmetric (const char function, const Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > &y, const char name, T *result=0)

template<typename T_y , typename T_result , class Policy >
bool	check_pos_definite (const char function, const Eigen::Matrix< T_y, Eigen::Dynamic, Eigen::Dynamic > &y, const char name, T_result *result, const Policy &)
	Return `true` if the specified matrix is positive definite.

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

template<typename T >
bool	check_pos_definite (const char function, const Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > &y, const char name, T *result=0)

template<typename T_y , typename T_result , class Policy >
bool	check_cov_matrix (const char function, const Eigen::Matrix< T_y, Eigen::Dynamic, Eigen::Dynamic > &y, const char name, T_result *result, const Policy &)
	Return `true` if the specified matrix is a valid covariance matrix.

template<typename T_y , typename T_result >
bool	check_cov_matrix (const char function, const Eigen::Matrix< T_y, Eigen::Dynamic, Eigen::Dynamic > &y, const char name, T_result *result)

template<typename T >
bool	check_cov_matrix (const char function, const Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > &y, const char name, T *result=0)

template<typename T_y , typename T_result , class Policy >
bool	check_corr_matrix (const char function, const Eigen::Matrix< T_y, Eigen::Dynamic, Eigen::Dynamic > &y, const char name, T_result *result, const Policy &)
	Return `true` if the specified matrix is a valid correlation matrix.

template<typename T_y , typename T_result >
bool	check_corr_matrix (const char function, const Eigen::Matrix< T_y, Eigen::Dynamic, Eigen::Dynamic > &y, const char name, T_result *result)

template<typename T >
bool	check_corr_matrix (const char function, const Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > &y, const char name, T *result=0)

template<typename T_covar , typename T_result , class Policy >
bool	check_cov_matrix (const char function, const Eigen::Matrix< T_covar, Eigen::Dynamic, Eigen::Dynamic > &Sigma, T_result result, const Policy &)
	Return `true` if the specified matrix is a valid covariance matrix.

template<typename T_covar , typename T_result >
bool	check_cov_matrix (const char function, const Eigen::Matrix< T_covar, Eigen::Dynamic, Eigen::Dynamic > &Sigma, T_result result)

template<typename T >
bool	check_cov_matrix (const char function, const Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > &Sigma, T result=0)

template<typename T_prob , typename T_result , class Policy >
bool	check_simplex (const char function, const Eigen::Matrix< T_prob, Eigen::Dynamic, 1 > &theta, const char name, T_result *result, const Policy &)
	Return `true` if the specified vector is simplex.

template<typename T_y , typename T_result >
bool	check_simplex (const char function, const Eigen::Matrix< T_y, Eigen::Dynamic, 1 > &theta, const char name, T_result *result)

template<typename T >
bool	check_simplex (const char function, const Eigen::Matrix< T, Eigen::Dynamic, 1 > &theta, const char name, T *result=0)

template<typename T_y , typename T_result , class Policy >
bool	check_ordered (const char function, const Eigen::Matrix< T_y, Eigen::Dynamic, 1 > &y, const char name, T_result *result, const Policy &)
	Return `true` if the specified vector is sorted into increasing order.

template<typename T_y , typename T_result >
bool	check_ordered (const char function, const Eigen::Matrix< T_y, Eigen::Dynamic, 1 > &y, const char name, T_result *result)

template<typename T >
bool	check_ordered (const char function, const Eigen::Matrix< T, Eigen::Dynamic, 1 > &y, const char name, T *result=0)

template<typename T_y , typename T_result , class Policy >
bool	check_positive_ordered (const char function, const Eigen::Matrix< T_y, Eigen::Dynamic, 1 > &y, const char name, T_result *result, const Policy &)
	Return `true` if the specified vector contains only non-negative values and is sorted into increasing order.

template<typename T_y , typename T_result >
bool	check_positive_ordered (const char function, const Eigen::Matrix< T_y, Eigen::Dynamic, 1 > &y, const char name, T_result *result)

template<typename T >
bool	check_positive_ordered (const char function, const Eigen::Matrix< T, Eigen::Dynamic, 1 > &y, const char name, T *result=0)

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

template<typename T_y , typename T_result >
bool	check_not_nan (const char function, const Eigen::Matrix< T_y, Eigen::Dynamic, Eigen::Dynamic > &y, const char name, T_result *result)

template<typename T >
bool	check_not_nan (const char function, const Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > &y, const char name, T *result=0)

template<typename T >
boost::math::tools::promote_args < T >::type	exp2 (T y)
	Return the exponent base 2 of the specified argument (C99).

template<typename T1 , typename T2 >
boost::math::tools::promote_args < T1, T2 >::type	fdim (T1 a, T2 b)
	The positive difference function (C99).

template<typename T1 , typename T2 , typename T3 >
boost::math::tools::promote_args < T1, T2, T3 >::type	fma (T1 a, T2 b, T3 c)
	The fused multiply-add operation (C99).

template<typename T >
boost::math::tools::promote_args < T >::type	log2 (T a)
	Returns the base 2 logarithm of the argument (C99).

template<typename T >
unsigned int	int_step (T y)
	The integer step, or Heaviside, function.

template<typename T >
int	step (T y)
	The step, or Heaviside, function.

template<typename T1 , typename T2 >
boost::math::tools::promote_args < T1, T2 >::type	lbeta (T1 a, T2 b)
	Return the log of the beta function applied to the specified arguments.

template<typename T_N , typename T_n >
boost::math::tools::promote_args < T_N, T_n >::type	binomial_coefficient_log (T_N N, T_n n)
	Return the log of the binomial coefficient for the specified arguments.

template<typename T >
boost::math::tools::promote_args < T >::type	inv_logit (T a)
	Returns the inverse logit function applied to the argument.

template<typename T >
boost::math::tools::promote_args < T >::type	logit (T a)
	Returns the logit function applied to the argument.

template<typename T >
boost::math::tools::promote_args < T >::type	Phi (T x)
	The unit normal cumulative distribution function.

template<typename T >
boost::math::tools::promote_args < T >::type	Phi_approx (T x)
	Approximation of the unit normal CDF.

template<typename T >
boost::math::tools::promote_args < T >::type	inv_cloglog (T x)
	The inverse complementary log-log function.

template<typename T >
boost::math::tools::promote_args < T >::type	binary_log_loss (int y, T y_hat)
	Returns the log loss function for binary classification with specified reference and response values.

template<typename Vector , typename Scalar >
void	softmax (const Vector &x, Vector &simplex)
	Write the values of the softmax transformed first argument into the second argument.

template<typename Vector >
void	inverse_softmax (const Vector &simplex, Vector &y)
	Writes the inverse softmax of the simplex argument into the second argument.

template<typename T >
boost::math::tools::promote_args < T >::type	log1p (T x)
	Return the natural logarithm of one plus the specified value.

template<typename T >
boost::math::tools::promote_args < T >::type	log1m (T x)
	Return the natural logarithm of one minus the specified value.

template<typename T >
boost::math::tools::promote_args < T >::type	lmgamma (unsigned int k, T x)
	Return the natural logarithm of the multivariate gamma function with the speciifed dimensions and argument.

double	if_else (bool c, double y_true, double y_false)
	Return the second argument if the first argument is true and otherwise return the second argument.

template<typename T >
T	square (T x)
	Return the square of the specified argument.

template<typename T_a , typename T_b >
boost::math::tools::promote_args < T_a, T_b >::type	multiply_log (T_a a, T_b b)

double	log1p_exp (const double &a)
	Calculates the log of 1 plus the exponential of the specified value without overflow.

template<typename T >
boost::math::tools::promote_args < T >::type	log_inv_logit (const T &u)
	Returns the natural logarithm of the inverse logit of the specified argument.

template<typename T >
boost::math::tools::promote_args < T >::type	log1m_inv_logit (const T &u)
	Returns the natural logarithm of 1 minus the inverse logit of the specified argument.

double	log_sum_exp (const double &a, const double &b)
	Calculates the log sum of exponetials without overflow.

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

double	log_sum_exp (const std::vector< double > &x)
	Return the log of the sum of the exponentiated values of the specified sequence of values.

template<typename T >
int	logical_negation (T x)
	The logical negation function which returns 1 if the input is equal to zero and 0 otherwise.

template<typename T1 , typename T2 >
int	logical_or (T1 x1, T2 x2)
	The logical or function which returns 1 if either argument is unequal to zero and 0 otherwise.

template<typename T1 , typename T2 >
int	logical_and (T1 x1, T2 x2)
	The logical and function which returns 1 if both arguments are unequal to zero and 0 otherwise.

template<typename T1 , typename T2 >
int	logical_eq (T1 x1, T2 x2)
	Return 1 if the first argument is equal to the second.

template<typename T1 , typename T2 >
int	logical_neq (T1 x1, T2 x2)
	Return 1 if the first argument is unequal to the second.

template<typename T1 , typename T2 >
int	logical_lt (T1 x1, T2 x2)
	Return 1 if the first argument is strictly less than the second.

template<typename T1 , typename T2 >
int	logical_lte (T1 x1, T2 x2)
	Return 1 if the first argument is less than or equal to the second.

template<typename T1 , typename T2 >
int	logical_gt (T1 x1, T2 x2)
	Return 1 if the first argument is strictly greater than the second.

template<typename T1 , typename T2 >
int	logical_gte (T1 x1, T2 x2)
	Return 1 if the first argument is greater than or equal to the second.

template<typename T1 , typename T2 , typename T3 >
double	simple_var (double v, const T1 &, const T1 &, const T2 &, const T2 &, const T3 &, const T3 &)
	Return the scalar value and ignore the remaining arguments.

template<typename T >
double	value_of (T x)
	Return the value of the specified scalar argument converted to a double value.

template<>
double	value_of< double > (double x)
	Return the specified argument.

double	pi ()
	Return the value of pi.

double	e ()
	Return the base of the natural logarithm.

double	sqrt2 ()
	Return the square root of two.

double	log2 ()
	Return natural logarithm of two.

double	log10 ()
	Return natural logarithm of ten.

double	positive_infinity ()
	Return positive infinity.

double	negative_infinity ()
	Return negative infinity.

double	not_a_number ()
	Return (quiet) not-a-number.

double	epsilon ()
	Return minimum positive number representable.

double	negative_epsilon ()
	Return maximum negative number (i.e., negative number with smallest absolute value).

int	as_bool (int x)
	Return an integer with an equivalent boolean value to specified input.

int	as_bool (double x)
	Return 1 if the argument is unequal to zero and 0 otherwise.

double	max (double a, double b)

double	max (std::vector< double > &x)

double	min (double a, double b)

double	dot (std::vector< double > &x, std::vector< double > &y)

double	dot_self (std::vector< double > &x)

void	scaled_add (std::vector< double > &x, std::vector< double > &y, double lambda)

void	sub (std::vector< double > &x, std::vector< double > &y, std::vector< double > &result)

double	dist (const std::vector< double > &x, const std::vector< double > &y)

double	sum (std::vector< double > &x)

double	F32 (double a, double b, double c, double d, double e, double z)

void	gradF32 (double *g, double a, double b, double c, double d, double e, double z)

void	grad2F1 (double &gradA, double &gradC, double a, double b, double c, double z, double precision=1e-6)

void	gradIncBeta (double &g1, double &g2, double a, double b, double z)

void	gradRegIncBeta (double &g1, double &g2, double a, double b, double z, double digammaA, double digammaB, double digammaSum, double betaAB)

double	gradRegIncGamma (double a, double z, double g, double dig, double precision=1e-6)

Variables
const double	E = boost::math::constants::e<double>()
	The base of the natural logarithm, .

const double	SQRT_2 = std::sqrt(2.0)
	The value of the square root of 2, $\sqrt{2}$ .

const double	LOG_2 = std::log(2.0)
	The natural logarithm of 2, $\log 2$ .

const double	LOG_10 = std::log(10.0)
	The natural logarithm of 10, $\log 10$ .

const double	INFTY = std::numeric_limits<double>::infinity()
	Positive infinity.

const double	NEGATIVE_INFTY = - std::numeric_limits<double>::infinity()
	Negative infinity.

const double	NOT_A_NUMBER = std::numeric_limits<double>::quiet_NaN()
	(Quiet) not-a-number value.

const double	EPSILON = std::numeric_limits<double>::epsilon()
	Smallest positive value.

const double	NEGATIVE_EPSILON = - std::numeric_limits<double>::epsilon()
	Largest negative value (i.e., smallest absolute value).

const double	CONSTRAINT_TOLERANCE = 1E-8
	The tolerance for checking arithmetic bounds In rank and in simplexes.

Detailed Description

Matrices and templated mathematical functions.

Typedef Documentation

typedef boost::math::policies::policy stan::math::default_policy

Default error-handling policy from Boost.

Definition at line 30 of file error_handling.hpp.

typedef Eigen::Matrix<double,Eigen::Dynamic,Eigen::Dynamic> stan::math::matrix_d

Type for matrix of double values.

Definition at line 152 of file matrix.hpp.

typedef Eigen::Matrix<double,1,Eigen::Dynamic> stan::math::row_vector_d

Type for (row) vector of double values.

Definition at line 166 of file matrix.hpp.

typedef Eigen::Matrix<double,Eigen::Dynamic,1> stan::math::vector_d

Type for (column) vector of double values.

Definition at line 159 of file matrix.hpp.

Function Documentation

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

Eigen::Matrix<typename boost::math::tools::promote_args<T1,T2>::type,R,C> stan::math::add	(	const Eigen::Matrix< T1, R, C > &	m1,
		const Eigen::Matrix< T2, R, C > &	m2
	)

inline

Return the sum of the specified matrices.

The two matrices must have the same dimensions.

Template Parameters

T1	Scalar type of first matrix.
T2	Scalar type of second matrix.
R	Row type of matrices.
C	Column type of matrices.

Parameters

m1	First matrix.
m2	Second matrix.

Returns: Sum of the matrices.

Exceptions

std::domain_error if m1 and m2 do not have the same dimensions.

Definition at line 1264 of file matrix.hpp.

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

Eigen::Matrix<typename boost::math::tools::promote_args<T1,T2>::type,R,C> stan::math::add	(	const Eigen::Matrix< T1, R, C > &	m,
		const T2 &	c
	)

inline

Return the sum of the specified matrix and specified scalar.

Template Parameters

T1	Scalar type of matrix.

Parameters

T2	Type of scalar.
m	Matrix.
c	Scalar.

Returns: The matrix plus the scalar.

Definition at line 1285 of file matrix.hpp.

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

Eigen::Matrix<typename boost::math::tools::promote_args<T1,T2>::type,R,C> stan::math::add	(	const T1 &	c,
		const Eigen::Matrix< T2, R, C > &	m
	)

inline

Return the sum of the specified scalar and specified matrix.

Parameters

T1	Type of scalar.

Template Parameters

T2	Scalar type of matrix.

Parameters

c	Scalar.
m	Matrix.

Returns: The scalar plus the matrix.

Definition at line 1305 of file matrix.hpp.

int stan::math::as_bool ( int x )

inline

Return an integer with an equivalent boolean value to specified input.

For integers, this reduces to the identity function.

Parameters

x value.

Returns: The value.

Definition at line 979 of file special_functions.hpp.

int stan::math::as_bool ( double x )

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 988 of file special_functions.hpp.

template<typename T >

boost::math::tools::promote_args<T>::type stan::math::binary_log_loss	(	int	y,
		T	y_hat
	)

inline

Returns the log loss function for binary classification with specified reference and response values.

The log loss function for prediction $\hat{y} \in [0, 1]$ given outcome $y \in \{ 0, 1 \}$ is

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

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

Parameters

y	Reference value in { 0 , 1 }.
y_hat	Response value in [0,1].

Returns: Log loss for response given reference value.

Definition at line 309 of file special_functions.hpp.

template<typename T_N , typename T_n >

boost::math::tools::promote_args<T_N, T_n>::type stan::math::binomial_coefficient_log	(	T_N	N,
		T_n	n
	)

inline

Return the log of the binomial coefficient for the specified arguments.

The binomial coefficient, ${N \choose n}$ , read "N choose n", is defined for $0 \leq n \leq N$ by

${N \choose n} = \frac{N!}{n! (N-n)!}$ .

This function uses Gamma functions to define the log and generalize the arguments to continuous N and n.

$\log {N \choose n} = \log \ \Gamma(N+1) - \log \Gamma(n+1) - \log \Gamma(N-n+1)$ .

Parameters

N	total number of objects.
n	number of objects chosen.

Returns: log (N choose n).

Definition at line 176 of file special_functions.hpp.

template<typename T >

Eigen::Matrix<T,Eigen::Dynamic,Eigen::Dynamic> stan::math::block	(	const Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > &	m,
		size_t	i,
		size_t	j,
		size_t	nrows,
		size_t	ncols
	)

inline

Return a nrows x ncols submatrix starting at (i,j).

Parameters

m	Matrix
i	Starting row
j	Starting column
nrows	Number of rows in block
ncols	Number of columns in block

Definition at line 1653 of file matrix.hpp.

template<typename T_y , typename T_low , typename T_high , typename T_result , class Policy >

bool stan::math::check_bounded	(	const char *	function,
		const T_y &	y,
		const T_low &	low,
		const T_high &	high,
		const char *	name,
		T_result *	result,
		const Policy &
	)

inline

Definition at line 619 of file error_handling.hpp.

template<typename T_y , typename T_low , typename T_high , typename T_result >

bool stan::math::check_bounded	(	const char *	function,
		const T_y &	y,
		const T_low &	low,
		const T_high &	high,
		const char *	name,
		T_result *	result
	)

inline

Definition at line 631 of file error_handling.hpp.

template<typename T_y , typename T_low , typename T_high >

bool stan::math::check_bounded	(	const char *	function,
		const T_y &	y,
		const T_low &	low,
		const T_high &	high,
		const char *	name
	)

inline

Definition at line 640 of file error_handling.hpp.

template<typename T , typename T_result , class Policy >

bool stan::math::check_consistent_size	(	size_t	max_size,
		const char *	function,
		const T &	x,
		const char *	name,
		T_result *	result,
		const Policy &
	)

inline

Definition at line 786 of file error_handling.hpp.

template<typename T1 , typename T2 , typename T_result , class Policy >

bool stan::math::check_consistent_sizes	(	const char *	function,
		const T1 &	x1,
		const T2 &	x2,
		const char *	name1,
		const char *	name2,
		T_result *	result,
		const Policy &
	)

inline

Definition at line 805 of file error_handling.hpp.

template<typename T1 , typename T2 , typename T_result >

bool stan::math::check_consistent_sizes	(	const char *	function,
		const T1 &	x1,
		const T2 &	x2,
		const char *	name1,
		const char *	name2,
		T_result *	result
	)

inline

Definition at line 818 of file error_handling.hpp.

template<typename T1 , typename T2 , typename T3 , typename T_result , class Policy >

bool stan::math::check_consistent_sizes	(	const char *	function,
		const T1 &	x1,
		const T2 &	x2,
		const T3 &	x3,
		const char *	name1,
		const char *	name2,
		const char *	name3,
		T_result *	result,
		const Policy &
	)

inline

Definition at line 830 of file error_handling.hpp.

template<typename T1 , typename T2 , typename T3 , typename T_result >

bool stan::math::check_consistent_sizes	(	const char *	function,
		const T1 &	x1,
		const T2 &	x2,
		const T3 &	x3,
		const char *	name1,
		const char *	name2,
		const char *	name3,
		T_result *	result
	)

inline

Definition at line 846 of file error_handling.hpp.

template<typename T1 , typename T2 , typename T3 , typename T4 , typename T_result , class Policy >

bool stan::math::check_consistent_sizes	(	const char *	function,
		const T1 &	x1,
		const T2 &	x2,
		const T3 &	x3,
		const T4 &	x4,
		const char *	name1,
		const char *	name2,
		const char *	name3,
		const char *	name4,
		T_result *	result,
		const Policy &
	)

inline

Definition at line 860 of file error_handling.hpp.

template<typename T1 , typename T2 , typename T3 , typename T4 , typename T_result >

bool stan::math::check_consistent_sizes	(	const char *	function,
		const T1 &	x1,
		const T2 &	x2,
		const T3 &	x3,
		const T4 &	x4,
		const char *	name1,
		const char *	name2,
		const char *	name3,
		const char *	name4,
		T_result *	result
	)

inline

Definition at line 880 of file error_handling.hpp.

template<typename T_y , typename T_result , class Policy >

bool stan::math::check_corr_matrix	(	const char *	function,
		const Eigen::Matrix< T_y, Eigen::Dynamic, Eigen::Dynamic > &	y,
		const char *	name,
		T_result *	result,
		const Policy &
	)

inline

Return true if the specified matrix is a valid correlation matrix.

A valid correlation matrix is symmetric, has a unit diagonal (all 1 values), and has all values between -1 and 1 (inclussive).

Parameters

function
y	Matrix to test.
name
result

Returns: true if the specified matrix is a valid correlation matrix.

Template Parameters

T	Type of scalar.

Definition at line 280 of file matrix_error_handling.hpp.

template<typename T_y , typename T_result >

bool stan::math::check_corr_matrix	(	const char *	function,
		const Eigen::Matrix< T_y, Eigen::Dynamic, Eigen::Dynamic > &	y,
		const char *	name,
		T_result *	result
	)

inline

Definition at line 317 of file matrix_error_handling.hpp.

template<typename T >

bool stan::math::check_corr_matrix	(	const char *	function,
		const Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > &	y,
		const char *	name,
		T *	result = `0`
	)

inline

Definition at line 325 of file matrix_error_handling.hpp.

template<typename T_y , typename T_result , class Policy >

bool stan::math::check_cov_matrix	(	const char *	function,
		const Eigen::Matrix< T_y, Eigen::Dynamic, Eigen::Dynamic > &	y,
		const char *	name,
		T_result *	result,
		const Policy &
	)

inline

Return true if the specified matrix is a valid covariance matrix.

A valid covariance matrix must be square, symmetric, and positive definite.

Parameters

function
y	Matrix to test.
name
result

Returns: true if the matrix is a valid covariance matrix.

Template Parameters

T	Type of scalar.

Definition at line 225 of file matrix_error_handling.hpp.

template<typename T_y , typename T_result >

bool stan::math::check_cov_matrix	(	const char *	function,
		const Eigen::Matrix< T_y, Eigen::Dynamic, Eigen::Dynamic > &	y,
		const char *	name,
		T_result *	result
	)

inline

Definition at line 245 of file matrix_error_handling.hpp.

template<typename T >

bool stan::math::check_cov_matrix	(	const char *	function,
		const Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > &	y,
		const char *	name,
		T *	result = `0`
	)

inline

Definition at line 254 of file matrix_error_handling.hpp.

template<typename T_covar , typename T_result , class Policy >

bool stan::math::check_cov_matrix	(	const char *	function,
		const Eigen::Matrix< T_covar, Eigen::Dynamic, Eigen::Dynamic > &	Sigma,
		T_result *	result,
		const Policy &
	)

inline

Return true if the specified matrix is a valid covariance matrix.

A valid covariance matrix must be symmetric and positive definite.

Parameters

function
Sigma	Matrix to test.
result

Returns: true if the matrix is a valid covariance matrix.

Template Parameters

T	Type of scalar.

Definition at line 345 of file matrix_error_handling.hpp.

template<typename T_covar , typename T_result >

bool stan::math::check_cov_matrix	(	const char *	function,
		const Eigen::Matrix< T_covar, Eigen::Dynamic, Eigen::Dynamic > &	Sigma,
		T_result *	result
	)

inline

Definition at line 361 of file matrix_error_handling.hpp.

template<typename T >

bool stan::math::check_cov_matrix	(	const char *	function,
		const Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > &	Sigma,
		T *	result = `0`
	)

inline

Definition at line 368 of file matrix_error_handling.hpp.

template<typename T_y , typename T_result , class Policy >

bool stan::math::check_finite	(	const char *	function,
		const T_y &	y,
		const char *	name,
		T_result *	result,
		const Policy &
	)

inline

Checks if the variable y is finite.

Definition at line 228 of file error_handling.hpp.

template<typename T_y , typename T_result >

bool stan::math::check_finite	(	const char *	function,
		const T_y &	y,
		const char *	name,
		T_result *	result
	)

inline

Definition at line 239 of file error_handling.hpp.

template<typename T >

bool stan::math::check_finite	(	const char *	function,
		const T &	y,
		const char *	name
	)

inline

Definition at line 247 of file error_handling.hpp.

template<typename T_y , typename T_low , typename T_result , class Policy >

bool stan::math::check_greater	(	const char *	function,
		const T_y &	y,
		const T_low &	low,
		const char *	name,
		T_result *	result,
		const Policy &
	)

inline

Definition at line 304 of file error_handling.hpp.

template<typename T_y , typename T_low , typename T_result >

bool stan::math::check_greater	(	const char *	function,
		const T_y &	y,
		const T_low &	low,
		const char *	name,
		T_result *	result
	)

inline

Definition at line 314 of file error_handling.hpp.

template<typename T_y , typename T_low >

bool stan::math::check_greater	(	const char *	function,
		const T_y &	y,
		const T_low &	low,
		const char *	name
	)

inline

Definition at line 322 of file error_handling.hpp.

template<typename T_y , typename T_low , typename T_result , class Policy >

bool stan::math::check_greater_or_equal	(	const char *	function,
		const T_y &	y,
		const T_low &	low,
		const char *	name,
		T_result *	result,
		const Policy &
	)

inline

Definition at line 380 of file error_handling.hpp.

template<typename T_y , typename T_low , typename T_result >

bool stan::math::check_greater_or_equal	(	const char *	function,
		const T_y &	y,
		const T_low &	low,
		const char *	name,
		T_result *	result
	)

inline

Definition at line 389 of file error_handling.hpp.

template<typename T_y , typename T_low >

bool stan::math::check_greater_or_equal	(	const char *	function,
		const T_y &	y,
		const T_low &	low,
		const char *	name
	)

inline

Definition at line 398 of file error_handling.hpp.

template<typename T_y , typename T_high , typename T_result , class Policy >

bool stan::math::check_less	(	const char *	function,
		const T_y &	y,
		const T_high &	high,
		const char *	name,
		T_result *	result,
		const Policy &
	)

inline

Definition at line 455 of file error_handling.hpp.

template<typename T_y , typename T_high , typename T_result >

bool stan::math::check_less	(	const char *	function,
		const T_y &	y,
		const T_high &	high,
		const char *	name,
		T_result *	result
	)

inline

Definition at line 465 of file error_handling.hpp.

template<typename T_y , typename T_high >

bool stan::math::check_less	(	const char *	function,
		const T_y &	y,
		const T_high &	high,
		const char *	name
	)

inline

Definition at line 473 of file error_handling.hpp.

template<typename T_y , typename T_high , typename T_result , class Policy >

bool stan::math::check_less_or_equal	(	const char *	function,
		const T_y &	y,
		const T_high &	high,
		const char *	name,
		T_result *	result,
		const Policy &
	)

inline

Definition at line 530 of file error_handling.hpp.

template<typename T_y , typename T_high , typename T_result >

bool stan::math::check_less_or_equal	(	const char *	function,
		const T_y &	y,
		const T_high &	high,
		const char *	name,
		T_result *	result
	)

inline

Definition at line 541 of file error_handling.hpp.

template<typename T_y , typename T_high >

bool stan::math::check_less_or_equal	(	const char *	function,
		const T_y &	y,
		const T_high &	high,
		const char *	name
	)

inline

Definition at line 549 of file error_handling.hpp.

template<typename T_y , typename T_result , class Policy >

bool stan::math::check_nonnegative	(	const char *	function,
		const T_y &	y,
		const char *	name,
		T_result *	result,
		const Policy &
	)

inline

Definition at line 692 of file error_handling.hpp.

template<typename T_y , typename T_result >

bool stan::math::check_nonnegative	(	const char *	function,
		const T_y &	y,
		const char *	name,
		T_result *	result
	)

inline

Definition at line 702 of file error_handling.hpp.

template<typename T_y >

bool stan::math::check_nonnegative	(	const char *	function,
		const T_y &	y,
		const char *	name
	)

inline

Definition at line 709 of file error_handling.hpp.

template<typename T_y , typename T_result , class Policy >

bool stan::math::check_not_nan	(	const char *	function,
		const T_y &	y,
		const char *	name,
		T_result *	result,
		const Policy &
	)

inline

Checks if the variable y is nan.

Parameters

function	Name of function being invoked.
y	Reference to variable being tested.
name	Name of variable being tested.
result	Pointer to resulting value after test.

Template Parameters

T_y	Type of variable being tested.
T_result	Type of result returned.
Policy	Error handling policy.

Definition at line 146 of file error_handling.hpp.

template<typename T_y , typename T_result >

bool stan::math::check_not_nan	(	const char *	function,
		const T_y &	y,
		const char *	name,
		T_result *	result = `0`
	)

inline

Checks if the variable y is nan.

Parameters

function	Name of function being invoked.
y	Reference to variable being tested.
name	Name of variable being tested.
result	Pointer to resulting value after test.

Template Parameters

T_y	Type of variable being tested.
T_result	Type of result returned.
Policy	Error handling policy.

Definition at line 169 of file error_handling.hpp.

template<typename T >

bool stan::math::check_not_nan	(	const char *	function,
		const T &	y,
		const char *	name
	)

inline

Definition at line 177 of file error_handling.hpp.

template<typename T_y , typename T_result , class Policy >

bool stan::math::check_not_nan	(	const char *	function,
		const Eigen::Matrix< T_y, Eigen::Dynamic, Eigen::Dynamic > &	y,
		const char *	name,
		T_result *	result,
		const Policy &
	)

inline

Definition at line 597 of file matrix_error_handling.hpp.

template<typename T_y , typename T_result >

bool stan::math::check_not_nan	(	const char *	function,
		const Eigen::Matrix< T_y, Eigen::Dynamic, Eigen::Dynamic > &	y,
		const char *	name,
		T_result *	result
	)

inline

Definition at line 621 of file matrix_error_handling.hpp.

template<typename T >

bool stan::math::check_not_nan	(	const char *	function,
		const Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > &	y,
		const char *	name,
		T *	result = `0`
	)

inline

Definition at line 628 of file matrix_error_handling.hpp.

template<typename T_y , typename T_result , class Policy >

bool stan::math::check_ordered	(	const char *	function,
		const Eigen::Matrix< T_y, Eigen::Dynamic, 1 > &	y,
		const char *	name,
		T_result *	result,
		const Policy &
	)

Return true if the specified vector is sorted into increasing order.

There may be duplicate values. Otherwise, raise a domain error according to the specified policy.

Parameters

function
y	Vector to test.
name
result

Template Parameters

Policy Only the policy's type matters.

Returns: true if the vector has positive, ordered values.

Definition at line 479 of file matrix_error_handling.hpp.

template<typename T_y , typename T_result >

bool stan::math::check_ordered	(	const char *	function,
		const Eigen::Matrix< T_y, Eigen::Dynamic, 1 > &	y,
		const char *	name,
		T_result *	result
	)

Definition at line 508 of file matrix_error_handling.hpp.

template<typename T >

bool stan::math::check_ordered	(	const char *	function,
		const Eigen::Matrix< T, Eigen::Dynamic, 1 > &	y,
		const char *	name,
		T *	result = `0`
	)

Definition at line 515 of file matrix_error_handling.hpp.

template<typename T_y , typename T_result , class Policy >

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

inline

Return true if the specified matrix is positive definite.

NOTE: symmetry is NOT checked by this function

Parameters

function
y	Matrix to test.
name
result

Returns: true if the matrix is positive definite.

Template Parameters

T	Type of scalar.

Definition at line 155 of file matrix_error_handling.hpp.

template<typename T_y , typename T_result >

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

inline

Definition at line 192 of file matrix_error_handling.hpp.

template<typename T >

bool stan::math::check_pos_definite	(	const char *	function,
		const Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > &	y,
		const char *	name,
		T *	result = `0`
	)

inline

Definition at line 201 of file matrix_error_handling.hpp.

template<typename T_y , typename T_result , class Policy >

bool stan::math::check_positive	(	const char *	function,
		const T_y &	y,
		const char *	name,
		T_result *	result,
		const Policy &
	)

inline

Definition at line 761 of file error_handling.hpp.

template<typename T_x , typename T_result >

bool stan::math::check_positive	(	const char *	function,
		const T_x &	x,
		const char *	name,
		T_result *	result
	)

inline

Definition at line 771 of file error_handling.hpp.

template<typename T >

bool stan::math::check_positive	(	const char *	function,
		const T &	x,
		const char *	name
	)

inline

Definition at line 778 of file error_handling.hpp.

template<typename T_y , typename T_result , class Policy >

bool stan::math::check_positive_ordered	(	const char *	function,
		const Eigen::Matrix< T_y, Eigen::Dynamic, 1 > &	y,
		const char *	name,
		T_result *	result,
		const Policy &
	)

Return true if the specified vector contains only non-negative values and is sorted into increasing order.

There may be duplicate values. Otherwise, raise a domain error according to the specified policy.

Parameters

function
y	Vector to test.
name
result

Template Parameters

Policy Only the policy's type matters.

Returns: true if the vector has positive, ordered values.

Definition at line 537 of file matrix_error_handling.hpp.

template<typename T_y , typename T_result >

bool stan::math::check_positive_ordered	(	const char *	function,
		const Eigen::Matrix< T_y, Eigen::Dynamic, 1 > &	y,
		const char *	name,
		T_result *	result
	)

Definition at line 578 of file matrix_error_handling.hpp.

template<typename T >

bool stan::math::check_positive_ordered	(	const char *	function,
		const Eigen::Matrix< T, Eigen::Dynamic, 1 > &	y,
		const char *	name,
		T *	result = `0`
	)

Definition at line 585 of file matrix_error_handling.hpp.

template<typename T_prob , typename T_result , class Policy >

bool stan::math::check_simplex	(	const char *	function,
		const Eigen::Matrix< T_prob, Eigen::Dynamic, 1 > &	theta,
		const char *	name,
		T_result *	result,
		const Policy &
	)

Return true if the specified vector is simplex.

To be a simplex, all values must be greater than or equal to 0 and the values must sum to 1.

The test that the values sum to 1 is done to within the tolerance specified by CONSTRAINT_TOLERANCE.

Parameters

function
theta	Vector to test.
name
result

Returns: true if the vector is a simplex.

Definition at line 395 of file matrix_error_handling.hpp.

template<typename T_y , typename T_result >

bool stan::math::check_simplex	(	const char *	function,
		const Eigen::Matrix< T_y, Eigen::Dynamic, 1 > &	theta,
		const char *	name,
		T_result *	result
	)

inline

Definition at line 447 of file matrix_error_handling.hpp.

template<typename T >

bool stan::math::check_simplex	(	const char *	function,
		const Eigen::Matrix< T, Eigen::Dynamic, 1 > &	theta,
		const char *	name,
		T *	result = `0`
	)

inline

Definition at line 454 of file matrix_error_handling.hpp.

template<typename T_size1 , typename T_size2 , typename T_result , class Policy >

bool stan::math::check_size_match	(	const char *	function,
		T_size1	i,
		const char *	name_i,
		T_size2	j,
		const char *	name_j,
		T_result *	result,
		const Policy &
	)

inline

Definition at line 32 of file matrix_error_handling.hpp.

template<typename T_size1 , typename T_size2 , typename T_result >

bool stan::math::check_size_match	(	const char *	function,
		T_size1	i,
		const char *	name_i,
		T_size2	j,
		const char *	name_j,
		T_result *	result
	)

inline

Definition at line 56 of file matrix_error_handling.hpp.

template<typename T_size1 , typename T_size2 >

bool stan::math::check_size_match	(	const char *	function,
		T_size1	i,
		const char *	name_i,
		T_size2	j,
		const char *	name_j,
		T_size1 *	result = `0`
	)

inline

Definition at line 67 of file matrix_error_handling.hpp.

template<typename T_y , typename T_result , class Policy >

bool stan::math::check_symmetric	(	const char *	function,
		const Eigen::Matrix< T_y, Eigen::Dynamic, Eigen::Dynamic > &	y,
		const char *	name,
		T_result *	result,
		const Policy &
	)

inline

Return true if the specified matrix is symmetric.

NOTE: squareness is not checked by this function

Parameters

function
y	Matrix to test.
name
result

Returns: true if the matrix is symmetric.

Template Parameters

T	Type of scalar.

Definition at line 89 of file matrix_error_handling.hpp.

template<typename T_y , typename T_result >

bool stan::math::check_symmetric	(	const char *	function,
		const Eigen::Matrix< T_y, Eigen::Dynamic, Eigen::Dynamic > &	y,
		const char *	name,
		T_result *	result
	)

inline

Definition at line 123 of file matrix_error_handling.hpp.

template<typename T >

bool stan::math::check_symmetric	(	const char *	function,
		const Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > &	y,
		const char *	name,
		T *	result = `0`
	)

inline

Definition at line 131 of file matrix_error_handling.hpp.

template<typename T >

Eigen::Matrix<T,Eigen::Dynamic,Eigen::Dynamic> stan::math::cholesky_decompose ( const Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > & m )

Return the lower-triangular Cholesky factor (i.e., matrix square root) of the specified square, symmetric matrix.

The return value $L$ will be a lower-traingular matrix such that the original matrix $A$ is given by

$A = L \times L^T$ .

Parameters

m	Symmetrix matrix.

Returns: Square root of matrix.

Exceptions

std::domain_error if m is not a symmetric matrix.

Definition at line 1957 of file matrix.hpp.

template<typename T >

Eigen::Matrix<T,Eigen::Dynamic,1> stan::math::col	(	const Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > &	m,
		size_t	j
	)

inline

Return the specified column of the specified matrix using start-at-1 indexing.

This is equivalent to calling m.col(i - 1) and assigning the resulting template expression to a column vector.

Parameters

m	Matrix.
j	Column index (count from 1).

Returns: Specified column of the matrix.

Definition at line 1635 of file matrix.hpp.

template<typename T , int R, int C>

size_t stan::math::cols ( const Eigen::Matrix< T, R, C > & m )

inline

Definition at line 629 of file matrix.hpp.

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

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

inline

Returns the dot product of the specified vectors.

Parameters

v1	First vector.
v2	Second vector.

Returns: Dot product of the vectors.

Exceptions

std::domain_error If the vectors are not the same size or if they are both not vector dimensioned.

Definition at line 885 of file matrix.hpp.

template<typename T , int R, int C>

Eigen::Matrix<T,1,C> stan::math::columns_dot_self ( const Eigen::Matrix< T, 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 870 of file matrix.hpp.

matrix_d stan::math::crossprod ( const matrix_d & 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 1596 of file matrix.hpp.

template<typename T , int R, int C>

T stan::math::determinant ( const Eigen::Matrix< T, R, C > & m )

inline

Returns the determinant of the specified square matrix.

Parameters

m	Specified matrix.

Returns: Determinant of the matrix.

Exceptions

std::domain_error if matrix is not square.

Definition at line 828 of file matrix.hpp.

template<typename T >

Eigen::Matrix<T,Eigen::Dynamic,Eigen::Dynamic> stan::math::diag_matrix ( const Eigen::Matrix< T, Eigen::Dynamic, 1 > & v )

inline

Return a square diagonal matrix with the specified vector of coefficients as the diagonal values.

Parameters

[in] v Specified vector.

Returns: Diagonal matrix with vector as diagonal values.

Definition at line 1685 of file matrix.hpp.

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

Eigen::Matrix<typename boost::math::tools::promote_args<T1,T2>::type, R1, C1> stan::math::diag_post_multiply	(	const Eigen::Matrix< T1, R1, C1 > &	m1,
		const Eigen::Matrix< T2, R2, C2 > &	m2
	)

Definition at line 1440 of file matrix.hpp.

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

Eigen::Matrix<typename boost::math::tools::promote_args<T1,T2>::type, R2, C2> stan::math::diag_pre_multiply	(	const Eigen::Matrix< T1, R1, C1 > &	m1,
		const Eigen::Matrix< T2, R2, C2 > &	m2
	)

Definition at line 1424 of file matrix.hpp.

template<typename T >

Eigen::Matrix<T,Eigen::Dynamic,1> stan::math::diagonal ( const Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > & m )

inline

Return a column vector of the diagonal elements of the specified matrix.

The matrix is not required to be square.

Parameters

m	Specified matrix.

Returns: Diagonal of the matrix.

Definition at line 1672 of file matrix.hpp.

double stan::math::dist	(	const std::vector< double > &	x,
		const std::vector< double > &	y
	)

inline

Definition at line 61 of file util.hpp.

template<int R, int C>

Eigen::Matrix<double,R,C> stan::math::divide	(	const Eigen::Matrix< double, R, C > &	m,
		double	c
	)

inline

Return specified matrix divided by specified scalar.

Template Parameters

R	Row type for matrix.
C	Column type for matrix.

Parameters

m	Matrix.
c	Scalar.

Returns: Matrix divided by scalar.

Definition at line 1393 of file matrix.hpp.

double stan::math::dot	(	std::vector< double > &	x,
		std::vector< double > &	y
	)

inline

Definition at line 30 of file util.hpp.

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

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

inline

Returns the dot product of the specified vectors.

Parameters

v1	First vector.
v2	Second vector.

Returns: Dot product of the vectors.

Exceptions

std::domain_error If the vectors are not the same size or if they are both not vector dimensioned.

Definition at line 906 of file matrix.hpp.

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

inline

Returns the dot product of the specified arrays of doubles.

Parameters

v1	First array.
v2	Second array.
length	Length of both arrays.

Definition at line 922 of file matrix.hpp.

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

inline

Returns the dot product of the specified arrays of doubles.

Parameters

v1	First array.
v2	Second array.

Exceptions

std::domain_error if the vectors are not the same size.

Definition at line 935 of file matrix.hpp.

double stan::math::dot_self ( std::vector< double > & x )

inline

Definition at line 39 of file util.hpp.

template<int R, int C>

double stan::math::dot_self ( const Eigen::Matrix< double, R, C > & v )

inline

Returns the dot product of the specified vector with itself.

Parameters

v Vector.

Template Parameters

R	number of rows or `Eigen::Dynamic` for dynamic
C	number of rows or `Eigen::Dyanmic` for dynamic

Exceptions

std::domain_error If v is not vector dimensioned.

Definition at line 855 of file matrix.hpp.

double stan::math::e ( )

inline

Return the base of the natural logarithm.

Returns: Base of natural logarithm.

Definition at line 895 of file special_functions.hpp.

template<typename T >

Eigen::Matrix<T,Eigen::Dynamic,1> stan::math::eigenvalues_sym ( const Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > & m )

Return the eigenvalues of the specified symmetric matrix in descending order of magnitude.

This function is more efficient than the general eigenvalues function for symmetric matrices.

See eigen_decompose() for more information.

Parameters

m	Specified matrix.

Returns: Eigenvalues of matrix.

Definition at line 1924 of file matrix.hpp.

template<typename T >

Eigen::Matrix<T,Eigen::Dynamic,Eigen::Dynamic> stan::math::eigenvectors_sym ( const Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > & m )

Definition at line 1934 of file matrix.hpp.

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

Eigen::Matrix<typename boost::math::tools::promote_args<T1,T2>::type, R, C> stan::math::elt_divide	(	const Eigen::Matrix< T1, R, C > &	m1,
		const Eigen::Matrix< T2, R, C > &	m2
	)

Return the elementwise division of the specified matrices matrices.

Template Parameters

T1	Type of scalars in first matrix.
T2	Type of scalars in second matrix.
R	Row type of both matrices.
C	Column type of both matrices.

Parameters

m1	First matrix
m2	Second matrix

Returns: Elementwise division of matrices.

Definition at line 1469 of file matrix.hpp.

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

Eigen::Matrix<typename boost::math::tools::promote_args<T1,T2>::type, R, C> stan::math::elt_multiply	(	const Eigen::Matrix< T1, R, C > &	m1,
		const Eigen::Matrix< T2, R, C > &	m2
	)

Return the elementwise multiplication of the specified matrices.

Template Parameters

T1	Type of scalars in first matrix.
T2	Type of scalars in second matrix.
R	Row type of both matrices.
C	Column type of both matrices.

Parameters

m1	First matrix
m2	Second matrix

Returns: Elementwise product of matrices.

Definition at line 1412 of file matrix.hpp.

double stan::math::epsilon ( )

inline

Return minimum positive number representable.

Returns: Minimum positive number.

Definition at line 958 of file special_functions.hpp.

template<typename T , int Rows, int Cols>

Eigen::Matrix<T,Rows,Cols> stan::math::exp ( const Eigen::Matrix< T, Rows, Cols > & m )

inline

Return the element-wise exponentiation of the matrix or vector.

Parameters

m	The matrix or vector.

Returns: ret(i,j) = exp(m(i,j))

Definition at line 1240 of file matrix.hpp.

template<typename T >

boost::math::tools::promote_args<T>::type stan::math::exp2 ( T y )

inline

Return the exponent base 2 of the specified argument (C99).

The exponent base 2 function is defined by

exp2(y) = pow(2.0,y).

Parameters

y Value.

Template Parameters

T	Type of scalar.

Returns: Exponent base 2 of value.

Definition at line 34 of file special_functions.hpp.

double stan::math::F32	(	double	a,
		double	b,
		double	c,
		double	d,
		double	e,
		double	z
	)

Definition at line 13 of file internal_math.hpp.

template<typename T1 , typename T2 >

boost::math::tools::promote_args<T1, T2>::type stan::math::fdim	(	T1	a,
		T2	b
	)

inline

The positive difference function (C99).

The function is defined by

fdim(a,b) = (a > b) ? (a - b) : 0.0.

Parameters

a	First value.
b	Second value.

Returns: Returns min(a - b, 0.0).

Definition at line 52 of file special_functions.hpp.

template<typename T1 , typename T2 , typename T3 >

boost::math::tools::promote_args<T1,T2,T3>::type stan::math::fma	(	T1	a,
		T2	b,
		T3	c
	)

inline

The fused multiply-add operation (C99).

The function is defined by

fma(a,b,c) = (a * b) + c.

Parameters

a	First value.
b	Second value.
c	Third value.

Returns: Product of the first two values plust the third.

Definition at line 70 of file special_functions.hpp.

template<typename T >

T& stan::math::get_base1	(	std::vector< T > &	x,
		size_t	i,
		const char *	error_msg,
		size_t	idx
	)

inline

Return a reference to the value of the specified vector at the specified base-one index.

If the index is out of range, throw a std::out_of_range exception with the specified error message and index indicated.

Parameters

x	Vector from which to get a value.
i	Index into vector plus 1.
error_msg	Error message if the index is out of range.
idx	Nested index level to report in error message if the index is out of range.

Returns: Value of vector at i - 1

Template Parameters

T	type of value.

Definition at line 274 of file matrix.hpp.

template<typename T >

T& stan::math::get_base1	(	std::vector< std::vector< T > > &	x,
		size_t	i1,
		size_t	i2,
		const char *	error_msg,
		size_t	idx
	)

inline

Return a reference to the value of the specified vector at the specified base-one indexes.

If an index is out of range, throw a std::out_of_range exception with the specified error message and index indicated.

Parameters

x	Vector from which to get a value.
i1	First index plus 1.
i2	Second index plus 1.
error_msg	Error message if an index is out of range.
idx	Nested index level to report in error message if the index is out of range.

Returns: Value of vector at indexes.

Template Parameters

T	type of value.

Definition at line 299 of file matrix.hpp.

template<typename T >

T& stan::math::get_base1	(	std::vector< std::vector< std::vector< T > > > &	x,
		size_t	i1,
		size_t	i2,
		size_t	i3,
		const char *	error_msg,
		size_t	idx
	)

inline

Return a reference to the value of the specified vector at the specified base-one indexes.

If an index is out of range, throw a std::out_of_range exception with the specified error message and index indicated.

Parameters

x	Vector from which to get a value.
i1	First index plus 1.
i2	Second index plus 1.
i3	Third index plus 1.
error_msg	Error message if an index is out of range.
idx	Nested index level to report in error message if the index is out of range.

Returns: Value of vector at indexes.

Template Parameters

T	type of value.

Definition at line 326 of file matrix.hpp.

template<typename T >

T& stan::math::get_base1	(	std::vector< std::vector< std::vector< std::vector< T > > > > &	x,
		size_t	i1,
		size_t	i2,
		size_t	i3,
		size_t	i4,
		const char *	error_msg,
		size_t	idx
	)

inline

Return a reference to the value of the specified vector at the specified base-one indexes.

If an index is out of range, throw a std::out_of_range exception with the specified error message and index indicated.

Parameters

x	Vector from which to get a value.
i1	First index plus 1.
i2	Second index plus 1.
i3	Third index plus 1.
i4	Fourth index plus 1.
error_msg	Error message if an index is out of range.
idx	Nested index level to report in error message if the index is out of range.

Returns: Value of vector at indexes.

Template Parameters

T	type of value.

Definition at line 355 of file matrix.hpp.

template<typename T >

T& stan::math::get_base1	(	std::vector< std::vector< std::vector< std::vector< std::vector< T > > > > > &	x,
		size_t	i1,
		size_t	i2,
		size_t	i3,
		size_t	i4,
		size_t	i5,
		const char *	error_msg,
		size_t	idx
	)

inline

Return a reference to the value of the specified vector at the specified base-one indexes.

If an index is out of range, throw a std::out_of_range exception with the specified error message and index indicated.

Parameters

x	Vector from which to get a value.
i1	First index plus 1.
i2	Second index plus 1.
i3	Third index plus 1.
i4	Fourth index plus 1.
i5	Fifth index plus 1.
error_msg	Error message if an index is out of range.
idx	Nested index level to report in error message if the index is out of range.

Returns: Value of vector at indexes.

Template Parameters

T	type of value.

Definition at line 386 of file matrix.hpp.

template<typename T >

T& stan::math::get_base1	(	std::vector< std::vector< std::vector< std::vector< std::vector< std::vector< T > > > > > > &	x,
		size_t	i1,
		size_t	i2,
		size_t	i3,
		size_t	i4,
		size_t	i5,
		size_t	i6,
		const char *	error_msg,
		size_t	idx
	)

inline

Return a reference to the value of the specified vector at the specified base-one indexes.

If an index is out of range, throw a std::out_of_range exception with the specified error message and index indicated.

Parameters

x	Vector from which to get a value.
i1	First index plus 1.
i2	Second index plus 1.
i3	Third index plus 1.
i4	Fourth index plus 1.
i5	Fifth index plus 1.
i6	Sixth index plus 1.
error_msg	Error message if an index is out of range.
idx	Nested index level to report in error message if the index is out of range.

Returns: Value of vector at indexes.

Template Parameters

T	type of value.

Definition at line 419 of file matrix.hpp.

template<typename T >

T& stan::math::get_base1	(	std::vector< std::vector< std::vector< std::vector< std::vector< std::vector< std::vector< T > > > > > > > &	x,
		size_t	i1,
		size_t	i2,
		size_t	i3,
		size_t	i4,
		size_t	i5,
		size_t	i6,
		size_t	i7,
		const char *	error_msg,
		size_t	idx
	)

inline

Return a reference to the value of the specified vector at the specified base-one indexes.

If an index is out of range, throw a std::out_of_range exception with the specified error message and index indicated.

Parameters

x	Vector from which to get a value.
i1	First index plus 1.
i2	Second index plus 1.
i3	Third index plus 1.
i4	Fourth index plus 1.
i5	Fifth index plus 1.
i6	Sixth index plus 1.
i7	Seventh index plus 1.
error_msg	Error message if an index is out of range.
idx	Nested index level to report in error message if the index is out of range.

Returns: Value of vector at indexes.

Template Parameters

T	type of value.

Definition at line 455 of file matrix.hpp.

template<typename T >

T& stan::math::get_base1	(	std::vector< std::vector< std::vector< std::vector< std::vector< std::vector< std::vector< std::vector< T > > > > > > > > &	x,
		size_t	i1,
		size_t	i2,
		size_t	i3,
		size_t	i4,
		size_t	i5,
		size_t	i6,
		size_t	i7,
		size_t	i8,
		const char *	error_msg,
		size_t	idx
	)

inline

Return a reference to the value of the specified vector at the specified base-one indexes.

If an index is out of range, throw a std::out_of_range exception with the specified error message and index indicated.

Parameters

x	Vector from which to get a value.
i1	First index plus 1.
i2	Second index plus 1.
i3	Third index plus 1.
i4	Fourth index plus 1.
i5	Fifth index plus 1.
i6	Sixth index plus 1.
i7	Seventh index plus 1.
i8	Eigth index plus 1.
error_msg	Error message if an index is out of range.
idx	Nested index level to report in error message if the index is out of range.

Returns: Value of vector at indexes.

Template Parameters

T	type of value.

Definition at line 493 of file matrix.hpp.

template<typename T >

Eigen::Matrix<T,1,Eigen::Dynamic> stan::math::get_base1	(	Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > &	x,
		size_t	m,
		const char *	error_msg,
		size_t	idx
	)

inline

Return a copy of the row of the specified vector at the specified base-one row index.

If the index is out of range, throw a std::out_of_range exception with the specified error message and index indicated.

Warning: Because a copy is involved, it is inefficient to access element of matrices by first using this method to get a row then using a second call to get the value at a specified column.

Parameters

x	Matrix from which to get a row
m	Index into matrix plus 1.
error_msg	Error message if the index is out of range.
idx	Nested index level to report in error message if the index is out of range.

Returns: Row of matrix at i - 1.

Template Parameters

T	type of value.

Definition at line 532 of file matrix.hpp.

template<typename T >

T& stan::math::get_base1	(	Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > &	x,
		size_t	m,
		size_t	n,
		const char *	error_msg,
		size_t	idx
	)

inline

Return a reference to the value of the specified matrix at the specified base-one row and column indexes.

If either index is out of range, throw a std::out_of_range exception with the specified error message and index indicated.

Parameters

x	Matrix from which to get a row
m	Row index plus 1.
n	Column index plus 1.
error_msg	Error message if either index is out of range.
idx	Nested index level to report in error message if either index is out of range.

Returns: Value of matrix at row m - 1 and column n - 1.

Template Parameters

T	type of value.

Definition at line 558 of file matrix.hpp.

template<typename T >

T& stan::math::get_base1	(	Eigen::Matrix< T, Eigen::Dynamic, 1 > &	x,
		size_t	m,
		const char *	error_msg,
		size_t	idx
	)

inline

Return a reference to the value of the specified column vector at the specified base-one index.

If the index is out of range, throw a std::out_of_range exception with the specified error message and index indicated.

Parameters

x	Column vector from which to get a value.
m	Row index plus 1.
error_msg	Error message if the index is out of range.
idx	Nested index level to report in error message if the index is out of range.

Returns: Value of column vector at row m - 1.

Template Parameters

T	type of value.

Definition at line 584 of file matrix.hpp.

template<typename T >

T& stan::math::get_base1	(	Eigen::Matrix< T, 1, Eigen::Dynamic > &	x,
		size_t	n,
		const char *	error_msg,
		size_t	idx
	)

inline

Return a reference to the value of the specified row vector at the specified base-one index.

If the index is out of range, throw a std::out_of_range exception with the specified error message and index indicated.

Parameters

x	Row vector from which to get a value.
n	Column index plus 1.
error_msg	Error message if the index is out of range.
idx	Nested index level to report in error message if the index is out of range.

Returns: Value of row vector at column n - 1.

Template Parameters

T	type of value.

Definition at line 609 of file matrix.hpp.

void stan::math::grad2F1	(	double &	gradA,
		double &	gradC,
		double	a,
		double	b,
		double	c,
		double	z,
		double	precision = `1e-6`
	)

Definition at line 96 of file internal_math.hpp.

void stan::math::gradF32	(	double *	g,
		double	a,
		double	b,
		double	c,
		double	d,
		double	e,
		double	z
	)

Definition at line 48 of file internal_math.hpp.

void stan::math::gradIncBeta	(	double &	g1,
		double &	g2,
		double	a,
		double	b,
		double	z
	)

Definition at line 132 of file internal_math.hpp.

void stan::math::gradRegIncBeta	(	double &	g1,
		double &	g2,
		double	a,
		double	b,
		double	z,
		double	digammaA,
		double	digammaB,
		double	digammaSum,
		double	betaAB
	)

Definition at line 152 of file internal_math.hpp.

double stan::math::gradRegIncGamma	(	double	a,
		double	z,
		double	g,
		double	dig,
		double	precision = `1e-6`
	)

Definition at line 169 of file internal_math.hpp.

double stan::math::ibeta	(	const double &	a,
		const double &	b,
		const double &	x
	)

inline

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

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

Parameters

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

Returns: The normalized incomplete beta function.

Definition at line 627 of file special_functions.hpp.

double stan::math::if_else	(	bool	c,
		double	y_true,
		double	y_false
	)

inline

Return the second argument if the first argument is true and otherwise return the second argument.

This is just a convenience method to provide a function with the same behavior as the built-in ternary operator. In general, this function behaves as if defined by

if_else(c,y1,y0) = c ? y1 : y0.

Parameters

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

Definition at line 508 of file special_functions.hpp.

template<typename T >

unsigned int stan::math::int_step ( T y )

The integer step, or Heaviside, function.

Parameters

y	Value to test.

Returns: 1 if value is greater than 0 and 0 otherwise

Template Parameters

T	Scalar argument type.

Definition at line 103 of file special_functions.hpp.

template<typename T >

boost::math::tools::promote_args<T>::type stan::math::inv_cloglog ( T x )

inline

The inverse complementary log-log function.

The function is defined by

inv_cloglog(x) = -exp(-exp(x)).

This function can be used to implement the inverse link function for complenentary-log-log regression.

Parameters

x Argument.

Returns: Inverse complementary log-log of the argument.

Definition at line 287 of file special_functions.hpp.

template<typename T >

boost::math::tools::promote_args<T>::type stan::math::inv_logit ( T a )

inline

Returns the inverse logit function applied to the argument.

The inverse logit function is defined by

$\mbox{logit}^{-1}(x) = \frac{1}{1 + \exp(-x)}$ .

This function can be used to implement the inverse link function for logistic regression.

The inverse to this function is stan::math::logit.

Parameters

a Argument.

Returns: Inverse logit of argument.

Definition at line 205 of file special_functions.hpp.

template<typename T >

Eigen::Matrix<T,Eigen::Dynamic,Eigen::Dynamic> stan::math::inverse ( const Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > & m )

inline

Returns the inverse of the specified matrix.

Parameters

m	Specified matrix.

Returns: Inverse of the matrix.

Definition at line 1704 of file matrix.hpp.

template<typename Vector >

void stan::math::inverse_softmax	(	const Vector &	simplex,
		Vector &	y
	)

Writes the inverse softmax of the simplex argument into the second argument.

See stan::math::softmax for the inverse function and a definition of the relation.

The inverse softmax function is defined by

$\mbox{inverse\_softmax}(x)[i] = \log x[i]$ .

This function defines the inverse of stan::math::softmax up to a scaling factor.

Because of the definition, values of 0.0 in the simplex are converted to negative infinity, and values of 1.0 are converted to 0.0.

There is no check that the input vector is a valid simplex vector.

Parameters

simplex	Simplex vector input.
y	Vector into which the inverse softmax is written.

Exceptions

std::invalid_argument if size of the input and output vectors differ.

Definition at line 416 of file special_functions.hpp.

template<typename T1 , typename T2 >

boost::math::tools::promote_args<T1,T2>::type stan::math::lbeta	(	T1	a,
		T2	b
	)

inline

Return the log of the beta function applied to the specified arguments.

The beta function is defined for $a > 0$ and $b > 0$ by

$\mbox{B}(a,b) = \frac{\Gamma(a) \Gamma(b)}{\Gamma(a+b)}$ .

This function returns its log,

$\log \mbox{B}(a,b) = \log \Gamma(a) + \log \Gamma(b) - \log \Gamma(a+b)$ .

See boost::math::lgamma() for the double-based and stan::agrad for the variable-based log Gamma function.

Parameters

a	First value
b	Second value

Returns: Log of the beta function applied to the two values.

Template Parameters

T1	Type of first value.
T2	Type of second value.

Definition at line 150 of file special_functions.hpp.

template<typename T >

boost::math::tools::promote_args<T>::type stan::math::lmgamma	(	unsigned int	k,
		T	x
	)

inline

Return the natural logarithm of the multivariate gamma function with the speciifed dimensions and argument.

The multivariate gamma function $\Gamma_k(x)$ for dimensionality $k$ and argument $x$ is defined by

$\Gamma_k(x) = \pi^{k(k-1)/4} \, \prod_{j=1}^k \Gamma(x + (1 - j)/2)$ ,

where $\Gamma()$ is the gamma function.

Parameters

k	Number of dimensions.
x	Function argument.

Returns: Natural log of the multivariate gamma function.

Template Parameters

T	Type of scalar.

Definition at line 485 of file special_functions.hpp.

template<typename T , int Rows, int Cols>

Eigen::Matrix<T,Rows,Cols> stan::math::log ( const Eigen::Matrix< T, Rows, Cols > & m )

inline

Return the element-wise logarithm of the matrix or vector.

Parameters

m	The matrix or vector.

Returns: ret(i,j) = log(m(i,j))

Definition at line 1229 of file matrix.hpp.

double stan::math::log10 ( )

inline

Return natural logarithm of ten.

Returns: Natural logarithm of ten.

Definition at line 922 of file special_functions.hpp.

template<typename T >

boost::math::tools::promote_args<T>::type stan::math::log1m ( T x )

inline

Return the natural logarithm of one minus the specified value.

The main use of this function is to cut down on intermediate values during algorithmic differentiation.

Parameters

x	Specified value.

Returns: Natural log of one minus x.

Definition at line 459 of file special_functions.hpp.

template<typename T >

boost::math::tools::promote_args<T>::type stan::math::log1m_inv_logit ( const T & u )

inline

Returns the natural logarithm of 1 minus the inverse logit of the specified argument.

Template Parameters

T	Scalar type

Parameters

u Input.

Returns: log of 1 minus the inverse logit of the input.

Definition at line 590 of file special_functions.hpp.

template<typename T >

boost::math::tools::promote_args<T>::type stan::math::log1p ( T x )

inline

Return the natural logarithm of one plus the specified value.

The main use of this function is to cut down on intermediate values during algorithmic differentiation.

Parameters

x	Specified value.

Returns: Natural log of one plus x.

Definition at line 435 of file special_functions.hpp.

double stan::math::log1p_exp ( const double & a )

inline

Calculates the log of 1 plus the exponential of the specified value without overflow.

This function is related to other special functions by:

log_1p_exp(x)

= log1p(exp(a))

= log(1 + exp(x))

= log_sum_exp(0,x).

Definition at line 554 of file special_functions.hpp.

template<typename T >

boost::math::tools::promote_args<T>::type stan::math::log2 ( T a )

inline

Returns the base 2 logarithm of the argument (C99).

The function is defined by:

log2(a) = log(a) / std::log(2.0).

Template Parameters

T	type of scalar

Parameters

a Value.

Returns: Base 2 logarithm of the value.

Definition at line 87 of file special_functions.hpp.

double stan::math::log2 ( )

inline

Return natural logarithm of two.

Returns: Natural logarithm of two.

Definition at line 913 of file special_functions.hpp.

template<typename T , int R, int C>

T stan::math::log_determinant ( const Eigen::Matrix< T, R, C > & m )

inline

Returns the log absolute determinant of the specified square matrix.

Parameters

m	Specified matrix.

Returns: log absolute determinant of the matrix.

Exceptions

std::domain_error if matrix is not square.

Definition at line 841 of file matrix.hpp.

template<typename T >

boost::math::tools::promote_args<T>::type stan::math::log_inv_logit ( const T & u )

inline

Returns the natural logarithm of the inverse logit of the specified argument.

Template Parameters

T	Scalar type

Parameters

u Input.

Returns: log of the inverse logit of the input.

Definition at line 572 of file special_functions.hpp.

double stan::math::log_sum_exp	(	const double &	a,
		const double &	b
	)

inline

Calculates the log sum of exponetials without overflow.

$\log (\exp(a) + \exp(b)) = m + \log(\exp(a-m) + \exp(b-m))$ ,

where $m = max(a,b)$ .

Parameters

a	the first variable
b	the second variable

Definition at line 608 of file special_functions.hpp.

double stan::math::log_sum_exp ( const std::vector< double > & x )

Return the log of the sum of the exponentiated values of the specified sequence of values.

The function is defined as follows to prevent overflow in exponential calculations.

$\log \sum_{n=1}^N \exp(x_n) = \max(x) + \log \sum_{n=1}^N \exp(x_n - \max(x))$ .

Parameters

x	array of specified values

Definition at line 646 of file special_functions.hpp.

template<typename T1 , typename T2 >

int stan::math::logical_and	(	T1	x1,
		T2	x2
	)

inline

The logical and function which returns 1 if both arguments are unequal to zero and 0 otherwise.

Equivalent to x1 != 0 && x2 != 0.

Template Parameters

T1	Type of first argument.
T2	Type of second argument.

Parameters

x1	First argument
x2	Second argument

Returns: true if both x1 and x2 are not equal to 0.

Definition at line 711 of file special_functions.hpp.

template<typename T1 , typename T2 >

int stan::math::logical_eq	(	T1	x1,
		T2	x2
	)

inline

Return 1 if the first argument is equal to the second.

Equivalent to x1 == x2.

Template Parameters

T1	Type of first argument.
T2	Type of second argument.

Parameters

x1	First argument
x2	Second argument

Returns: true iff x1 == x2

Definition at line 730 of file special_functions.hpp.

template<typename T1 , typename T2 >

int stan::math::logical_gt	(	T1	x1,
		T2	x2
	)

inline

Return 1 if the first argument is strictly greater than the second.

Equivalent to x1 < x2.

Template Parameters

T1	Type of first argument.
T2	Type of second argument.

Parameters

x1	First argument
x2	Second argument

Returns: true iff x1 > x2

Definition at line 798 of file special_functions.hpp.

template<typename T1 , typename T2 >

int stan::math::logical_gte	(	T1	x1,
		T2	x2
	)

inline

Return 1 if the first argument is greater than or equal to the second.

Equivalent to x1 >= x2.

Template Parameters

T1	Type of first argument.
T2	Type of second argument.

Parameters

x1	First argument
x2	Second argument

Returns: true iff x1 >= x2

Definition at line 815 of file special_functions.hpp.

template<typename T1 , typename T2 >

int stan::math::logical_lt	(	T1	x1,
		T2	x2
	)

inline

Return 1 if the first argument is strictly less than the second.

Equivalent to x1 < x2.

Template Parameters

T1	Type of first argument.
T2	Type of second argument.

Parameters

x1	First argument
x2	Second argument

Returns: true iff x1 < x2

Definition at line 764 of file special_functions.hpp.

template<typename T1 , typename T2 >

int stan::math::logical_lte	(	T1	x1,
		T2	x2
	)

inline

Return 1 if the first argument is less than or equal to the second.

Equivalent to x1 <= x2.

Template Parameters

T1	Type of first argument.
T2	Type of second argument.

Parameters

x1	First argument
x2	Second argument

Returns: true iff x1 <= x2

Definition at line 781 of file special_functions.hpp.

template<typename T >

int stan::math::logical_negation ( T x )

inline

The logical negation function which returns 1 if the input is equal to zero and 0 otherwise.

Template Parameters

T	Type to compare to zero.

Parameters

x	Value to compare to zero.

Returns: 1 if input is equal to zero.

Definition at line 674 of file special_functions.hpp.

template<typename T1 , typename T2 >

int stan::math::logical_neq	(	T1	x1,
		T2	x2
	)

inline

Return 1 if the first argument is unequal to the second.

Equivalent to x1 != x2.

Template Parameters

T1	Type of first argument.
T2	Type of second argument.

Parameters

x1	First argument
x2	Second argument

Returns: true iff x1 != x2

Definition at line 747 of file special_functions.hpp.

template<typename T1 , typename T2 >

int stan::math::logical_or	(	T1	x1,
		T2	x2
	)

inline

The logical or function which returns 1 if either argument is unequal to zero and 0 otherwise.

Equivalent to x1 != 0 || x2 != 0.

Template Parameters

T1	Type of first argument.
T2	Type of second argument.

Parameters

x1	First argument
x2	Second argument

Returns: true if either x1 or x2 is not equal to 0.

Definition at line 692 of file special_functions.hpp.

template<typename T >

boost::math::tools::promote_args<T>::type stan::math::logit ( T a )

inline

Returns the logit function applied to the argument.

The logit function is defined as for $x \in [0,1]$ by returning the log odds of $x$ treated as a probability,

$\mbox{logit}(x) = \log \left( \frac{x}{1 - x} \right)$ .

The inverse to this function is stan::math::inv_logit.

Parameters

a Argument.

Returns: Logit of the argument.

Definition at line 226 of file special_functions.hpp.

double stan::math::max	(	double	a,
		double	b
	)

inline

Definition at line 12 of file util.hpp.

double stan::math::max ( std::vector< double > & x )

inline

Definition at line 16 of file util.hpp.

int stan::math::max ( const std::vector< int > & x )

inline

Returns the maximum coefficient in the specified column vector.

Parameters

v	Specified vector.

Returns: Maximum coefficient value in the vector.

Template Parameters

Type	of values being compared and returned

Exceptions

std::domain_error If the size of the vector is zero.

Definition at line 999 of file matrix.hpp.

template<typename T >

T stan::math::max ( const std::vector< T > & x )

inline

Returns the maximum coefficient in the specified column vector.

Parameters

v	Specified vector.

Returns: Maximum coefficient value in the vector.

Template Parameters

T	Type of values being compared and returned

Definition at line 1017 of file matrix.hpp.

template<typename T , int R, int C>

T stan::math::max ( const Eigen::Matrix< T, R, C > & m )

inline

Returns the maximum coefficient in the specified vector, row vector, or matrix.

Parameters

v	Specified vector, row vector, or matrix.

Returns: Maximum coefficient value in the vector.

Definition at line 1034 of file matrix.hpp.

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

Eigen::Matrix<typename boost::math::tools::promote_args<T1,T2>::type,R1,C2> stan::math::mdivide_left	(	const Eigen::Matrix< T1, R1, C1 > &	A,
		const Eigen::Matrix< T2, R2, C2 > &	b
	)

inline

Returns the solution of the system Ax=b.

Parameters

A	Matrix.
b	Right hand side matrix or vector.

Returns: x = A^-1 b, solution of the linear system.

Exceptions

std::domain_error if A is not square or the rows of b don't match the size of A.

Definition at line 1815 of file matrix.hpp.

template<int TriView, typename T1 , typename T2 , int R1, int C1, int R2, int C2>

Eigen::Matrix<typename boost::math::tools::promote_args<T1,T2>::type, R1,C2> stan::math::mdivide_left_tri	(	const Eigen::Matrix< T1, R1, C1 > &	A,
		const Eigen::Matrix< T2, R2, C2 > &	b
	)

inline

Returns the solution of the system Ax=b when A is triangular.

Parameters

A	Triangular matrix. Specify upper or lower with TriView being Eigen::Upper or Eigen::Lower.
b	Right hand side matrix or vector.

Returns: x = A^-1 b, solution of the linear system.

Exceptions

std::domain_error if A is not square or the rows of b don't match the size of A.

Definition at line 1748 of file matrix.hpp.

template<int TriView, typename T , int R1, int C1>

Eigen::Matrix<T,R1,C1> stan::math::mdivide_left_tri ( const Eigen::Matrix< T, R1, C1 > & A )

inline

Returns the solution of the system Ax=b when A is triangular and b=I.

Parameters

A	Triangular matrix. Specify upper or lower with TriView being Eigen::Upper or Eigen::Lower.

Returns: x = A^-1 .

Exceptions

std::domain_error if A is not square

Definition at line 1767 of file matrix.hpp.

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

Eigen::Matrix<typename boost::math::tools::promote_args<T1,T2>::type, R1,C2> stan::math::mdivide_left_tri_low	(	const Eigen::Matrix< T1, R1, C1 > &	A,
		const Eigen::Matrix< T2, R2, C2 > &	b
	)

inline

Definition at line 1779 of file matrix.hpp.

template<typename T , int R1, int C1>

Eigen::Matrix<T,R1,C1> stan::math::mdivide_left_tri_low ( const Eigen::Matrix< T, R1, C1 > & A )

inline

Definition at line 1793 of file matrix.hpp.

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

Eigen::Matrix<typename boost::math::tools::promote_args<T1,T2>::type,R1,C2> stan::math::mdivide_right	(	const Eigen::Matrix< T1, R1, C1 > &	b,
		const Eigen::Matrix< T2, R2, C2 > &	A
	)

inline

Returns the solution of the system Ax=b.

Parameters

A	Matrix.
b	Right hand side matrix or vector.

Returns: x = b A^-1, solution of the linear system.

Exceptions

std::domain_error if A is not square or the rows of b don't match the size of A.

Definition at line 1897 of file matrix.hpp.

template<int TriView, typename T1 , typename T2 , int R1, int C1, int R2, int C2>

Eigen::Matrix<typename boost::math::tools::promote_args<T1,T2>::type,R1,C2> stan::math::mdivide_right_tri	(	const Eigen::Matrix< T1, R1, C1 > &	b,
		const Eigen::Matrix< T2, R2, C2 > &	A
	)

inline

Returns the solution of the system Ax=b when A is triangular.

Parameters

A	Triangular matrix. Specify upper or lower with TriView being Eigen::Upper or Eigen::Lower.
b	Right hand side matrix or vector.

Returns: x = b A^-1, solution of the linear system.

Exceptions

std::domain_error if A is not square or the rows of b don't match the size of A.

Definition at line 1839 of file matrix.hpp.

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

Eigen::Matrix<typename boost::math::tools::promote_args<T1,T2>::type,R1,C2> stan::math::mdivide_right_tri_low	(	const Eigen::Matrix< T1, R1, C1 > &	b,
		const Eigen::Matrix< T2, R2, C2 > &	A
	)

inline

Returns the solution of the system tri(A)x=b when tri(A) is a lower triangular view of the matrix A.

Parameters

A	Matrix.
b	Right hand side matrix or vector.

Returns: x = b * tri(A)^-1, solution of the linear system.

Exceptions

std::domain_error if A is not square or the rows of b don't match the size of A.

Definition at line 1875 of file matrix.hpp.

template<typename T >

boost::math::tools::promote_args<T>::type stan::math::mean ( const std::vector< T > & v )

inline

Returns the sample mean (i.e., average) of the coefficients in the specified standard vector.

Parameters

v	Specified vector.

Returns: Sample mean of vector coefficients.

Exceptions

std::domain_error if the size of the vector is less than 1.

Definition at line 1051 of file matrix.hpp.

template<typename T , int R, int C>

boost::math::tools::promote_args<T>::type stan::math::mean ( const Eigen::Matrix< T, R, C > & m )

inline

Returns the sample mean (i.e., average) of the coefficients in the specified vector, row vector, or matrix.

Parameters

m	Specified vector, row vector, or matrix.

Returns: Sample mean of vector coefficients.

Definition at line 1068 of file matrix.hpp.

double stan::math::min	(	double	a,
		double	b
	)

inline

Definition at line 25 of file util.hpp.

int stan::math::min ( const std::vector< int > & x )

inline

Returns the minimum coefficient in the specified column vector.

Parameters

v	Specified vector.

Returns: Minimum coefficient value in the vector.

Template Parameters

Type	of values being compared and returned

Definition at line 948 of file matrix.hpp.

template<typename T >

T stan::math::min ( const std::vector< T > & x )

inline

Returns the minimum coefficient in the specified column vector.

Parameters

v	Specified vector.

Returns: Minimum coefficient value in the vector.

Template Parameters

Type	of values being compared and returned

Definition at line 966 of file matrix.hpp.

template<typename T , int R, int C>

T stan::math::min ( const Eigen::Matrix< T, R, C > & m )

inline

Returns the minimum coefficient in the specified matrix, vector, or row vector.

Parameters

v	Specified matrix, vector, or row vector.

Returns: Minimum coefficient value in the vector.

Definition at line 983 of file matrix.hpp.

template<typename T >

T stan::math::minus ( const T & x )

inline

Returns the negation of the specified scalar or matrix.

Template Parameters

T	Type of subtrahend.

Parameters

x	Subtrahend.

Returns: Negation of subtrahend.

Definition at line 1377 of file matrix.hpp.

template<int R, int C>

Eigen::Matrix<double,R,C> stan::math::multiply	(	const Eigen::Matrix< double, R, C > &	m,
		double	c
	)

inline

Return specified matrix multiplied by specified scalar.

Template Parameters

R	Row type for matrix.
C	Column type for matrix.

Parameters

m	Matrix.
c	Scalar.

Returns: Product of matrix and scalar.

Definition at line 1491 of file matrix.hpp.

template<int R, int C>

Eigen::Matrix<double,R,C> stan::math::multiply	(	double	c,
		const Eigen::Matrix< double, R, C > &	m
	)

inline

Return specified scalar multiplied by specified matrix.

Template Parameters

R	Row type for matrix.
C	Column type for matrix.

Parameters

c	Scalar.
m	Matrix.

Returns: Product of scalar and matrix.

Definition at line 1506 of file matrix.hpp.

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

Eigen::Matrix<double,R1,C2> stan::math::multiply	(	const Eigen::Matrix< double, 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

m1	First matrix.
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 1523 of file matrix.hpp.

template<int C1, int R2>

double stan::math::multiply	(	const Eigen::Matrix< double, 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

rv	Row vector.
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 1539 of file matrix.hpp.

template<typename T_a , typename T_b >

boost::math::tools::promote_args<T_a,T_b>::type stan::math::multiply_log	(	T_a	a,
		T_b	b
	)

inline

Definition at line 533 of file special_functions.hpp.

matrix_d stan::math::multiply_lower_tri_self_transpose ( const matrix_d & L )

inline

Returns the result of multiplying the lower triangular portion of the input matrix by its own transpose.

Parameters

L	Matrix to multiply.

Returns: The lower triangular values in L times their own transpose.

Exceptions

std::domain_error If the input matrix is not square.

Definition at line 1556 of file matrix.hpp.

double stan::math::negative_epsilon ( )

inline

Return maximum negative number (i.e., negative number with smallest absolute value).

Returns: Maximum negative number.

Definition at line 968 of file special_functions.hpp.

double stan::math::negative_infinity ( )

inline

Return negative infinity.

Returns: Negative infinity.

Definition at line 940 of file special_functions.hpp.

double stan::math::not_a_number ( )

inline

Return (quiet) not-a-number.

Returns: Quiet not-a-number.

Definition at line 949 of file special_functions.hpp.

template<typename T >

boost::math::tools::promote_args<T>::type stan::math::Phi ( T x )

inline

The unit normal cumulative distribution function.

The return value for a specified input is the probability that a random unit normal variate is less than or equal to the specified value, defined by

$\Phi(x) = \int_{-\infty}^x \mbox{\sf Norm}(x|0,1) \ dx$

This function can be used to implement the inverse link function for probit regression.

Parameters

x Argument.

Returns: Probability random sample is less than or equal to argument.

Definition at line 250 of file special_functions.hpp.

template<typename T >

boost::math::tools::promote_args<T>::type stan::math::Phi_approx ( T x )

inline

Approximation of the unit normal CDF.

http://www.jiem.org/index.php/jiem/article/download/60/27

This function can be used to implement the inverse link function for probit regression.

Parameters

x Argument.

Returns: Probability random sample is less than or equal to argument.

Definition at line 268 of file special_functions.hpp.

double stan::math::pi ( )

inline

Return the value of pi.

Returns: Pi.

Definition at line 886 of file special_functions.hpp.

double stan::math::positive_infinity ( )

inline

Return positive infinity.

Returns: Positive infinity.

Definition at line 931 of file special_functions.hpp.

template<typename T >

T stan::math::prod ( const std::vector< T > & v )

inline

Returns the product of the coefficients of the specified standard vector.

Parameters

v	Specified vector.

Returns: Product of coefficients of vector.

Definition at line 1188 of file matrix.hpp.

template<typename T , int R, int C>

T stan::math::prod ( const Eigen::Matrix< T, R, C > & v )

inline

Returns the product of the coefficients of the specified column vector.

Parameters

v	Specified vector.

Returns: Product of coefficients of vector.

Definition at line 1203 of file matrix.hpp.

template<typename T1 , typename T2 , typename F >

common_type<T1,T2>::type stan::math::promote_common ( const F & u )

inline

Definition at line 118 of file matrix.hpp.

template<typename T >

void stan::math::resize	(	T &	x,
		std::vector< size_t >	dims
	)

inline

Recursively resize the specified vector of vectors, which must bottom out at scalar values, Eigen vectors or Eigen matrices.

Parameters

x	Array-like object to resize.
dims	New dimensions.

Template Parameters

T	Type of object being resized.

Definition at line 221 of file matrix.hpp.

template<typename T >

Eigen::Matrix<T,1,Eigen::Dynamic> stan::math::row	(	const Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > &	m,
		size_t	i
	)

inline

Return the specified row of the specified matrix, using start-at-1 indexing.

This is equivalent to calling m.row(i - 1) and assigning the resulting template expression to a row vector.

Template Parameters

T	Scalar value type for matrix.

Parameters

m	Matrix.
i	Row index (count from 1).

Returns: Specified row of the matrix.

Definition at line 1615 of file matrix.hpp.

template<typename T , int R, int C>

size_t stan::math::rows ( const Eigen::Matrix< T, R, C > & m )

inline

Definition at line 623 of file matrix.hpp.

void stan::math::scaled_add	(	std::vector< double > &	x,
		std::vector< double > &	y,
		double	lambda
	)

inline

Definition at line 47 of file util.hpp.

template<typename T >

boost::math::tools::promote_args<T>::type stan::math::sd ( const std::vector< T > & v )

inline

Returns the unbiased sample standard deviation of the coefficients in the specified column vector.

Parameters

v	Specified vector.

Returns: Sample variance of vector.

Definition at line 1131 of file matrix.hpp.

template<typename T , int R, int C>

boost::math::tools::promote_args<T>::type stan::math::sd ( const Eigen::Matrix< T, R, C > & m )

inline

Returns the unbiased sample standard deviation of the coefficients in the specified vector, row vector, or matrix.

Parameters

m	Specified vector, row vector or matrix.

Returns: Sample variance.

Definition at line 1146 of file matrix.hpp.

template<typename T1 , typename T2 , typename T3 >

double stan::math::simple_var	(	double	v,
		const T1 &	,
		const T1 &	,
		const T2 &	,
		const T2 &	,
		const T3 &	,
		const T3 &
	)

inline

Return the scalar value and ignore the remaining arguments.

This function provides an overload of simple_var to use with primitive values for which the type and derivative type are the same. The other overloads are for stan::agrad::var arguments; the definitions can be found in stan/agrad/partials_vari.hpp.

Template Parameters

T1	Type of first dummy argument and derivative.
T2	Type of second dummy argument and derivative.
T3	Type of third dummy argument and derivative.

Parameters

v	Value to return.

Returns: Value.

Definition at line 839 of file special_functions.hpp.

template<typename T >

Eigen::Matrix<T,Eigen::Dynamic,1> stan::math::singular_values ( const Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > & m )

Return the vector of the singular values of the specified matrix in decreasing order of magnitude.

See the documentation for svd() for information on the signular values.

Parameters

m	Specified matrix.

Returns: Singular values of the matrix.

Definition at line 1974 of file matrix.hpp.

template<typename Vector , typename Scalar >

void stan::math::softmax	(	const Vector &	x,
		Vector &	simplex
	)

Write the values of the softmax transformed first argument into the second argument.

Values in the first argument are unbounded and values in the output form a simplex.

The softmax transformed generalizes the inverse logistic function by transforming a vector $x$ of length $K$ as

$\mbox{softmax}(x)[i] = \frac{\exp(x[i])}{\sum_{k=1}^{K} \exp(x[k])}$ .

By construction, the result is a simplex, which means the values are all non-negative and sum to 1.0,

$\sum_{k=1}^{K} \mbox{softmax}(x)[k] = 1$ .

The type Vector is for a vector with values of type Scalar. Vectors x must support x.size() and return assignable references of type Scalar through x[int]. Variables a of type Scalar need to support division (in context x[i] /= a) and exponentiation (exp(a)). Conforming examples include

Vector = std::vector<double> and Scalar = double,

Vector = std::vector<stan::agrad::var> and Scalar = stan::agrad::var,

Vector = Eigen::Matrix<double,Eigen::Dynamic,1><double> and Scalar = double,

and so on.

The function stan::math::inverse_softmax provides an inverse of this operation up to an additive constant. Specifically, if x is a simplex argument, then

softmax(inv_softmax(x)) = x.

If y is an arbitrary vector, then we only have identification up to an additive constant c, as in

inv_softmax(softmax(y)) = y + c * I.

Parameters

x	Input vector of unbounded parameters.
simplex	Output vector of simplex values.

Exceptions

std::invalid_argument if size of the input and output vectors differ.

Definition at line 379 of file special_functions.hpp.

template<typename T >

Eigen::Matrix<T,Eigen::Dynamic,1> stan::math::softmax ( const Eigen::Matrix< T, Eigen::Dynamic, 1 > & v )

inline

Return the softmax of the specified vector.

Template Parameters

T	Scalar type of values in vector.

Parameters

[in] v Vector to transform.

Returns: Unit simplex result of the softmax transform of the vector.

Definition at line 1719 of file matrix.hpp.

double stan::math::sqrt2 ( )

inline

Return the square root of two.

Returns: Square root of two.

Definition at line 904 of file special_functions.hpp.

template<typename T >

T stan::math::square ( T x )

inline

Return the square of the specified argument.

$\mbox{square}(x) = x^2$ .

The implementation of square(x) is just x * x. Given this, this method is mainly useful in cases where x is not a simple primitive type, particularly when it is an auto-dif type.

Parameters

x	Input to square.

Returns: Square of input.

Template Parameters

T	Type of scalar.

Definition at line 527 of file special_functions.hpp.

template<typename T >

int stan::math::step ( T y )

inline

The step, or Heaviside, function.

The function is defined by

step(y) = (y < 0.0) ? 0 : 1.

Parameters

y	Scalar argument.

Returns: 1 if the specified argument is greater than or equal to 0.0, and 0 otherwise.

Definition at line 120 of file special_functions.hpp.

void stan::math::sub	(	std::vector< double > &	x,
		std::vector< double > &	y,
		std::vector< double > &	result
	)

inline

Definition at line 54 of file util.hpp.

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

Eigen::Matrix<typename boost::math::tools::promote_args<T1,T2>::type, R, C> stan::math::subtract	(	const Eigen::Matrix< T1, R, C > &	m1,
		const Eigen::Matrix< T2, R, C > &	m2
	)

inline

Return the result of subtracting the second specified matrix from the first specified matrix.

The return scalar type is the promotion of the input types.

Template Parameters

T1	Scalar type of first matrix.
T2	Scalar type of second matrix.
R	Row type of matrices.
C	Column type of matrices.

Parameters

m1	First matrix.
m2	Second matrix.

Returns: Difference between first matrix and second matrix.

Definition at line 1331 of file matrix.hpp.

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

Eigen::Matrix<typename boost::math::tools::promote_args<T1,T2>::type, R, C> stan::math::subtract	(	const T1 &	c,
		const Eigen::Matrix< T2, R, C > &	m
	)

inline

Definition at line 1344 of file matrix.hpp.

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

Eigen::Matrix<typename boost::math::tools::promote_args<T1,T2>::type, R, C> stan::math::subtract	(	const Eigen::Matrix< T1, R, C > &	m,
		const T2 &	c
	)

inline

Definition at line 1356 of file matrix.hpp.

double stan::math::sum ( std::vector< double > & x )

inline

Definition at line 71 of file util.hpp.

template<typename T >

T stan::math::sum ( const std::vector< T > & xs )

inline

Return the sum of the values in the specified standard vector.

Parameters

xs	Standard vector to sum.

Returns: Sum of elements.

Template Parameters

T	Type of elements summed.

Definition at line 1162 of file matrix.hpp.

template<typename T , int R, int C>

double stan::math::sum ( const Eigen::Matrix< T, R, C > & v )

inline

Returns the sum of the coefficients of the specified column vector.

Parameters

v	Specified vector.

Returns: Sum of coefficients of vector.

Definition at line 1177 of file matrix.hpp.

matrix_d stan::math::tcrossprod ( const matrix_d & 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 1577 of file matrix.hpp.

template<typename T >

T stan::math::trace ( const Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > & m )

inline

Returns the trace of the specified matrix.

The trace is defined as the sum of the elements on the diagonal. The matrix is not required to be square. Returns 0 if matrix is empty.

Parameters

[in] m Specified matrix.

Returns: Trace of the matrix.

Definition at line 1218 of file matrix.hpp.

template<typename T , int R, int C>

Eigen::Matrix<T,C,R> stan::math::transpose ( const Eigen::Matrix< T, R, C > & m )

inline

Definition at line 1692 of file matrix.hpp.

template<typename T , int R, int C>

void stan::math::validate_column_index	(	const Eigen::Matrix< T, R, C > &	m,
		size_t	j,
		const char *	msg
	)

Definition at line 689 of file matrix.hpp.

template<typename T1 , typename T2 >

void stan::math::validate_greater	(	const T1 &	x,
		const T2 &	y,
		const char *	x_name,
		const char *	y_name,
		const char *	fun_name
	)

inline

Definition at line 674 of file matrix.hpp.

template<typename T1 , typename T2 >

void stan::math::validate_greater_or_equal	(	const T1 &	x,
		const T2 &	y,
		const char *	x_name,
		const char *	y_name,
		const char *	fun_name
	)

inline

Definition at line 661 of file matrix.hpp.

template<typename T1 , typename T2 >

void stan::math::validate_less	(	const T1 &	x,
		const T2 &	y,
		const char *	x_name,
		const char *	y_name,
		const char *	fun_name
	)

inline

Definition at line 648 of file matrix.hpp.

template<typename T1 , typename T2 >

void stan::math::validate_less_or_equal	(	const T1 &	x,
		const T2 &	y,
		const char *	x_name,
		const char *	y_name,
		const char *	fun_name
	)

inline

Definition at line 635 of file matrix.hpp.

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

void stan::math::validate_matching_dims	(	const Eigen::Matrix< T1, R1, C1 > &	x1,
		const Eigen::Matrix< T2, R2, C2 > &	x2,
		const char *	msg
	)

inline

Definition at line 744 of file matrix.hpp.

template<typename T1 , typename T2 >

void stan::math::validate_matching_sizes	(	const std::vector< T1 > &	x1,
		const std::vector< T2 > &	x2,
		const char *	msg
	)

inline

Definition at line 758 of file matrix.hpp.

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

void stan::math::validate_matching_sizes	(	const Eigen::Matrix< T1, R1, C1 > &	x1,
		const Eigen::Matrix< T2, R2, C2 > &	x2,
		const char *	msg
	)

inline

Definition at line 771 of file matrix.hpp.

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

void stan::math::validate_multiplicable	(	const Eigen::Matrix< T1, R1, C1 > &	x1,
		const Eigen::Matrix< T2, R2, C2 > &	x2,
		const char *	msg
	)

inline

Definition at line 786 of file matrix.hpp.

void stan::math::validate_non_negative_index	(	const std::string &	var_name,
		const std::string &	expr,
		int	val
	)

inline

Definition at line 16 of file matrix_error_handling.hpp.

template<typename T >

void stan::math::validate_nonzero_size	(	const T &	x,
		const char *	msg
	)

inline

Definition at line 799 of file matrix.hpp.

template<typename T , int R, int C>

void stan::math::validate_row_index	(	const Eigen::Matrix< T, R, C > &	m,
		size_t	i,
		const char *	msg
	)

Definition at line 701 of file matrix.hpp.

template<typename T , int R, int C>

void stan::math::validate_square	(	const Eigen::Matrix< T, R, C > &	x,
		const char *	msg
	)

Definition at line 713 of file matrix.hpp.

template<typename T , int R, int C>

void stan::math::validate_symmetric	(	const Eigen::Matrix< T, R, C > &	x,
		const char *	msg
	)

Definition at line 725 of file matrix.hpp.

template<typename T , int R, int C>

void stan::math::validate_vector	(	const Eigen::Matrix< T, R, C > &	x,
		const char *	msg
	)

inline

Definition at line 808 of file matrix.hpp.

template<typename T >

double stan::math::value_of ( T x )

inline

Return the value of the specified scalar argument converted to a double value.

This function is meant to cover the primitive types. For types requiring pass-by-reference, this template function should be specialized.

Template Parameters

T	Type of scalar.

Parameters

x	Scalar to convert to double.

Returns: Value of scalar cast to a double.

Definition at line 859 of file special_functions.hpp.

template<>

double stan::math::value_of< double > ( double x )

inline

Return the specified argument.

See value_of(T) for a polymorphic implementation using static casts.

This inline pass-through no-op should be compiled away.

Parameters

x	Specified value.

Returns: Specified value.

Definition at line 875 of file special_functions.hpp.

template<typename T >

boost::math::tools::promote_args<T>::type stan::math::variance ( const std::vector< T > & v )

inline

Returns the sample variance (divide by length - 1) of the coefficients in the specified standard vector.

Parameters

v	Specified vector.

Returns: Sample variance of vector.

Exceptions

std::domain_error if the size of the vector is less than 1.

Definition at line 1084 of file matrix.hpp.

template<typename T , int R, int C>

boost::math::tools::promote_args<T>::type stan::math::variance ( const Eigen::Matrix< T, R, C > & m )

inline

Returns the sample variance (divide by length - 1) of the coefficients in the specified column vector.

Parameters

v	Specified vector.

Returns: Sample variance of vector.

Definition at line 1106 of file matrix.hpp.

Variable Documentation

const double stan::math::CONSTRAINT_TOLERANCE = 1E-8

The tolerance for checking arithmetic bounds In rank and in simplexes.

The default value is 1E-8.

Definition at line 24 of file error_handling.hpp.

const double stan::math::E = boost::math::constants::e<double>()

The base of the natural logarithm, $ e $ .

Definition at line 14 of file constants.hpp.

const double stan::math::EPSILON = std::numeric_limits<double>::epsilon()

Smallest positive value.

Definition at line 52 of file constants.hpp.

const double stan::math::INFTY = std::numeric_limits<double>::infinity()

Positive infinity.

Definition at line 37 of file constants.hpp.

const double stan::math::LOG_10 = std::log(10.0)

The natural logarithm of 10, $\log 10$ .

Definition at line 32 of file constants.hpp.

const double stan::math::LOG_2 = std::log(2.0)

The natural logarithm of 2, $\log 2$ .

Definition at line 26 of file constants.hpp.

const double stan::math::NEGATIVE_EPSILON = - std::numeric_limits<double>::epsilon()

Largest negative value (i.e., smallest absolute value).

Definition at line 57 of file constants.hpp.

const double stan::math::NEGATIVE_INFTY = - std::numeric_limits<double>::infinity()

Negative infinity.

Definition at line 42 of file constants.hpp.

const double stan::math::NOT_A_NUMBER = std::numeric_limits<double>::quiet_NaN()

(Quiet) not-a-number value.

Definition at line 47 of file constants.hpp.

const double stan::math::SQRT_2 = std::sqrt(2.0)

The value of the square root of 2, $\sqrt{2}$ .

Definition at line 20 of file constants.hpp.

Namespaces

Classes

Typedefs

Functions

Variables

Detailed Description

Typedef Documentation

Function Documentation

Variable Documentation