Scythe-1.0.3: scythe Namespace Reference

The Scythe library namespace. More...

Classes
struct	exponentiate
	A Functor encapsulating exponentiation. More...
struct	ax_plus_b
	A Functor encapsulating . More...
class	DataBlock
	Handles Matrix data internals. More...
class	NullDataBlock
	Null data block object. More...
class	DataBlockReference
	Handle to DataBlock objects. More...
struct	all_elements
	A convenient marker for vector submatrix access. More...
class	scythe_exception
	The Scythe exception abstract base class. More...
class	scythe_alloc_error
	Memory allocation error. More...
class	scythe_invalid_arg
	Invalid function argument. More...
class	scythe_file_error
	File i/o error. More...
class	scythe_conformation_error
	Matrix conformation error. More...
class	scythe_dimension_error
	Matrix dimension error. More...
class	scythe_null_error
	Null Matrix error. More...
class	scythe_type_error
	Matrix type error. More...
class	scythe_bounds_error
	Element out of bounds error. More...
class	scythe_convergence_error
	Numerical convergence error. More...
class	scythe_range_error
	Numerical underflow or overflow error. More...
class	scythe_precision_error
	Numerical precision error. More...
class	scythe_randseed_error
	Random number seed error. More...
class	scythe_style_error
	Matrix style error. More...
class	scythe_lapack_internal_error
	LAPACK Internal Error. More...
class	scythe_unexpected_default_error
	Unexpected call to default error. More...
struct	QRdecomp
	The result of a QR decomposition. More...
struct	SVD
	The result of a singular value decomposition. More...
struct	Eigen
	The result of an eigenvalue/vector decomposition. More...
struct	GeneralEigen
class	ListInitializer
	A helper class for list-wise initialization. More...
class	Matrix_base
	Matrix superclass. More...
class	Matrix
	An STL-compliant matrix container class. More...
class	const_matrix_bidirectional_iterator
	An STL-compliant const bidirectional iterator for Matrix. More...
class	matrix_bidirectional_iterator
	An STL-compliant bidirectional iterator for Matrix. More...
class	const_matrix_forward_iterator
	An STL-compliant const forward iterator for Matrix. More...
class	matrix_forward_iterator
	An STL-compliant forward iterator for Matrix. More...
class	const_matrix_random_access_iterator
	An STL-compliant const random access iterator for Matrix. More...
class	matrix_random_access_iterator
	An STL-compliant random access iterator for Matrix. More...
class	lecuyer
	The L'Ecuyer random number generator. More...
class	mersenne
	The Mersenne Twister random number generator. More...
class	rtmvnorm
	Truncated multivariate normal distribution random number generator. More...
class	wrapped_generator
	Adaptor for non-Scythe quasi-random number generators. More...
class	rng
	Random number generator. More...
Enumerations
enum	matrix_order { Col, Row }
	Matrix order enumerator. More...
enum	matrix_style { Concrete, View }
	Matrix style enumerator. More...
Functions
template<typename T , matrix_order O, matrix_style S, class FUNCTOR >
void	for_each_ij_set (Matrix< T, O, S > &M, FUNCTOR func)
	Iterate through a Matrix in order.
template<matrix_order ORDER1, matrix_order ORDER2, typename T , typename S , matrix_order SO, matrix_style SS, matrix_order DO, matrix_style DS>
void	copy (const Matrix< T, SO, SS > &source, Matrix< S, DO, DS > &dest)
	Copy the contents of one Matrix into another.
template<matrix_order ORDER1, matrix_order ORDER2, typename T , matrix_order SO, matrix_style SS, matrix_order DO, matrix_style DS>
void	copy_recycle (const Matrix< T, SO, SS > &source, Matrix< T, DO, DS > &dest)
	Copy the contents of one Matrix into another.
template<class T >
T	sgn (const T &x)
	Determine the sign of a number.
template<matrix_order o1, matrix_order o2, matrix_order o3>
bool	maj_col ()
template<matrix_order o1, matrix_order o2, matrix_order o3, matrix_order o4>
bool	maj_col ()
double	gammafn (double x)
	The gamma function.
double	lngammafn (double x)
	The natural log of the absolute value of the gamma function.
double	betafn (double a, double b)
	The beta function.
double	lnbetafn (double a, double b)
	The natural log of the beta function.
int	factorial (unsigned int n)
	The factorial function.
double	lnfactorial (unsigned int n)
	The log of the factorial function.
double	pbeta (double x, double a, double b)
	The beta distribution function.
template<matrix_order RO, matrix_style RS, matrix_order PO, matrix_style PS>
Matrix< double, RO, RS >	pbeta (const Matrix< double, PO, PS > &X, double a, double b)
template<matrix_order O, matrix_style S>
Matrix< double, O, Concrete >	pbeta (const Matrix< double, O, S > &X, double a, double b)
double	dbeta (double x, double a, double b)
	The beta density function.
template<matrix_order RO, matrix_style RS, matrix_order PO, matrix_style PS>
Matrix< double, RO, RS >	dbeta (const Matrix< double, PO, PS > &X, double a, double b)
template<matrix_order O, matrix_style S>
Matrix< double, O, Concrete >	dbeta (const Matrix< double, O, S > &X, double a, double b)
double	lndbeta1 (double x, double a, double b)
	The natural log of the ordinate of the beta density function.
template<matrix_order RO, matrix_style RS, matrix_order PO, matrix_style PS>
Matrix< double, RO, RS >	lndbeta1 (const Matrix< double, PO, PS > &X, double a, double b)
template<matrix_order O, matrix_style S>
Matrix< double, O, Concrete >	lndbeta1 (const Matrix< double, O, S > &X, double a, double b)
double	pbinom (double x, unsigned int n, double p)
	The binomial distribution function.
template<matrix_order RO, matrix_style RS, matrix_order PO, matrix_style PS>
Matrix< double, RO, RS >	pbinom (const Matrix< double, PO, PS > &X, unsigned int n, double p)
template<matrix_order O, matrix_style S>
Matrix< double, O, Concrete >	pbinom (const Matrix< double, O, S > &X, unsigned int n, double p)
double	dbinom (double x, unsigned int n, double p)
	The binomial density function.
template<matrix_order RO, matrix_style RS, matrix_order PO, matrix_style PS>
Matrix< double, RO, RS >	dbinom (const Matrix< double, PO, PS > &X, unsigned int n, double p)
template<matrix_order O, matrix_style S>
Matrix< double, O, Concrete >	dbinom (const Matrix< double, O, S > &X, unsigned int n, double p)
double	pchisq (double x, double df)
	The $\chi^2$ distribution function.
template<matrix_order RO, matrix_style RS, matrix_order PO, matrix_style PS>
Matrix< double, RO, RS >	pchisq (const Matrix< double, PO, PS > &X, double df)
template<matrix_order O, matrix_style S>
Matrix< double, O, Concrete >	pchisq (const Matrix< double, O, S > &X, double df)
double	dchisq (double x, double df)
	The $\chi^2$ density function.
template<matrix_order RO, matrix_style RS, matrix_order PO, matrix_style PS>
Matrix< double, RO, RS >	dchisq (const Matrix< double, PO, PS > &X, double df)
template<matrix_order O, matrix_style S>
Matrix< double, O, Concrete >	dchisq (const Matrix< double, O, S > &X, double df)
double	pexp (double x, double scale)
	The exponential distribution function.
template<matrix_order RO, matrix_style RS, matrix_order PO, matrix_style PS>
Matrix< double, RO, RS >	pexp (const Matrix< double, PO, PS > &X, double scale)
template<matrix_order O, matrix_style S>
Matrix< double, O, Concrete >	pexp (const Matrix< double, O, S > &X, double scale)
double	dexp (double x, double scale)
	The exponential density function.
template<matrix_order RO, matrix_style RS, matrix_order PO, matrix_style PS>
Matrix< double, RO, RS >	dexp (const Matrix< double, PO, PS > &X, double scale)
template<matrix_order O, matrix_style S>
Matrix< double, O, Concrete >	dexp (const Matrix< double, O, S > &X, double scale)
double	pf (double x, double df1, double df2)
	The F distribution function.
template<matrix_order RO, matrix_style RS, matrix_order PO, matrix_style PS>
Matrix< double, RO, RS >	pf (const Matrix< double, PO, PS > &X, double df1, double df2)
template<matrix_order O, matrix_style S>
Matrix< double, O, Concrete >	pf (const Matrix< double, O, S > &X, double df1, double df2)
double	df (double x, double df1, double df2)
	The F density function.
template<matrix_order RO, matrix_style RS, matrix_order PO, matrix_style PS>
Matrix< double, RO, RS >	df (const Matrix< double, PO, PS > &X, double df1, double df2)
template<matrix_order O, matrix_style S>
Matrix< double, O, Concrete >	df (const Matrix< double, O, S > &X, double df1, double df2)
double	pgamma (double x, double shape, double scale)
	The gamma distribution function.
template<matrix_order RO, matrix_style RS, matrix_order PO, matrix_style PS>
Matrix< double, RO, RS >	pgamma (const Matrix< double, PO, PS > &X, double shape, double scale)
template<matrix_order O, matrix_style S>
Matrix< double, O, Concrete >	pgamma (const Matrix< double, O, S > &X, double shape, double scale)
double	dgamma (double x, double shape, double scale)
	The gamma density function.
template<matrix_order RO, matrix_style RS, matrix_order PO, matrix_style PS>
Matrix< double, RO, RS >	dgamma (const Matrix< double, PO, PS > &X, double shape, double scale)
template<matrix_order O, matrix_style S>
Matrix< double, O, Concrete >	dgamma (const Matrix< double, O, S > &X, double shape, double scale)
double	plogis (double x, double location, double scale)
	The logistic distribution function.
template<matrix_order RO, matrix_style RS, matrix_order PO, matrix_style PS>
Matrix< double, RO, RS >	plogis (const Matrix< double, PO, PS > &X, double location, double scale)
template<matrix_order O, matrix_style S>
Matrix< double, O, Concrete >	plogis (const Matrix< double, O, S > &X, double location, double scale)
double	dlogis (double x, double location, double scale)
	The logistic density function.
template<matrix_order RO, matrix_style RS, matrix_order PO, matrix_style PS>
Matrix< double, RO, RS >	dlogis (const Matrix< double, PO, PS > &X, double location, double scale)
template<matrix_order O, matrix_style S>
Matrix< double, O, Concrete >	dlogis (const Matrix< double, O, S > &X, double location, double scale)
double	plnorm (double x, double logmean, double logsd)
	The log-normal distribution function.
template<matrix_order RO, matrix_style RS, matrix_order PO, matrix_style PS>
Matrix< double, RO, RS >	plnorm (const Matrix< double, PO, PS > &X, double logmean, double logsd)
template<matrix_order O, matrix_style S>
Matrix< double, O, Concrete >	plnorm (const Matrix< double, O, S > &X, double logmean, double logsd)
double	dlnorm (double x, double logmean, double logsd)
	The log-normal density function.
template<matrix_order RO, matrix_style RS, matrix_order PO, matrix_style PS>
Matrix< double, RO, RS >	dlnorm (const Matrix< double, PO, PS > &X, double logmean, double logsd)
template<matrix_order O, matrix_style S>
Matrix< double, O, Concrete >	dlnorm (const Matrix< double, O, S > &X, double logmean, double logsd)
double	pnbinom (unsigned int x, double n, double p)
	The negative binomial distribution function.
template<matrix_order RO, matrix_style RS, matrix_order PO, matrix_style PS>
Matrix< double, RO, RS >	pnbinom (const Matrix< unsigned int, PO, PS > &X, double n, double p)
template<matrix_order O, matrix_style S>
Matrix< double, O, Concrete >	pnbinom (const Matrix< unsigned int, O, S > &X, double n, double p)
double	dnbinom (unsigned int x, double n, double p)
	The negative binomial density function.
template<matrix_order RO, matrix_style RS, matrix_order PO, matrix_style PS>
Matrix< double, RO, RS >	dnbinom (const Matrix< unsigned int, PO, PS > &X, double n, double p)
template<matrix_order O, matrix_style S>
Matrix< double, O, Concrete >	dnbinom (const Matrix< unsigned int, O, S > &X, double n, double p)
double	pnorm (double x, double mean, double sd)
	The normal distribution function.
template<matrix_order RO, matrix_style RS, matrix_order PO, matrix_style PS>
Matrix< double, RO, RS >	pnorm (const Matrix< double, PO, PS > &X, double mean, double sd)
template<matrix_order O, matrix_style S>
Matrix< double, O, Concrete >	pnorm (const Matrix< double, O, S > &X, double mean, double sd)
double	dnorm (double x, double mean, double sd)
	The normal density function.
template<matrix_order RO, matrix_style RS, matrix_order PO, matrix_style PS>
Matrix< double, RO, RS >	dnorm (const Matrix< double, PO, PS > &X, double mean, double sd)
template<matrix_order O, matrix_style S>
Matrix< double, O, Concrete >	dnorm (const Matrix< double, O, S > &X, double mean, double sd)
double	lndnorm (double x, double mean, double sd)
	The natural log of normal density function.
template<matrix_order RO, matrix_style RS, matrix_order PO, matrix_style PS>
Matrix< double, RO, RS >	lndnorm (const Matrix< double, PO, PS > &X, double mean, double sd)
template<matrix_order O, matrix_style S>
Matrix< double, O, Concrete >	lndnorm (const Matrix< double, O, S > &X, double mean, double sd)
double	qnorm1 (double in_p)
	The standard normal quantile function.
template<matrix_order RO, matrix_style RS, matrix_order PO, matrix_style PS>
Matrix< double, RO, RS >	qnorm1 (const Matrix< double, PO, PS > &X, double in_p)
template<matrix_order O, matrix_style S>
Matrix< double, O, Concrete >	qnorm1 (const Matrix< double, O, S > &X, double in_p)
double	ppois (unsigned int x, double lambda)
	The Poisson distribution function.
template<matrix_order RO, matrix_style RS, matrix_order PO, matrix_style PS>
Matrix< double, RO, RS >	ppois (const Matrix< unsigned int, PO, PS > &X, double lambda)
template<matrix_order O, matrix_style S>
Matrix< double, O, Concrete >	ppois (const Matrix< unsigned int, O, S > &X, double lambda)
double	dpois (unsigned int x, double lambda)
	The Poisson density function.
template<matrix_order RO, matrix_style RS, matrix_order PO, matrix_style PS>
Matrix< double, RO, RS >	dpois (const Matrix< unsigned int, PO, PS > &X, double lambda)
template<matrix_order O, matrix_style S>
Matrix< double, O, Concrete >	dpois (const Matrix< unsigned int, O, S > &X, double lambda)
double	pt (double x, double n)
	The Student t distribution function.
template<matrix_order RO, matrix_style RS, matrix_order PO, matrix_style PS>
Matrix< double, RO, RS >	pt (const Matrix< double, PO, PS > &X, double n)
template<matrix_order O, matrix_style S>
Matrix< double, O, Concrete >	pt (const Matrix< double, O, S > &X, double n)
double	dt (double x, double n)
	The Student t distribution function.
template<matrix_order RO, matrix_style RS, matrix_order PO, matrix_style PS>
Matrix< double, RO, RS >	dt (const Matrix< double, PO, PS > &X, double n)
template<matrix_order O, matrix_style S>
Matrix< double, O, Concrete >	dt (const Matrix< double, O, S > &X, double n)
double	dt1 (double x, double mu, double sigma2, double nu)
	The univariate Student t density function.
template<matrix_order RO, matrix_style RS, matrix_order PO, matrix_style PS>
Matrix< double, RO, RS >	dt1 (const Matrix< double, PO, PS > &X, double mu, double sigma2, double nu)
template<matrix_order O, matrix_style S>
Matrix< double, O, Concrete >	dt1 (const Matrix< double, O, S > &X, double mu, double sigma2, double nu)
double	lndt1 (double x, double mu, double sigma2, double nu)
	The natural log of the univariate Student t density function.
template<matrix_order RO, matrix_style RS, matrix_order PO, matrix_style PS>
Matrix< double, RO, RS >	lndt1 (const Matrix< double, PO, PS > &X, double mu, double sigma2, double nu)
template<matrix_order O, matrix_style S>
Matrix< double, O, Concrete >	lndt1 (const Matrix< double, O, S > &X, double mu, double sigma2, double nu)
double	punif (double x, double a, double b)
	The uniform distribution function.
template<matrix_order RO, matrix_style RS, matrix_order PO, matrix_style PS>
Matrix< double, RO, RS >	punif (const Matrix< double, PO, PS > &X, double a, double b)
template<matrix_order O, matrix_style S>
Matrix< double, O, Concrete >	punif (const Matrix< double, O, S > &X, double a, double b)
double	dunif (double x, double a, double b)
	The uniform density function.
template<matrix_order RO, matrix_style RS, matrix_order PO, matrix_style PS>
Matrix< double, RO, RS >	dunif (const Matrix< double, PO, PS > &X, double a, double b)
template<matrix_order O, matrix_style S>
Matrix< double, O, Concrete >	dunif (const Matrix< double, O, S > &X, double a, double b)
double	pweibull (double x, double shape, double scale)
	The Weibull distribution function.
template<matrix_order RO, matrix_style RS, matrix_order PO, matrix_style PS>
Matrix< double, RO, RS >	pweibull (const Matrix< double, PO, PS > &X, double shape, double scale)
template<matrix_order O, matrix_style S>
Matrix< double, O, Concrete >	pweibull (const Matrix< double, O, S > &X, double shape, double scale)
double	dweibull (double x, double shape, double scale)
	The Weibull density function.
template<matrix_order RO, matrix_style RS, matrix_order PO, matrix_style PS>
Matrix< double, RO, RS >	dweibull (const Matrix< double, PO, PS > &X, double shape, double scale)
template<matrix_order O, matrix_style S>
Matrix< double, O, Concrete >	dweibull (const Matrix< double, O, S > &X, double shape, double scale)
template<matrix_order O1, matrix_style 0. 00277777777777777777778, matrix_order O2, matrix_style 0. 00079365079365079365079365, matrix_order O3, matrix_style 0. 000595238095238095238095238>
double	lndmvn (const Matrix< double, O1, 0.00277777777777777777778 > &x, const Matrix< double, O2, 0.00079365079365079365079365 > &mu, const Matrix< double, O3, 0.000595238095238095238095238 > &Sigma)
	The natural log of the multivariate normal density function.
void	scythe_terminate ()
template<matrix_order RO, matrix_style RS, typename T , matrix_order PO, matrix_style PS>
Matrix< T, RO, RS >	cholesky (const Matrix< T, PO, PS > &A)
	Cholesky decomposition of a symmetric positive-definite matrix.
template<typename T , matrix_order O, matrix_style S>
Matrix< T, O, Concrete >	cholesky (const Matrix< T, O, S > &A)
template<matrix_order RO, matrix_style RS, typename T , matrix_order PO1, matrix_style PS1, matrix_order PO2, matrix_style PS2, matrix_order PO3, matrix_style PS3>
Matrix< T, RO, RS >	chol_solve (const Matrix< T, PO1, PS1 > &A, const Matrix< T, PO2, PS2 > &b, const Matrix< T, PO3, PS3 > &M)
	Solve for x via backward substitution, given a lower triangular matrix resulting from Cholesky decomposition.
template<typename T , matrix_order PO1, matrix_style PS1, matrix_order PO2, matrix_style PS2, matrix_order PO3, matrix_style PS3>
Matrix< T, PO1, Concrete >	chol_solve (const Matrix< T, PO1, PS1 > &A, const Matrix< T, PO2, PS2 > &b, const Matrix< T, PO3, PS3 > &M)
template<matrix_order RO, matrix_style RS, typename T , matrix_order PO1, matrix_style PS1, matrix_order PO2, matrix_style PS2>
Matrix< T, RO, RS >	chol_solve (const Matrix< T, PO1, PS1 > &A, const Matrix< T, PO2, PS2 > &b)
	Solve for x via backward substitution, using Cholesky decomposition.
template<typename T , matrix_order PO1, matrix_style PS1, matrix_order PO2, matrix_style PS2>
Matrix< T, PO1, Concrete >	chol_solve (const Matrix< T, PO1, PS1 > &A, const Matrix< T, PO2, PS2 > &b)
template<matrix_order RO, matrix_style RS, typename T , matrix_order PO1, matrix_style PS1, matrix_order PO2, matrix_style PS2>
Matrix< T, RO, RS >	invpd (const Matrix< T, PO1, PS1 > &A, const Matrix< T, PO2, PS2 > &M)
	Calculates the inverse of a symmetric positive definite matrix, given a lower triangular matrix resulting from Cholesky decomposition.
template<typename T , matrix_order PO1, matrix_style PS1, matrix_order PO2, matrix_style PS2>
Matrix< T, PO1, Concrete >	invpd (const Matrix< T, PO1, PS1 > &A, const Matrix< T, PO2, PS2 > &M)
template<matrix_order RO, matrix_style RS, typename T , matrix_order PO, matrix_style PS>
Matrix< T, RO, RS >	invpd (const Matrix< T, PO, PS > &A)
	Calculate the inverse of a symmetric positive definite matrix.
template<typename T , matrix_order O, matrix_style S>
Matrix< T, O, Concrete >	invpd (const Matrix< T, O, S > &A)
template<matrix_order PO1, matrix_style PS1, typename T , matrix_order PO2, matrix_order PO3, matrix_order PO4>
void	lu_decomp (Matrix< T, PO1, PS1 > A, Matrix< T, PO2, Concrete > &L, Matrix< T, PO3, Concrete > &U, Matrix< unsigned int, PO4, Concrete > &perm_vec)
	LU decomposition of a square matrix.
template<matrix_order RO, matrix_style RS, typename T , matrix_order PO1, matrix_style PS1, matrix_order PO2, matrix_style PS2, matrix_order PO3, matrix_style PS3, matrix_order PO4, matrix_style PS4, matrix_order PO5, matrix_style PS5>
Matrix< T, RO, RS >	lu_solve (const Matrix< T, PO1, PS1 > &A, const Matrix< T, PO2, PS2 > &b, const Matrix< T, PO3, PS3 > &L, const Matrix< T, PO4, PS4 > &U, const Matrix< unsigned int, PO5, PS5 > &perm_vec)
	Solve for x via forward and backward substitution, given the results of a LU decomposition.
template<typename T , matrix_order PO1, matrix_style PS1, matrix_order PO2, matrix_style PS2, matrix_order PO3, matrix_style PS3, matrix_order PO4, matrix_style PS4, matrix_order PO5, matrix_style PS5>
Matrix< T, PO1, Concrete >	lu_solve (const Matrix< T, PO1, PS1 > &A, const Matrix< T, PO2, PS2 > &b, const Matrix< T, PO3, PS3 > &L, const Matrix< T, PO4, PS4 > &U, const Matrix< unsigned int, PO5, PS5 > &perm_vec)
template<matrix_order RO, matrix_style RS, typename T , matrix_order PO1, matrix_style PS1, matrix_order PO2, matrix_style PS2>
Matrix< T, RO, RS >	lu_solve (Matrix< T, PO1, PS1 > A, const Matrix< T, PO2, PS2 > &b)
	Solve for x via forward and backward substitution, using LU decomposition.
template<typename T , matrix_order PO1, matrix_style PS1, matrix_order PO2, matrix_style PS2>
Matrix< T, PO1, Concrete >	lu_solve (Matrix< T, PO1, PS1 > A, const Matrix< T, PO2, PS2 > &b)
template<matrix_order RO, matrix_style RS, typename T , matrix_order PO1, matrix_style PS1, matrix_order PO2, matrix_style PS2, matrix_order PO3, matrix_style PS3, matrix_order PO4, matrix_style PS4>
Matrix< T, RO, RS >	inv (const Matrix< T, PO1, PS1 > &A, const Matrix< T, PO2, PS2 > &L, const Matrix< T, PO3, PS3 > &U, const Matrix< unsigned int, PO4, PS4 > &perm_vec)
	Calculates the inverse of a non-singular square matrix, given an LU decomposition.
template<typename T , matrix_order PO1, matrix_style PS1, matrix_order PO2, matrix_style PS2, matrix_order PO3, matrix_style PS3, matrix_order PO4, matrix_style PS4>
Matrix< T, PO1, Concrete >	inv (const Matrix< T, PO1, PS1 > &A, const Matrix< T, PO2, PS2 > &L, const Matrix< T, PO3, PS3 > &U, const Matrix< unsigned int, PO4, PS4 > &perm_vec)
template<matrix_order RO, matrix_style RS, typename T , matrix_order PO, matrix_style PS>
Matrix< T, RO, RS >	inv (const Matrix< T, PO, PS > &A)
	Invert an arbitrary, non-singular, square matrix.
template<typename T , matrix_order O, matrix_style S>
Matrix< T, O, Concrete >	inv (const Matrix< T, O, S > &A)
template<matrix_order RO, matrix_style RS, typename T , matrix_order PO1, matrix_style PS1, matrix_order PO2, matrix_style PS2>
Matrix< T, RO, RS >	row_interchange (Matrix< T, PO1, PS1 > A, const Matrix< unsigned int, PO2, PS2 > &p)
	Interchange the rows of a Matrix according to a permutation vector.
template<typename T , matrix_order PO1, matrix_style PS1, matrix_order PO2, matrix_style PS2>
Matrix< T, PO1, Concrete >	row_interchange (const Matrix< T, PO1, PS1 > &A, const Matrix< unsigned int, PO2, PS2 > &p)
template<typename T , matrix_order PO, matrix_style PS>
T	det (const Matrix< T, PO, PS > &A)
	Calculate the determinant of a square Matrix.
template<>
Matrix	cholesky (const Matrix<> &A)
template<>
Matrix	chol_solve (const Matrix<> &A, const Matrix<> &b, const Matrix<> &M)
template<>
Matrix	chol_solve (const Matrix<> &A, const Matrix<> &b)
template<matrix_order PO2, matrix_order PO3, matrix_order PO4>
double	lu_decomp_alg (Matrix<> &A, Matrix< double, PO2, Concrete > &L, Matrix< double, PO3, Concrete > &U, Matrix< unsigned int, PO4, Concrete > &perm_vec)
QRdecomp	qr_decomp (const Matrix<> &A)
	QR decomposition of a matrix.
Matrix	qr_solve (const Matrix<> &A, const Matrix<> &b, const QRdecomp &QR)
	Solve given a QR decomposition.
Matrix	qr_solve (const Matrix<> &A, const Matrix<> &b)
	Solve using QR decomposition.
template<>
Matrix	invpd (const Matrix<> &A)
template<>
Matrix	invpd (const Matrix<> &A, const Matrix<> &M)
template<>
Matrix	inv (const Matrix<> &A)
SVD	svd (const Matrix<> &A, int nu=-1, int nv=-1)
	Calculates the singular value decomposition of a matrix, optionally computing the left and right singular vectors.
Eigen	eigen (const Matrix<> &A, bool vectors=true)
	Calculates the eigenvalues and eigenvectors of a symmetric matrix.
GeneralEigen	geneigen (const Matrix<> &A, bool vectors=true)
template<matrix_order RO, matrix_style RS, typename T , matrix_order PO, matrix_style PS>
Matrix< T, RO, RS >	t (const Matrix< T, PO, PS > &M)
	Transpose a Matrix.
template<typename T , matrix_order O, matrix_style S>
Matrix< T, O, Concrete >	t (const Matrix< T, O, S > &M)
template<typename T , matrix_order O, matrix_style S>
Matrix< T, O, S >	ones (unsigned int rows, unsigned int cols)
	Create a matrix of ones.
template<typename T , matrix_order O>
Matrix< T, O, Concrete >	ones (unsigned int rows, unsigned int cols)
template<typename T >
Matrix< T, Col, Concrete >	ones (unsigned int rows, unsigned int cols)
template<typename T , matrix_order O, matrix_style S>
Matrix< T, O, S >	eye (unsigned int k)
	Create a k by k identity Matrix.
template<typename T , matrix_order O>
Matrix< T, O, Concrete >	eye (uint k)
template<typename T >
Matrix< T, Col, Concrete >	eye (uint k)
template<typename T , matrix_order O, matrix_style S>
Matrix< T, O, S >	seqa (T start, T incr, uint rows)
	Create a rows x 1 vector-additive sequence Matrix.
template<typename T , matrix_order O>
Matrix< T, O, Concrete >	seqa (T start, T incr, uint rows)
template<typename T >
Matrix< T, Col, Concrete >	seqa (T start, T incr, uint rows)
Matrix< double, Col, Concrete >	seqa (double start, double incr, uint rows)
template<matrix_order SORT_ORDER, matrix_order RO, matrix_style RS, typename T , matrix_order PO, matrix_style PS>
Matrix< T, RO, RS >	sort (const Matrix< T, PO, PS > &M)
	Sort a Matrix.
template<matrix_order SORT_ORDER, typename T , matrix_order O, matrix_style S>
Matrix< T, O, Concrete >	sort (const Matrix< T, O, S > &M)
template<typename T , matrix_order O, matrix_style S>
Matrix< T, O, Concrete >	sort (const Matrix< T, O, S > &M)
template<matrix_order RO, matrix_style RS, typename T , matrix_order PO, matrix_style PS>
Matrix< T, RO, RS >	sortc (const Matrix< T, PO, PS > &M)
	Sort the columns of a Matrix.
template<typename T , matrix_order O, matrix_style S>
Matrix< T, O, Concrete >	sortc (const Matrix< T, O, S > &M)
template<matrix_order RO, matrix_style RS, typename T , matrix_order PO1, matrix_style PS1, matrix_order PO2, matrix_style PS2>
Matrix< T, RO, RS >	cbind (const Matrix< T, PO1, PS1 > &A, const Matrix< T, PO2, PS2 > &B)
	Column bind two matrices.
template<typename T , matrix_order PO1, matrix_style PS1, matrix_order PO2, matrix_style PS2>
Matrix< T, PO1, Concrete >	cbind (const Matrix< T, PO1, PS1 > &A, const Matrix< T, PO2, PS2 > &B)
template<matrix_order RO, matrix_style RS, typename T , matrix_order PO1, matrix_style PS1, matrix_order PO2, matrix_style PS2>
Matrix< T, RO, RS >	rbind (const Matrix< T, PO1, PS1 > &A, const Matrix< T, PO2, PS2 > &B)
	Row bind two matrices.
template<typename T , matrix_order PO1, matrix_style PS1, matrix_order PO2, matrix_style PS2>
Matrix< T, PO1, Concrete >	rbind (const Matrix< T, PO1, PS1 > &A, const Matrix< T, PO2, PS2 > &B)
template<matrix_order RO, matrix_style RS, typename T , matrix_order PO, matrix_style PS>
Matrix< unsigned int, RO, RS >	order (const Matrix< T, PO, PS > &M)
	Calculate the rank-order of each element in a Matrix.
template<typename T , matrix_order O, matrix_style S>
Matrix< unsigned int, O, Concrete >	order (const Matrix< T, O, S > &M)
template<matrix_order RO, matrix_style RS, typename T , matrix_order PO1, matrix_style PS1, matrix_order PO2, matrix_style PS2>
Matrix< T, RO, RS >	selif (const Matrix< T, PO1, PS1 > &M, const Matrix< bool, PO2, PS2 > &e)
	Locate rows for which a binary column vector equals 1.
template<typename T , matrix_order PO1, matrix_style PS1, matrix_order PO2, matrix_style PS2>
Matrix< T, PO1, Concrete >	selif (const Matrix< T, PO1, PS1 > &M, const Matrix< bool, PO2, PS2 > &e)
template<matrix_order RO, matrix_style RS, typename T , matrix_order PO, matrix_style PS>
Matrix< T, RO, RS >	unique (const Matrix< T, PO, PS > &M)
	Find unique elements in a Matrix.
template<typename T , matrix_order O, matrix_style S>
Matrix< T, O, Concrete >	unique (const Matrix< T, O, S > &M)
template<matrix_order RO, matrix_style RS, typename T , matrix_order PO, matrix_style PS>
Matrix< T, RO, RS >	vech (const Matrix< T, PO, PS > &M)
	Vectorize a symmetric Matrix.
template<typename T , matrix_order O, matrix_style S>
Matrix< T, O, Concrete >	vech (const Matrix< T, O, S > &M)
template<matrix_order RO, matrix_style RS, typename T , matrix_order PO, matrix_style PS>
Matrix< T, RO, RS >	xpnd (const Matrix< T, PO, PS > &v)
template<typename T , matrix_order O, matrix_style S>
Matrix< T, O, Concrete >	xpnd (const Matrix< T, O, S > &v)
template<matrix_order RO, matrix_style RS, typename T , matrix_order PO, matrix_style PS>
Matrix< T, RO, RS >	diag (const Matrix< T, PO, PS > &M)
	Return the diagonal of a Matrix.
template<typename T , matrix_order O, matrix_style S>
Matrix< T, O, Concrete >	diag (const Matrix< T, O, S > &M)
template<matrix_order RO, matrix_style RS, typename T , matrix_order PO1, matrix_style PS1, matrix_order PO2, matrix_style PS2, matrix_order PO3, matrix_style PS3>
Matrix< T, RO, RS >	gaxpy (const Matrix< T, PO1, PS1 > &A, const Matrix< T, PO2, PS2 > &B, const Matrix< T, PO3, PS3 > &C)
template<typename T , matrix_order PO1, matrix_style PS1, matrix_order PO2, matrix_style PS2, matrix_order PO3, matrix_style PS3>
Matrix< T, PO1, Concrete >	gaxpy (const Matrix< T, PO1, PS1 > &A, const Matrix< T, PO2, PS2 > &B, const Matrix< T, PO3, PS3 > &C)
template<matrix_order RO, matrix_style RS, typename T , matrix_order PO, matrix_style PS>
Matrix< T, RO, RS >	crossprod (const Matrix< T, PO, PS > &A)
template<typename T , matrix_order O, matrix_style S>
Matrix< T, O, Concrete >	crossprod (const Matrix< T, O, S > &M)
template<>
Matrix	gaxpy< Col, Concrete, double, Col, Concrete, Col, Concrete, Col, Concrete > (const Matrix<> &A, const Matrix<> &B, const Matrix<> &C)
template<>
Matrix	crossprod (const Matrix<> &A)
template<typename T_type , matrix_order ORDER, matrix_style STYLE, matrix_order L_ORDER, matrix_style L_STYLE, matrix_order R_ORDER, matrix_style R_STYLE>
Matrix< T_type, ORDER, STYLE >	operator* (const Matrix< T_type, L_ORDER, L_STYLE > &lhs, const Matrix< T_type, R_ORDER, R_STYLE > &rhs)
	Multiply two matrices.
template<matrix_order L_ORDER, matrix_style L_STYLE, matrix_order R_ORDER, matrix_style R_STYLE, typename T_type >
Matrix< T_type, L_ORDER, Concrete >	operator* (const Matrix< T_type, L_ORDER, L_STYLE > &lhs, const Matrix< T_type, R_ORDER, R_STYLE > &rhs)
	Multiply two matrices.
template<matrix_order ORDER, matrix_style L_STYLE, matrix_order R_ORDER, matrix_style R_STYLE, typename T_type >
Matrix< T_type, ORDER, Concrete >	operator* (const Matrix< T_type, ORDER, L_STYLE > &lhs, const Matrix< T_type, R_ORDER, R_STYLE > &rhs)
template<typename T_type , matrix_order ORDER, matrix_style STYLE, matrix_order L_ORDER, matrix_style L_STYLE>
Matrix< T_type, ORDER, STYLE >	operator* (const Matrix< T_type, L_ORDER, L_STYLE > &lhs, const typename Matrix< T_type >::ttype &rhs)
template<matrix_order ORDER, matrix_style L_STYLE, typename T_type >
Matrix< T_type, ORDER, Concrete >	operator* (const Matrix< T_type, ORDER, L_STYLE > &lhs, const typename Matrix< T_type >::ttype &rhs)
template<typename T_type , matrix_order ORDER, matrix_style STYLE, matrix_order R_ORDER, matrix_style R_STYLE>
Matrix< T_type, ORDER, STYLE >	operator* (const typename Matrix< T_type >::ttype &lhs, const Matrix< T_type, R_ORDER, R_STYLE > &rhs)
template<matrix_order ORDER, matrix_style R_STYLE, typename T_type >
Matrix< T_type, ORDER, Concrete >	operator* (const typename Matrix< T_type >::ttype &lhs, const Matrix< T_type, ORDER, R_STYLE > &rhs)
template<typename T_type , matrix_order ORDER, matrix_style STYLE, matrix_order L_ORDER, matrix_style L_STYLE, matrix_order R_ORDER, matrix_style R_STYLE>
Matrix< T_type, ORDER, STYLE >	kronecker (const Matrix< T_type, L_ORDER, L_STYLE > &lhs, const Matrix< T_type, R_ORDER, R_STYLE > &rhs)
	Kronecker multiply two matrices.
template<matrix_order ORDER, matrix_style L_STYLE, matrix_order R_ORDER, matrix_style R_STYLE, typename T_type >
Matrix< T_type, ORDER, Concrete >	kronecker (const Matrix< T_type, ORDER, L_STYLE > &lhs, const Matrix< T_type, R_ORDER, R_STYLE > &rhs)
template<typename T_type , matrix_order ORDER, matrix_style STYLE, matrix_order L_ORDER, matrix_style L_STYLE>
Matrix< T_type, ORDER, STYLE >	kronecker (const Matrix< T_type, L_ORDER, L_STYLE > &lhs, const typename Matrix< T_type >::ttype &rhs)
template<matrix_order ORDER, matrix_style L_STYLE, typename T_type >
Matrix< T_type, ORDER, Concrete >	kronecker (const Matrix< T_type, ORDER, L_STYLE > &lhs, const typename Matrix< T_type >::ttype &rhs)
template<typename T_type , matrix_order ORDER, matrix_style STYLE, matrix_order R_ORDER, matrix_style R_STYLE>
Matrix< T_type, ORDER, STYLE >	kronecker (const typename Matrix< T_type >::ttype &lhs, const Matrix< T_type, R_ORDER, R_STYLE > &rhs)
template<matrix_order ORDER, matrix_style R_STYLE, typename T_type >
Matrix< T_type, ORDER, Concrete >	kronecker (const typename Matrix< T_type >::ttype &lhs, const Matrix< T_type, ORDER, R_STYLE > &rhs)
template<typename T_type , matrix_order ORDER, matrix_style STYLE, matrix_order L_ORDER, matrix_style L_STYLE, matrix_order R_ORDER, matrix_style R_STYLE>
Matrix< T_type, ORDER, STYLE >	operator+ (const Matrix< T_type, L_ORDER, L_STYLE > &lhs, const Matrix< T_type, R_ORDER, R_STYLE > &rhs)
	Add two matrices.
template<matrix_order ORDER, matrix_style L_STYLE, matrix_order R_ORDER, matrix_style R_STYLE, typename T_type >
Matrix< T_type, ORDER, Concrete >	operator+ (const Matrix< T_type, ORDER, L_STYLE > &lhs, const Matrix< T_type, R_ORDER, R_STYLE > &rhs)
template<typename T_type , matrix_order ORDER, matrix_style STYLE, matrix_order L_ORDER, matrix_style L_STYLE>
Matrix< T_type, ORDER, STYLE >	operator+ (const Matrix< T_type, L_ORDER, L_STYLE > &lhs, const typename Matrix< T_type >::ttype &rhs)
template<matrix_order ORDER, matrix_style L_STYLE, typename T_type >
Matrix< T_type, ORDER, Concrete >	operator+ (const Matrix< T_type, ORDER, L_STYLE > &lhs, const typename Matrix< T_type >::ttype &rhs)
template<typename T_type , matrix_order ORDER, matrix_style STYLE, matrix_order R_ORDER, matrix_style R_STYLE>
Matrix< T_type, ORDER, STYLE >	operator+ (const typename Matrix< T_type >::ttype &lhs, const Matrix< T_type, R_ORDER, R_STYLE > &rhs)
template<matrix_order ORDER, matrix_style R_STYLE, typename T_type >
Matrix< T_type, ORDER, Concrete >	operator+ (const typename Matrix< T_type >::ttype &lhs, const Matrix< T_type, ORDER, R_STYLE > &rhs)
template<typename T_type , matrix_order ORDER, matrix_style STYLE, matrix_order L_ORDER, matrix_style L_STYLE, matrix_order R_ORDER, matrix_style R_STYLE>
Matrix< T_type, ORDER, STYLE >	operator- (const Matrix< T_type, L_ORDER, L_STYLE > &lhs, const Matrix< T_type, R_ORDER, R_STYLE > &rhs)
	Subtract two matrices.
template<matrix_order ORDER, matrix_style L_STYLE, matrix_order R_ORDER, matrix_style R_STYLE, typename T_type >
Matrix< T_type, ORDER, Concrete >	operator- (const Matrix< T_type, ORDER, L_STYLE > &lhs, const Matrix< T_type, R_ORDER, R_STYLE > &rhs)
template<typename T_type , matrix_order ORDER, matrix_style STYLE, matrix_order L_ORDER, matrix_style L_STYLE>
Matrix< T_type, ORDER, STYLE >	operator- (const Matrix< T_type, L_ORDER, L_STYLE > &lhs, const typename Matrix< T_type >::ttype &rhs)
template<matrix_order ORDER, matrix_style L_STYLE, typename T_type >
Matrix< T_type, ORDER, Concrete >	operator- (const Matrix< T_type, ORDER, L_STYLE > &lhs, const typename Matrix< T_type >::ttype &rhs)
template<typename T_type , matrix_order ORDER, matrix_style STYLE, matrix_order R_ORDER, matrix_style R_STYLE>
Matrix< T_type, ORDER, STYLE >	operator- (const typename Matrix< T_type >::ttype &lhs, const Matrix< T_type, R_ORDER, R_STYLE > &rhs)
template<matrix_order ORDER, matrix_style R_STYLE, typename T_type >
Matrix< T_type, ORDER, Concrete >	operator- (const typename Matrix< T_type >::ttype &lhs, const Matrix< T_type, ORDER, R_STYLE > &rhs)
template<typename T_type , matrix_order ORDER, matrix_style STYLE, matrix_order L_ORDER, matrix_style L_STYLE, matrix_order R_ORDER, matrix_style R_STYLE>
Matrix< T_type, ORDER, STYLE >	operator% (const Matrix< T_type, L_ORDER, L_STYLE > &lhs, const Matrix< T_type, R_ORDER, R_STYLE > &rhs)
	Element multiply two matrices.
template<matrix_order ORDER, matrix_style L_STYLE, matrix_order R_ORDER, matrix_style R_STYLE, typename T_type >
Matrix< T_type, ORDER, Concrete >	operator% (const Matrix< T_type, ORDER, L_STYLE > &lhs, const Matrix< T_type, R_ORDER, R_STYLE > &rhs)
template<typename T_type , matrix_order ORDER, matrix_style STYLE, matrix_order L_ORDER, matrix_style L_STYLE>
Matrix< T_type, ORDER, STYLE >	operator% (const Matrix< T_type, L_ORDER, L_STYLE > &lhs, const typename Matrix< T_type >::ttype &rhs)
template<matrix_order ORDER, matrix_style L_STYLE, typename T_type >
Matrix< T_type, ORDER, Concrete >	operator% (const Matrix< T_type, ORDER, L_STYLE > &lhs, const typename Matrix< T_type >::ttype &rhs)
template<typename T_type , matrix_order ORDER, matrix_style STYLE, matrix_order R_ORDER, matrix_style R_STYLE>
Matrix< T_type, ORDER, STYLE >	operator% (const typename Matrix< T_type >::ttype &lhs, const Matrix< T_type, R_ORDER, R_STYLE > &rhs)
template<matrix_order ORDER, matrix_style R_STYLE, typename T_type >
Matrix< T_type, ORDER, Concrete >	operator% (const typename Matrix< T_type >::ttype &lhs, const Matrix< T_type, ORDER, R_STYLE > &rhs)
template<typename T_type , matrix_order ORDER, matrix_style STYLE, matrix_order L_ORDER, matrix_style L_STYLE, matrix_order R_ORDER, matrix_style R_STYLE>
Matrix< T_type, ORDER, STYLE >	operator/ (const Matrix< T_type, L_ORDER, L_STYLE > &lhs, const Matrix< T_type, R_ORDER, R_STYLE > &rhs)
	Divide two matrices.
template<matrix_order ORDER, matrix_style L_STYLE, matrix_order R_ORDER, matrix_style R_STYLE, typename T_type >
Matrix< T_type, ORDER, Concrete >	operator/ (const Matrix< T_type, ORDER, L_STYLE > &lhs, const Matrix< T_type, R_ORDER, R_STYLE > &rhs)
template<typename T_type , matrix_order ORDER, matrix_style STYLE, matrix_order L_ORDER, matrix_style L_STYLE>
Matrix< T_type, ORDER, STYLE >	operator/ (const Matrix< T_type, L_ORDER, L_STYLE > &lhs, const typename Matrix< T_type >::ttype &rhs)
template<matrix_order ORDER, matrix_style L_STYLE, typename T_type >
Matrix< T_type, ORDER, Concrete >	operator/ (const Matrix< T_type, ORDER, L_STYLE > &lhs, const typename Matrix< T_type >::ttype &rhs)
template<typename T_type , matrix_order ORDER, matrix_style STYLE, matrix_order R_ORDER, matrix_style R_STYLE>
Matrix< T_type, ORDER, STYLE >	operator/ (const typename Matrix< T_type >::ttype &lhs, const Matrix< T_type, R_ORDER, R_STYLE > &rhs)
template<matrix_order ORDER, matrix_style R_STYLE, typename T_type >
Matrix< T_type, ORDER, Concrete >	operator/ (const typename Matrix< T_type >::ttype &lhs, const Matrix< T_type, ORDER, R_STYLE > &rhs)
template<typename T_type , matrix_order ORDER, matrix_style STYLE, matrix_order L_ORDER, matrix_style L_STYLE, matrix_order R_ORDER, matrix_style R_STYLE>
Matrix< T_type, ORDER, STYLE >	operator^ (const Matrix< T_type, L_ORDER, L_STYLE > &lhs, const Matrix< T_type, R_ORDER, R_STYLE > &rhs)
	Exponentiate one Matrix by another.
template<matrix_order ORDER, matrix_style L_STYLE, matrix_order R_ORDER, matrix_style R_STYLE, typename T_type >
Matrix< T_type, ORDER, Concrete >	operator^ (const Matrix< T_type, ORDER, L_STYLE > &lhs, const Matrix< T_type, R_ORDER, R_STYLE > &rhs)
template<typename T_type , matrix_order ORDER, matrix_style STYLE, matrix_order L_ORDER, matrix_style L_STYLE>
Matrix< T_type, ORDER, STYLE >	operator^ (const Matrix< T_type, L_ORDER, L_STYLE > &lhs, const typename Matrix< T_type >::ttype &rhs)
template<matrix_order ORDER, matrix_style L_STYLE, typename T_type >
Matrix< T_type, ORDER, Concrete >	operator^ (const Matrix< T_type, ORDER, L_STYLE > &lhs, const typename Matrix< T_type >::ttype &rhs)
template<typename T_type , matrix_order ORDER, matrix_style STYLE, matrix_order R_ORDER, matrix_style R_STYLE>
Matrix< T_type, ORDER, STYLE >	operator^ (const typename Matrix< T_type >::ttype &lhs, const Matrix< T_type, R_ORDER, R_STYLE > &rhs)
template<matrix_order ORDER, matrix_style R_STYLE, typename T_type >
Matrix< T_type, ORDER, Concrete >	operator^ (const typename Matrix< T_type >::ttype &lhs, const Matrix< T_type, ORDER, R_STYLE > &rhs)
template<typename T_type , matrix_order R_ORDER, matrix_style R_STYLE, matrix_order ORDER, matrix_style STYLE>
Matrix< T_type, R_ORDER, R_STYLE >	operator- (const Matrix< T_type, ORDER, STYLE > &M)
	Negate a Matrix.
template<matrix_order ORDER, matrix_style P_STYLE, typename T_type >
Matrix< T_type, ORDER, Concrete >	operator- (const Matrix< T_type, ORDER, P_STYLE > &M)
template<matrix_order R_ORDER, matrix_style R_STYLE, typename T_type , matrix_order ORDER, matrix_style STYLE>
Matrix< bool, R_ORDER, R_STYLE >	operator! (const Matrix< T_type, ORDER, STYLE > &M)
	Logically NOT a Matrix.
template<typename T_type , matrix_order ORDER, matrix_style P_STYLE>
Matrix< bool, ORDER, Concrete >	operator! (const Matrix< T_type, ORDER, P_STYLE > &M)
template<matrix_order ORDER, matrix_style STYLE, typename T_type , matrix_order L_ORDER, matrix_style L_STYLE, matrix_order R_ORDER, matrix_style R_STYLE>
Matrix< bool, ORDER, STYLE >	operator== (const Matrix< T_type, L_ORDER, L_STYLE > &lhs, const Matrix< T_type, R_ORDER, R_STYLE > &rhs)
	Test Matrix equality.
template<typename T_type , matrix_order ORDER, matrix_style L_STYLE, matrix_order R_ORDER, matrix_style R_STYLE>
Matrix< bool, ORDER, Concrete >	operator== (const Matrix< T_type, ORDER, L_STYLE > &lhs, const Matrix< T_type, R_ORDER, R_STYLE > &rhs)
template<matrix_order ORDER, matrix_style STYLE, typename T_type , matrix_order L_ORDER, matrix_style L_STYLE>
Matrix< bool, ORDER, STYLE >	operator== (const Matrix< T_type, L_ORDER, L_STYLE > &lhs, const typename Matrix< T_type >::ttype &rhs)
template<typename T_type , matrix_order ORDER, matrix_style L_STYLE>
Matrix< bool, ORDER, Concrete >	operator== (const Matrix< T_type, ORDER, L_STYLE > &lhs, const typename Matrix< T_type >::ttype &rhs)
template<matrix_order ORDER, matrix_style STYLE, typename T_type , matrix_order R_ORDER, matrix_style R_STYLE>
Matrix< bool, ORDER, STYLE >	operator== (const typename Matrix< T_type >::ttype &lhs, const Matrix< T_type, R_ORDER, R_STYLE > &rhs)
template<typename T_type , matrix_order ORDER, matrix_style R_STYLE>
Matrix< bool, ORDER, Concrete >	operator== (const typename Matrix< T_type >::ttype &lhs, const Matrix< T_type, ORDER, R_STYLE > &rhs)
template<matrix_order ORDER, matrix_style STYLE, typename T_type , matrix_order L_ORDER, matrix_style L_STYLE, matrix_order R_ORDER, matrix_style R_STYLE>
Matrix< bool, ORDER, STYLE >	operator!= (const Matrix< T_type, L_ORDER, L_STYLE > &lhs, const Matrix< T_type, R_ORDER, R_STYLE > &rhs)
	Test Matrix equality.
template<typename T_type , matrix_order ORDER, matrix_style L_STYLE, matrix_order R_ORDER, matrix_style R_STYLE>
Matrix< bool, ORDER, Concrete >	operator!= (const Matrix< T_type, ORDER, L_STYLE > &lhs, const Matrix< T_type, R_ORDER, R_STYLE > &rhs)
template<matrix_order ORDER, matrix_style STYLE, typename T_type , matrix_order L_ORDER, matrix_style L_STYLE>
Matrix< bool, ORDER, STYLE >	operator!= (const Matrix< T_type, L_ORDER, L_STYLE > &lhs, const typename Matrix< T_type >::ttype &rhs)
template<typename T_type , matrix_order ORDER, matrix_style L_STYLE>
Matrix< bool, ORDER, Concrete >	operator!= (const Matrix< T_type, ORDER, L_STYLE > &lhs, const typename Matrix< T_type >::ttype &rhs)
template<matrix_order ORDER, matrix_style STYLE, typename T_type , matrix_order R_ORDER, matrix_style R_STYLE>
Matrix< bool, ORDER, STYLE >	operator!= (const typename Matrix< T_type >::ttype &lhs, const Matrix< T_type, R_ORDER, R_STYLE > &rhs)
template<typename T_type , matrix_order ORDER, matrix_style R_STYLE>
Matrix< bool, ORDER, Concrete >	operator!= (const typename Matrix< T_type >::ttype &lhs, const Matrix< T_type, ORDER, R_STYLE > &rhs)
template<matrix_order ORDER, matrix_style STYLE, typename T_type , matrix_order L_ORDER, matrix_style L_STYLE, matrix_order R_ORDER, matrix_style R_STYLE>
Matrix< bool, ORDER, STYLE >	operator< (const Matrix< T_type, L_ORDER, L_STYLE > &lhs, const Matrix< T_type, R_ORDER, R_STYLE > &rhs)
	Test Matrix inequality.
template<typename T_type , matrix_order ORDER, matrix_style L_STYLE, matrix_order R_ORDER, matrix_style R_STYLE>
Matrix< bool, ORDER, Concrete >	operator< (const Matrix< T_type, ORDER, L_STYLE > &lhs, const Matrix< T_type, R_ORDER, R_STYLE > &rhs)
template<matrix_order ORDER, matrix_style STYLE, typename T_type , matrix_order L_ORDER, matrix_style L_STYLE>
Matrix< bool, ORDER, STYLE >	operator< (const Matrix< T_type, L_ORDER, L_STYLE > &lhs, const typename Matrix< T_type >::ttype &rhs)
template<typename T_type , matrix_order ORDER, matrix_style L_STYLE>
Matrix< bool, ORDER, Concrete >	operator< (const Matrix< T_type, ORDER, L_STYLE > &lhs, const typename Matrix< T_type >::ttype &rhs)
template<matrix_order ORDER, matrix_style STYLE, typename T_type , matrix_order R_ORDER, matrix_style R_STYLE>
Matrix< bool, ORDER, STYLE >	operator< (const typename Matrix< T_type >::ttype &lhs, const Matrix< T_type, R_ORDER, R_STYLE > &rhs)
template<typename T_type , matrix_order ORDER, matrix_style R_STYLE>
Matrix< bool, ORDER, Concrete >	operator< (const typename Matrix< T_type >::ttype &lhs, const Matrix< T_type, ORDER, R_STYLE > &rhs)
template<matrix_order ORDER, matrix_style STYLE, typename T_type , matrix_order L_ORDER, matrix_style L_STYLE, matrix_order R_ORDER, matrix_style R_STYLE>
Matrix< bool, ORDER, STYLE >	operator<= (const Matrix< T_type, L_ORDER, L_STYLE > &lhs, const Matrix< T_type, R_ORDER, R_STYLE > &rhs)
	Test Matrix inequality.
template<typename T_type , matrix_order ORDER, matrix_style L_STYLE, matrix_order R_ORDER, matrix_style R_STYLE>
Matrix< bool, ORDER, Concrete >	operator<= (const Matrix< T_type, ORDER, L_STYLE > &lhs, const Matrix< T_type, R_ORDER, R_STYLE > &rhs)
template<matrix_order ORDER, matrix_style STYLE, typename T_type , matrix_order L_ORDER, matrix_style L_STYLE>
Matrix< bool, ORDER, STYLE >	operator<= (const Matrix< T_type, L_ORDER, L_STYLE > &lhs, const typename Matrix< T_type >::ttype &rhs)
template<typename T_type , matrix_order ORDER, matrix_style L_STYLE>
Matrix< bool, ORDER, Concrete >	operator<= (const Matrix< T_type, ORDER, L_STYLE > &lhs, const typename Matrix< T_type >::ttype &rhs)
template<matrix_order ORDER, matrix_style STYLE, typename T_type , matrix_order R_ORDER, matrix_style R_STYLE>
Matrix< bool, ORDER, STYLE >	operator<= (const typename Matrix< T_type >::ttype &lhs, const Matrix< T_type, R_ORDER, R_STYLE > &rhs)
template<typename T_type , matrix_order ORDER, matrix_style R_STYLE>
Matrix< bool, ORDER, Concrete >	operator<= (const typename Matrix< T_type >::ttype &lhs, const Matrix< T_type, ORDER, R_STYLE > &rhs)
template<matrix_order ORDER, matrix_style STYLE, typename T_type , matrix_order L_ORDER, matrix_style L_STYLE, matrix_order R_ORDER, matrix_style R_STYLE>
Matrix< bool, ORDER, STYLE >	operator> (const Matrix< T_type, L_ORDER, L_STYLE > &lhs, const Matrix< T_type, R_ORDER, R_STYLE > &rhs)
	Test Matrix inequality.
template<typename T_type , matrix_order ORDER, matrix_style L_STYLE, matrix_order R_ORDER, matrix_style R_STYLE>
Matrix< bool, ORDER, Concrete >	operator> (const Matrix< T_type, ORDER, L_STYLE > &lhs, const Matrix< T_type, R_ORDER, R_STYLE > &rhs)
template<matrix_order ORDER, matrix_style STYLE, typename T_type , matrix_order L_ORDER, matrix_style L_STYLE>
Matrix< bool, ORDER, STYLE >	operator> (const Matrix< T_type, L_ORDER, L_STYLE > &lhs, const typename Matrix< T_type >::ttype &rhs)
template<typename T_type , matrix_order ORDER, matrix_style L_STYLE>
Matrix< bool, ORDER, Concrete >	operator> (const Matrix< T_type, ORDER, L_STYLE > &lhs, const typename Matrix< T_type >::ttype &rhs)
template<matrix_order ORDER, matrix_style STYLE, typename T_type , matrix_order R_ORDER, matrix_style R_STYLE>
Matrix< bool, ORDER, STYLE >	operator> (const typename Matrix< T_type >::ttype &lhs, const Matrix< T_type, R_ORDER, R_STYLE > &rhs)
template<typename T_type , matrix_order ORDER, matrix_style R_STYLE>
Matrix< bool, ORDER, Concrete >	operator> (const typename Matrix< T_type >::ttype &lhs, const Matrix< T_type, ORDER, R_STYLE > &rhs)
template<matrix_order ORDER, matrix_style STYLE, typename T_type , matrix_order L_ORDER, matrix_style L_STYLE, matrix_order R_ORDER, matrix_style R_STYLE>
Matrix< bool, ORDER, STYLE >	operator>= (const Matrix< T_type, L_ORDER, L_STYLE > &lhs, const Matrix< T_type, R_ORDER, R_STYLE > &rhs)
	Test Matrix inequality.
template<typename T_type , matrix_order ORDER, matrix_style L_STYLE, matrix_order R_ORDER, matrix_style R_STYLE>
Matrix< bool, ORDER, Concrete >	operator>= (const Matrix< T_type, ORDER, L_STYLE > &lhs, const Matrix< T_type, R_ORDER, R_STYLE > &rhs)
template<matrix_order ORDER, matrix_style STYLE, typename T_type , matrix_order L_ORDER, matrix_style L_STYLE>
Matrix< bool, ORDER, STYLE >	operator>= (const Matrix< T_type, L_ORDER, L_STYLE > &lhs, const typename Matrix< T_type >::ttype &rhs)
template<typename T_type , matrix_order ORDER, matrix_style L_STYLE>
Matrix< bool, ORDER, Concrete >	operator>= (const Matrix< T_type, ORDER, L_STYLE > &lhs, const typename Matrix< T_type >::ttype &rhs)
template<matrix_order ORDER, matrix_style STYLE, typename T_type , matrix_order R_ORDER, matrix_style R_STYLE>
Matrix< bool, ORDER, STYLE >	operator>= (const typename Matrix< T_type >::ttype &lhs, const Matrix< T_type, R_ORDER, R_STYLE > &rhs)
template<typename T_type , matrix_order ORDER, matrix_style R_STYLE>
Matrix< bool, ORDER, Concrete >	operator>= (const typename Matrix< T_type >::ttype &lhs, const Matrix< T_type, ORDER, R_STYLE > &rhs)
template<matrix_order ORDER, matrix_style STYLE, typename T_type , matrix_order L_ORDER, matrix_style L_STYLE, matrix_order R_ORDER, matrix_style R_STYLE>
Matrix< bool, ORDER, STYLE >	operator& (const Matrix< T_type, L_ORDER, L_STYLE > &lhs, const Matrix< T_type, R_ORDER, R_STYLE > &rhs)
	Logically AND two matrices.
template<typename T_type , matrix_order ORDER, matrix_style L_STYLE, matrix_order R_ORDER, matrix_style R_STYLE>
Matrix< bool, ORDER, Concrete >	operator& (const Matrix< T_type, ORDER, L_STYLE > &lhs, const Matrix< T_type, R_ORDER, R_STYLE > &rhs)
template<matrix_order ORDER, matrix_style STYLE, typename T_type , matrix_order L_ORDER, matrix_style L_STYLE>
Matrix< bool, ORDER, STYLE >	operator& (const Matrix< T_type, L_ORDER, L_STYLE > &lhs, const typename Matrix< T_type >::ttype &rhs)
template<typename T_type , matrix_order ORDER, matrix_style L_STYLE>
Matrix< bool, ORDER, Concrete >	operator& (const Matrix< T_type, ORDER, L_STYLE > &lhs, const typename Matrix< T_type >::ttype &rhs)
template<matrix_order ORDER, matrix_style STYLE, typename T_type , matrix_order R_ORDER, matrix_style R_STYLE>
Matrix< bool, ORDER, STYLE >	operator& (const typename Matrix< T_type >::ttype &lhs, const Matrix< T_type, R_ORDER, R_STYLE > &rhs)
template<typename T_type , matrix_order ORDER, matrix_style R_STYLE>
Matrix< bool, ORDER, Concrete >	operator& (const typename Matrix< T_type >::ttype &lhs, const Matrix< T_type, ORDER, R_STYLE > &rhs)
template<matrix_order ORDER, matrix_style STYLE, typename T_type , matrix_order L_ORDER, matrix_style L_STYLE, matrix_order R_ORDER, matrix_style R_STYLE>
Matrix< bool, ORDER, STYLE >	operator\| (const Matrix< T_type, L_ORDER, L_STYLE > &lhs, const Matrix< T_type, R_ORDER, R_STYLE > &rhs)
	Logically OR two matrices.
template<typename T_type , matrix_order ORDER, matrix_style L_STYLE, matrix_order R_ORDER, matrix_style R_STYLE>
Matrix< bool, ORDER, Concrete >	operator\| (const Matrix< T_type, ORDER, L_STYLE > &lhs, const Matrix< T_type, R_ORDER, R_STYLE > &rhs)
template<matrix_order ORDER, matrix_style STYLE, typename T_type , matrix_order L_ORDER, matrix_style L_STYLE>
Matrix< bool, ORDER, STYLE >	operator\| (const Matrix< T_type, L_ORDER, L_STYLE > &lhs, const typename Matrix< T_type >::ttype &rhs)
template<typename T_type , matrix_order ORDER, matrix_style L_STYLE>
Matrix< bool, ORDER, Concrete >	operator\| (const Matrix< T_type, ORDER, L_STYLE > &lhs, const typename Matrix< T_type >::ttype &rhs)
template<matrix_order ORDER, matrix_style STYLE, typename T_type , matrix_order R_ORDER, matrix_style R_STYLE>
Matrix< bool, ORDER, STYLE >	operator\| (const typename Matrix< T_type >::ttype &lhs, const Matrix< T_type, R_ORDER, R_STYLE > &rhs)
template<typename T_type , matrix_order ORDER, matrix_style R_STYLE>
Matrix< bool, ORDER, Concrete >	operator\| (const typename Matrix< T_type >::ttype &lhs, const Matrix< T_type, ORDER, R_STYLE > &rhs)
template<typename T , matrix_order O, matrix_style S>
std::istream &	operator>> (std::istream &is, Matrix< T, O, S > &M)
	Populate a Matrix from a stream.
template<typename T , matrix_order O, matrix_style S>
std::ostream &	operator<< (std::ostream &os, const Matrix< T, O, S > &M)
	Write a Matrix to a stream.
template<>
Matrix	*operator< double, Col, Concrete, Col, Concrete >** (const Matrix<> &lhs, const Matrix<> &rhs)
template<class T_type , matrix_order ORDER, matrix_order M_ORDER, matrix_style STYLE>
const_matrix_random_access_iterator < T_type, ORDER, M_ORDER, STYLE >	operator+ (const_matrix_random_access_iterator< T_type, ORDER, M_ORDER, STYLE > x, int n)
template<class T_type , matrix_order ORDER, matrix_order M_ORDER, matrix_style STYLE>
const_matrix_random_access_iterator < T_type, ORDER, M_ORDER, STYLE >	operator+ (int n, const_matrix_random_access_iterator< T_type, ORDER, M_ORDER, STYLE > x)
template<class T_type , matrix_order ORDER, matrix_order M_ORDER, matrix_style STYLE>
const_matrix_random_access_iterator < T_type, ORDER, M_ORDER, STYLE >	operator- (const_matrix_random_access_iterator< T_type, ORDER, M_ORDER, STYLE > x, int n)
template<class T_type , matrix_order ORDER, matrix_order M_ORDER, matrix_style STYLE>
matrix_random_access_iterator < T_type, ORDER, M_ORDER, STYLE >	operator+ (matrix_random_access_iterator< T_type, ORDER, M_ORDER, STYLE > x, int n)
template<class T_type , matrix_order ORDER, matrix_order M_ORDER, matrix_style STYLE>
matrix_random_access_iterator < T_type, ORDER, M_ORDER, STYLE >	operator+ (int n, matrix_random_access_iterator< T_type, ORDER, M_ORDER, STYLE > x)
template<class T_type , matrix_order ORDER, matrix_order M_ORDER, matrix_style STYLE>
matrix_random_access_iterator < T_type, ORDER, M_ORDER, STYLE >	operator- (matrix_random_access_iterator< T_type, ORDER, M_ORDER, STYLE > x, int n)
template<typename T >
T	epsilon ()
	Compute the machine epsilon.
template<typename T , typename FUNCTOR >
T	intsimp (FUNCTOR fun, T a, T b, unsigned int N)
	Calculate the definite integral of a function from a to b.
template<typename T , typename FUNCTOR >
T	adaptsimp (FUNCTOR fun, T a, T b, unsigned int N, double tol=1e-5)
	Calculate the definite integral of a function from a to b.
template<matrix_order RO, matrix_style RS, typename T , matrix_order PO, matrix_style PS, typename FUNCTOR >
Matrix< T, RO, RS >	gradfdif (FUNCTOR fun, const Matrix< T, PO, PS > &theta)
	Calculate gradient of a function using a forward difference formula.
template<typename T , matrix_order O, matrix_style S, typename FUNCTOR >
Matrix< T, O, Concrete >	gradfdif (FUNCTOR fun, const Matrix< T, O, S > &theta)
template<typename T , matrix_order PO1, matrix_style PS1, matrix_order PO2, matrix_style PS2, typename FUNCTOR >
T	gradfdifls (FUNCTOR fun, T alpha, const Matrix< T, PO1, PS1 > &theta, const Matrix< T, PO2, PS2 > &p)
	Calculate the first derivative of the function using a forward difference formula.
template<matrix_order RO, matrix_style RS, typename T , matrix_order PO, matrix_style PS, typename FUNCTOR >
Matrix< T, RO, RS >	jacfdif (FUNCTOR fun, const Matrix< T, PO, PS > &theta)
	Calculate the Jacobian of a function using a forward difference formula.
template<typename T , matrix_order PO, matrix_style PS, typename FUNCTOR >
Matrix< T, PO, PS >	jacfdif (FUNCTOR fun, const Matrix< T, PO, PS > &theta)
template<matrix_order RO, matrix_style RS, typename T , matrix_order PO, matrix_style PS, typename FUNCTOR >
Matrix< T, RO, RS >	hesscdif (FUNCTOR fun, const Matrix< T, PO, PS > &theta)
	Calculate the Hessian of a function using a central difference formula.
template<typename T , matrix_order PO, matrix_style PS, typename FUNCTOR >
Matrix< T, PO, PS >	hesscdif (FUNCTOR fun, const Matrix< T, PO, PS > &theta)
template<typename T , matrix_order PO1, matrix_style PS1, matrix_order PO2, matrix_style PS2, typename FUNCTOR >
T	linesearch1 (FUNCTOR fun, const Matrix< T, PO1, PS1 > &theta, const Matrix< T, PO2, PS2 > &p)
	Find the step length that minimizes an implied 1-dimensional function.
template<typename T , matrix_order PO1, matrix_style PS1, matrix_order PO2, matrix_style PS2, typename FUNCTOR , typename RNGTYPE >
T	linesearch2 (FUNCTOR fun, const Matrix< T, PO1, PS1 > &theta, const Matrix< T, PO2, PS2 > &p, rng< RNGTYPE > &runif)
	Find the step length that minimizes an implied 1-dimensional function.
template<typename T , matrix_order PO1, matrix_style PS1, matrix_order PO2, matrix_style PS2, typename FUNCTOR >
T	zoom (FUNCTOR fun, T alpha_lo, T alpha_hi, const Matrix< T, PO1, PS1 > &theta, const Matrix< T, PO2, PS2 > &p)
	Find minimum of a function once bracketed.
template<matrix_order RO, matrix_style RS, typename T , matrix_order PO, matrix_style PS, typename FUNCTOR , typename RNGTYPE >
Matrix< T, RO, RS >	BFGS (FUNCTOR fun, const Matrix< T, PO, PS > &theta, rng< RNGTYPE > &runif, unsigned int maxit, T tolerance, bool trace=false)
	Find function minimum using the BFGS algorithm.
template<typename T , matrix_order O, matrix_style S, typename FUNCTOR , typename RNGTYPE >
Matrix< T, O, Concrete >	BFGS (FUNCTOR fun, const Matrix< T, O, S > &theta, rng< RNGTYPE > &runif, unsigned int maxit, T tolerance, bool trace=false)
template<matrix_order RO, matrix_style RS, typename T , matrix_order PO, matrix_style PS, typename FUNCTOR >
Matrix< T, RO, RS >	nls_broyden (FUNCTOR fun, const Matrix< T, PO, PS > &theta, unsigned int maxit=5000, T tolerance=1e-6)
	Solve a system of nonlinear equations.
template<typename T , matrix_order O, matrix_style S, typename FUNCTOR >
Matrix< T, O, Concrete >	nls_broyden (FUNCTOR fun, const Matrix< T, O, S > &theta, unsigned int maxit=5000, T tolerance=1e-6)
template<matrix_order RO, matrix_style RS, typename T , matrix_order PO, matrix_style PS>
Matrix< T, RO, RS >	acos (const Matrix< T, PO, PS > &A)
	Calculate the inverse cosine of each element of a Matrix.
template<typename T , matrix_order O, matrix_style S>
Matrix< T, O, Concrete >	acos (const Matrix< T, O, S > &A)
template<matrix_order RO, matrix_style RS, typename T , matrix_order PO, matrix_style PS>
Matrix< T, RO, RS >	acosh (const Matrix< T, PO, PS > &A)
	Calculate the inverse hyperbolic cosine of each element of a Matrix.
template<typename T , matrix_order O, matrix_style S>
Matrix< T, O, Concrete >	acosh (const Matrix< T, O, S > &A)
template<matrix_order RO, matrix_style RS, typename T , matrix_order PO, matrix_style PS>
Matrix< T, RO, RS >	asin (const Matrix< T, PO, PS > &A)
	Calculate the inverse sine of each element of a Matrix.
template<typename T , matrix_order O, matrix_style S>
Matrix< T, O, Concrete >	asin (const Matrix< T, O, S > &A)
template<matrix_order RO, matrix_style RS, typename T , matrix_order PO, matrix_style PS>
Matrix< T, RO, RS >	asinh (const Matrix< T, PO, PS > &A)
	Calculate the inverse hyperbolic sine of each element of a Matrix.
template<typename T , matrix_order O, matrix_style S>
Matrix< T, O, Concrete >	asinh (const Matrix< T, O, S > &A)
template<matrix_order RO, matrix_style RS, typename T , matrix_order PO, matrix_style PS>
Matrix< T, RO, RS >	atan (const Matrix< T, PO, PS > &A)
	Calculate the inverse tangent of each element of a Matrix.
template<typename T , matrix_order O, matrix_style S>
Matrix< T, O, Concrete >	atan (const Matrix< T, O, S > &A)
template<matrix_order RO, matrix_style RS, typename T , matrix_order PO, matrix_style PS>
Matrix< T, RO, RS >	atanh (const Matrix< T, PO, PS > &A)
	Calculate the inverse hyperbolic tangent of each element of a Matrix.
template<typename T , matrix_order O, matrix_style S>
Matrix< T, O, Concrete >	atanh (const Matrix< T, O, S > &A)
template<matrix_order RO, matrix_style RS, typename T , matrix_order PO1, matrix_style PS1, matrix_order PO2, matrix_style PS2, typename S >
Matrix< T, RO, RS >	atan2 (const Matrix< T, PO1, PS1 > &A, const Matrix< S, PO2, PS2 > &B)
	Calculate the angle whose tangent is y/x.
template<typename T , matrix_order PO1, matrix_style PS1, matrix_order PO2, matrix_style PS2, typename S >
Matrix< T, PO1, Concrete >	atan2 (const Matrix< T, PO1, PS1 > &A, const Matrix< S, PO2, PS2 > &B)
template<matrix_order RO, matrix_style RS, typename T , matrix_order PO, matrix_style PS, typename S >
Matrix< T, RO, RS >	atan2 (const Matrix< T, PO, PS > &A, S b)
template<typename T , typename S , matrix_order PO, matrix_style PS>
Matrix< T, PO, Concrete >	atan2 (const Matrix< T, PO, PS > &A, S b)
template<matrix_order RO, matrix_style RS, typename T , matrix_order PO, matrix_style PS, typename S >
Matrix< T, RO, RS >	atan2 (T a, const Matrix< S, PO, PS > &B)
template<typename T , typename S , matrix_order PO, matrix_style PS>
Matrix< T, PO, Concrete >	atan2 (T a, const Matrix< S, PO, PS > &B)
template<matrix_order RO, matrix_style RS, typename T , matrix_order PO, matrix_style PS>
Matrix< T, RO, RS >	cbrt (const Matrix< T, PO, PS > &A)
	Calculate the cube root of each element of a Matrix.
template<typename T , matrix_order O, matrix_style S>
Matrix< T, O, Concrete >	cbrt (const Matrix< T, O, S > &A)
template<matrix_order RO, matrix_style RS, typename T , matrix_order PO, matrix_style PS>
Matrix< T, RO, RS >	ceil (const Matrix< T, PO, PS > &A)
	Calculate the ceiling of each element of a Matrix.
template<typename T , matrix_order O, matrix_style S>
Matrix< T, O, Concrete >	ceil (const Matrix< T, O, S > &A)
template<matrix_order RO, matrix_style RS, typename T , matrix_order PO1, matrix_style PS1, matrix_order PO2, matrix_style PS2, typename S >
Matrix< T, RO, RS >	copysign (const Matrix< T, PO1, PS1 > &A, const Matrix< S, PO2, PS2 > &B)
	Create a matrix containing the absolute value of the first input and the sign of the second input.
template<typename T , matrix_order PO1, matrix_style PS1, matrix_order PO2, matrix_style PS2, typename S >
Matrix< T, PO1, Concrete >	copysign (const Matrix< T, PO1, PS1 > &A, const Matrix< S, PO2, PS2 > &B)
template<matrix_order RO, matrix_style RS, typename T , matrix_order PO, matrix_style PS, typename S >
Matrix< T, RO, RS >	copysign (const Matrix< T, PO, PS > &A, S b)
template<typename T , typename S , matrix_order PO, matrix_style PS>
Matrix< T, PO, Concrete >	copysign (const Matrix< T, PO, PS > &A, S b)
template<matrix_order RO, matrix_style RS, typename T , matrix_order PO, matrix_style PS, typename S >
Matrix< T, RO, RS >	copysign (T a, const Matrix< S, PO, PS > &B)
template<typename T , typename S , matrix_order PO, matrix_style PS>
Matrix< T, PO, Concrete >	copysign (T a, const Matrix< S, PO, PS > &B)
template<matrix_order RO, matrix_style RS, typename T , matrix_order PO, matrix_style PS>
Matrix< T, RO, RS >	cos (const Matrix< T, PO, PS > &A)
	Calculate the cosine of each element of a Matrix.
template<typename T , matrix_order O, matrix_style S>
Matrix< T, O, Concrete >	cos (const Matrix< T, O, S > &A)
template<matrix_order RO, matrix_style RS, typename T , matrix_order PO, matrix_style PS>
Matrix< T, RO, RS >	cosh (const Matrix< T, PO, PS > &A)
	Calculate the hyperbolic cosine of each element of a Matrix.
template<typename T , matrix_order O, matrix_style S>
Matrix< T, O, Concrete >	cosh (const Matrix< T, O, S > &A)
template<matrix_order RO, matrix_style RS, typename T , matrix_order PO, matrix_style PS>
Matrix< T, RO, RS >	erf (const Matrix< T, PO, PS > &A)
	Calculate the error function of each element of a Matrix.
template<typename T , matrix_order O, matrix_style S>
Matrix< T, O, Concrete >	erf (const Matrix< T, O, S > &A)
template<matrix_order RO, matrix_style RS, typename T , matrix_order PO, matrix_style PS>
Matrix< T, RO, RS >	erfc (const Matrix< T, PO, PS > &A)
	Calculate the complementary error function of each element of a Matrix.
template<typename T , matrix_order O, matrix_style S>
Matrix< T, O, Concrete >	erfc (const Matrix< T, O, S > &A)
template<matrix_order RO, matrix_style RS, typename T , matrix_order PO, matrix_style PS>
Matrix< T, RO, RS >	exp (const Matrix< T, PO, PS > &A)
	Calculate the value e^x for each element of a Matrix.
template<typename T , matrix_order O, matrix_style S>
Matrix< T, O, Concrete >	exp (const Matrix< T, O, S > &A)
template<matrix_order RO, matrix_style RS, typename T , matrix_order PO, matrix_style PS>
Matrix< T, RO, RS >	expm1 (const Matrix< T, PO, PS > &A)
	Calculate the value e^(x-1) for each element of a Matrix.
template<typename T , matrix_order O, matrix_style S>
Matrix< T, O, Concrete >	expm1 (const Matrix< T, O, S > &A)
template<matrix_order RO, matrix_style RS, typename T , matrix_order PO, matrix_style PS>
Matrix< T, RO, RS >	fabs (const Matrix< T, PO, PS > &A)
	Calculate the absolute value of each element of a Matrix.
template<typename T , matrix_order O, matrix_style S>
Matrix< T, O, Concrete >	fabs (const Matrix< T, O, S > &A)
template<matrix_order RO, matrix_style RS, typename T , matrix_order PO, matrix_style PS>
Matrix< T, RO, RS >	floor (const Matrix< T, PO, PS > &A)
	Calculate the floor of each element of a Matrix.
template<typename T , matrix_order O, matrix_style S>
Matrix< T, O, Concrete >	floor (const Matrix< T, O, S > &A)
template<matrix_order RO, matrix_style RS, typename T , matrix_order PO1, matrix_style PS1, matrix_order PO2, matrix_style PS2, typename S >
Matrix< T, RO, RS >	fmod (const Matrix< T, PO1, PS1 > &A, const Matrix< S, PO2, PS2 > &B)
	Calculate the remainder of the division of each matrix element.
template<typename T , matrix_order PO1, matrix_style PS1, matrix_order PO2, matrix_style PS2, typename S >
Matrix< T, PO1, Concrete >	fmod (const Matrix< T, PO1, PS1 > &A, const Matrix< S, PO2, PS2 > &B)
template<matrix_order RO, matrix_style RS, typename T , matrix_order PO, matrix_style PS, typename S >
Matrix< T, RO, RS >	fmod (const Matrix< T, PO, PS > &A, S b)
template<typename T , typename S , matrix_order PO, matrix_style PS>
Matrix< T, PO, Concrete >	fmod (const Matrix< T, PO, PS > &A, S b)
template<matrix_order RO, matrix_style RS, typename T , matrix_order PO, matrix_style PS, typename S >
Matrix< T, RO, RS >	fmod (T a, const Matrix< S, PO, PS > &B)
template<typename T , typename S , matrix_order PO, matrix_style PS>
Matrix< T, PO, Concrete >	fmod (T a, const Matrix< S, PO, PS > &B)
template<matrix_order RO, matrix_style RS, typename T , matrix_order PO1, matrix_style PS1, matrix_order PO2, matrix_style PS2>
Matrix< T, RO, RS >	frexp (const Matrix< T, PO1, PS1 > &A, Matrix< int, PO2, PS2 > &ex)
template<typename T , matrix_order PO1, matrix_style PS1, matrix_order PO2, matrix_style PS2>
Matrix< T, PO1, Concrete >	frexp (Matrix< T, PO1, PS1 > &A, Matrix< int, PO2, PS2 > &ex)
template<matrix_order RO, matrix_style RS, typename T , matrix_order PO1, matrix_style PS1, matrix_order PO2, matrix_style PS2, typename S >
Matrix< T, RO, RS >	hypot (const Matrix< T, PO1, PS1 > &A, const Matrix< S, PO2, PS2 > &B)
	Calculate the euclidean distance between two inputs.
template<typename T , matrix_order PO1, matrix_style PS1, matrix_order PO2, matrix_style PS2, typename S >
Matrix< T, PO1, Concrete >	hypot (const Matrix< T, PO1, PS1 > &A, const Matrix< S, PO2, PS2 > &B)
template<matrix_order RO, matrix_style RS, typename T , matrix_order PO, matrix_style PS, typename S >
Matrix< T, RO, RS >	hypot (const Matrix< T, PO, PS > &A, S b)
template<typename T , typename S , matrix_order PO, matrix_style PS>
Matrix< T, PO, Concrete >	hypot (const Matrix< T, PO, PS > &A, S b)
template<matrix_order RO, matrix_style RS, typename T , matrix_order PO, matrix_style PS, typename S >
Matrix< T, RO, RS >	hypot (T a, const Matrix< S, PO, PS > &B)
template<typename T , typename S , matrix_order PO, matrix_style PS>
Matrix< T, PO, Concrete >	hypot (T a, const Matrix< S, PO, PS > &B)
template<matrix_order RO, matrix_style RS, typename T , matrix_order PO, matrix_style PS>
Matrix< T, RO, RS >	ilogb (const Matrix< T, PO, PS > &A)
template<typename T , matrix_order O, matrix_style S>
Matrix< T, O, Concrete >	ilogb (const Matrix< T, O, S > &A)
template<matrix_order RO, matrix_style RS, typename T , matrix_order PO, matrix_style PS>
Matrix< T, RO, RS >	j0 (const Matrix< T, PO, PS > &A)
	Compute the Bessel function of the first kind of the order 0.
template<typename T , matrix_order O, matrix_style S>
Matrix< T, O, Concrete >	j0 (const Matrix< T, O, S > &A)
template<matrix_order RO, matrix_style RS, typename T , matrix_order PO, matrix_style PS>
Matrix< T, RO, RS >	j1 (const Matrix< T, PO, PS > &A)
	Compute the Bessel function of the first kind of the order 1.
template<typename T , matrix_order O, matrix_style S>
Matrix< T, O, Concrete >	j1 (const Matrix< T, O, S > &A)
template<matrix_order RO, matrix_style RS, typename T , matrix_order PO1, matrix_style PS1, matrix_order PO2, matrix_style PS2, typename S >
Matrix< T, RO, RS >	jn (const Matrix< T, PO1, PS1 > &A, const Matrix< S, PO2, PS2 > &B)
	Compute the Bessel function of the first kind of the order n.
template<typename T , matrix_order PO1, matrix_style PS1, matrix_order PO2, matrix_style PS2, typename S >
Matrix< T, PO1, Concrete >	jn (const Matrix< T, PO1, PS1 > &A, const Matrix< S, PO2, PS2 > &B)
template<matrix_order RO, matrix_style RS, typename T , matrix_order PO, matrix_style PS, typename S >
Matrix< T, RO, RS >	jn (const Matrix< T, PO, PS > &A, S b)
template<typename T , typename S , matrix_order PO, matrix_style PS>
Matrix< T, PO, Concrete >	jn (const Matrix< T, PO, PS > &A, S b)
template<matrix_order RO, matrix_style RS, typename T , matrix_order PO, matrix_style PS, typename S >
Matrix< T, RO, RS >	jn (T a, const Matrix< S, PO, PS > &B)
template<typename T , typename S , matrix_order PO, matrix_style PS>
Matrix< T, PO, Concrete >	jn (T a, const Matrix< S, PO, PS > &B)
template<matrix_order RO, matrix_style RS, typename T , matrix_order PO1, matrix_style PS1, matrix_order PO2, matrix_style PS2, typename S >
Matrix< T, RO, RS >	ldexp (const Matrix< T, PO1, PS1 > &A, const Matrix< S, PO2, PS2 > &B)
	Compute x * 2^ex.
template<typename T , matrix_order PO1, matrix_style PS1, matrix_order PO2, matrix_style PS2, typename S >
Matrix< T, PO1, Concrete >	ldexp (const Matrix< T, PO1, PS1 > &A, const Matrix< S, PO2, PS2 > &B)
template<matrix_order RO, matrix_style RS, typename T , matrix_order PO, matrix_style PS, typename S >
Matrix< T, RO, RS >	ldexp (const Matrix< T, PO, PS > &A, S b)
template<typename T , typename S , matrix_order PO, matrix_style PS>
Matrix< T, PO, Concrete >	ldexp (const Matrix< T, PO, PS > &A, S b)
template<matrix_order RO, matrix_style RS, typename T , matrix_order PO, matrix_style PS, typename S >
Matrix< T, RO, RS >	ldexp (T a, const Matrix< S, PO, PS > &B)
template<typename T , typename S , matrix_order PO, matrix_style PS>
Matrix< T, PO, Concrete >	ldexp (T a, const Matrix< S, PO, PS > &B)
template<matrix_order RO, matrix_style RS, typename T , matrix_order PO, matrix_style PS>
Matrix< T, RO, RS >	lgamma (const Matrix< T, PO, PS > &A)
	Compute the natural log of the absolute value of the gamma function.
template<typename T , matrix_order O, matrix_style S>
Matrix< T, O, Concrete >	lgamma (const Matrix< T, O, S > &A)
template<matrix_order RO, matrix_style RS, typename T , matrix_order PO, matrix_style PS>
Matrix< T, RO, RS >	log (const Matrix< T, PO, PS > &A)
	Compute the natural log of each element of a Matrix.
template<typename T , matrix_order O, matrix_style S>
Matrix< T, O, Concrete >	log (const Matrix< T, O, S > &A)
template<matrix_order RO, matrix_style RS, typename T , matrix_order PO, matrix_style PS>
Matrix< T, RO, RS >	log10 (const Matrix< T, PO, PS > &A)
	Compute the log base 10 of each element of a Matrix.
template<typename T , matrix_order O, matrix_style S>
Matrix< T, O, Concrete >	log10 (const Matrix< T, O, S > &A)
template<matrix_order RO, matrix_style RS, typename T , matrix_order PO, matrix_style PS>
Matrix< T, RO, RS >	log1p (const Matrix< T, PO, PS > &A)
	Compute the natural log of 1 + each element of a Matrix.
template<typename T , matrix_order O, matrix_style S>
Matrix< T, O, Concrete >	log1p (const Matrix< T, O, S > &A)
template<matrix_order RO, matrix_style RS, typename T , matrix_order PO, matrix_style PS>
Matrix< T, RO, RS >	logb (const Matrix< T, PO, PS > &A)
	Compute the logb each element of a Matrix.
template<typename T , matrix_order O, matrix_style S>
Matrix< T, O, Concrete >	logb (const Matrix< T, O, S > &A)
template<matrix_order RO, matrix_style RS, typename T , matrix_order PO1, matrix_style PS1, matrix_order PO2, matrix_style PS2>
Matrix< T, RO, RS >	modf (const Matrix< T, PO1, PS1 > &A, Matrix< double, PO2, PS2 > &ipart)
template<typename T , matrix_order PO1, matrix_style PS1, matrix_order PO2, matrix_style PS2>
Matrix< T, PO1, Concrete >	modf (Matrix< T, PO1, PS1 > &A, Matrix< double, PO2, PS2 > &ipart)
template<matrix_order RO, matrix_style RS, typename T , matrix_order PO1, matrix_style PS1, matrix_order PO2, matrix_style PS2, typename S >
Matrix< T, RO, RS >	pow (const Matrix< T, PO1, PS1 > &A, const Matrix< S, PO2, PS2 > &B)
	Compute x^ex for each element of a matrix.
template<typename T , matrix_order PO1, matrix_style PS1, matrix_order PO2, matrix_style PS2, typename S >
Matrix< T, PO1, Concrete >	pow (const Matrix< T, PO1, PS1 > &A, const Matrix< S, PO2, PS2 > &B)
template<matrix_order RO, matrix_style RS, typename T , matrix_order PO, matrix_style PS, typename S >
Matrix< T, RO, RS >	pow (const Matrix< T, PO, PS > &A, S b)
template<typename T , typename S , matrix_order PO, matrix_style PS>
Matrix< T, PO, Concrete >	pow (const Matrix< T, PO, PS > &A, S b)
template<matrix_order RO, matrix_style RS, typename T , matrix_order PO, matrix_style PS, typename S >
Matrix< T, RO, RS >	pow (T a, const Matrix< S, PO, PS > &B)
template<typename T , typename S , matrix_order PO, matrix_style PS>
Matrix< T, PO, Concrete >	pow (T a, const Matrix< S, PO, PS > &B)
template<matrix_order RO, matrix_style RS, typename T , matrix_order PO1, matrix_style PS1, matrix_order PO2, matrix_style PS2, typename S >
Matrix< T, RO, RS >	remainder (const Matrix< T, PO1, PS1 > &A, const Matrix< S, PO2, PS2 > &B)
template<typename T , matrix_order PO1, matrix_style PS1, matrix_order PO2, matrix_style PS2, typename S >
Matrix< T, PO1, Concrete >	remainder (const Matrix< T, PO1, PS1 > &A, const Matrix< S, PO2, PS2 > &B)
template<matrix_order RO, matrix_style RS, typename T , matrix_order PO, matrix_style PS, typename S >
Matrix< T, RO, RS >	remainder (const Matrix< T, PO, PS > &A, S b)
template<typename T , typename S , matrix_order PO, matrix_style PS>
Matrix< T, PO, Concrete >	remainder (const Matrix< T, PO, PS > &A, S b)
template<matrix_order RO, matrix_style RS, typename T , matrix_order PO, matrix_style PS, typename S >
Matrix< T, RO, RS >	remainder (T a, const Matrix< S, PO, PS > &B)
template<typename T , typename S , matrix_order PO, matrix_style PS>
Matrix< T, PO, Concrete >	remainder (T a, const Matrix< S, PO, PS > &B)
template<matrix_order RO, matrix_style RS, typename T , matrix_order PO, matrix_style PS>
Matrix< T, RO, RS >	rint (const Matrix< T, PO, PS > &A)
	Return x rounded to the nearest integer.
template<typename T , matrix_order O, matrix_style S>
Matrix< T, O, Concrete >	rint (const Matrix< T, O, S > &A)
template<matrix_order RO, matrix_style RS, typename T , matrix_order PO1, matrix_style PS1, matrix_order PO2, matrix_style PS2, typename S >
Matrix< T, RO, RS >	scalbn (const Matrix< T, PO1, PS1 > &A, const Matrix< S, PO2, PS2 > &B)
template<typename T , matrix_order PO1, matrix_style PS1, matrix_order PO2, matrix_style PS2, typename S >
Matrix< T, PO1, Concrete >	scalbn (const Matrix< T, PO1, PS1 > &A, const Matrix< S, PO2, PS2 > &B)
template<matrix_order RO, matrix_style RS, typename T , matrix_order PO, matrix_style PS, typename S >
Matrix< T, RO, RS >	scalbn (const Matrix< T, PO, PS > &A, S b)
template<typename T , typename S , matrix_order PO, matrix_style PS>
Matrix< T, PO, Concrete >	scalbn (const Matrix< T, PO, PS > &A, S b)
template<matrix_order RO, matrix_style RS, typename T , matrix_order PO, matrix_style PS, typename S >
Matrix< T, RO, RS >	scalbn (T a, const Matrix< S, PO, PS > &B)
template<typename T , typename S , matrix_order PO, matrix_style PS>
Matrix< T, PO, Concrete >	scalbn (T a, const Matrix< S, PO, PS > &B)
template<matrix_order RO, matrix_style RS, typename T , matrix_order PO, matrix_style PS>
Matrix< T, RO, RS >	sin (const Matrix< T, PO, PS > &A)
	Calculate the sine of each element of a Matrix.
template<typename T , matrix_order O, matrix_style S>
Matrix< T, O, Concrete >	sin (const Matrix< T, O, S > &A)
template<matrix_order RO, matrix_style RS, typename T , matrix_order PO, matrix_style PS>
Matrix< T, RO, RS >	sinh (const Matrix< T, PO, PS > &A)
	Calculate the hyperbolic sine of each element of a Matrix.
template<typename T , matrix_order O, matrix_style S>
Matrix< T, O, Concrete >	sinh (const Matrix< T, O, S > &A)
template<matrix_order RO, matrix_style RS, typename T , matrix_order PO, matrix_style PS>
Matrix< T, RO, RS >	sqrt (const Matrix< T, PO, PS > &A)
	Calculate the square root of each element in a matrix.
template<typename T , matrix_order O, matrix_style S>
Matrix< T, O, Concrete >	sqrt (const Matrix< T, O, S > &A)
template<matrix_order RO, matrix_style RS, typename T , matrix_order PO, matrix_style PS>
Matrix< T, RO, RS >	tan (const Matrix< T, PO, PS > &A)
	Calculate the tangent of each element of a Matrix.
template<typename T , matrix_order O, matrix_style S>
Matrix< T, O, Concrete >	tan (const Matrix< T, O, S > &A)
template<matrix_order RO, matrix_style RS, typename T , matrix_order PO, matrix_style PS>
Matrix< T, RO, RS >	tanh (const Matrix< T, PO, PS > &A)
	Calculate the hyperbolic tangent of each element of a Matrix.
template<typename T , matrix_order O, matrix_style S>
Matrix< T, O, Concrete >	tanh (const Matrix< T, O, S > &A)
template<matrix_order RO, matrix_style RS, typename T , matrix_order PO, matrix_style PS>
Matrix< T, RO, RS >	y0 (const Matrix< T, PO, PS > &A)
	Compute the Bessel function of the second kind of order 0.
template<typename T , matrix_order O, matrix_style S>
Matrix< T, O, Concrete >	y0 (const Matrix< T, O, S > &A)
template<matrix_order RO, matrix_style RS, typename T , matrix_order PO, matrix_style PS>
Matrix< T, RO, RS >	y1 (const Matrix< T, PO, PS > &A)
	Compute the Bessel function of the second kind of order 1.
template<typename T , matrix_order O, matrix_style S>
Matrix< T, O, Concrete >	y1 (const Matrix< T, O, S > &A)
template<matrix_order RO, matrix_style RS, typename T , matrix_order PO1, matrix_style PS1, matrix_order PO2, matrix_style PS2, typename S >
Matrix< T, RO, RS >	yn (const Matrix< T, PO1, PS1 > &A, const Matrix< S, PO2, PS2 > &B)
	Compute the Bessel function of the second kind of order n.
template<typename T , matrix_order PO1, matrix_style PS1, matrix_order PO2, matrix_style PS2, typename S >
Matrix< T, PO1, Concrete >	yn (const Matrix< T, PO1, PS1 > &A, const Matrix< S, PO2, PS2 > &B)
template<matrix_order RO, matrix_style RS, typename T , matrix_order PO, matrix_style PS, typename S >
Matrix< T, RO, RS >	yn (const Matrix< T, PO, PS > &A, S b)
template<typename T , typename S , matrix_order PO, matrix_style PS>
Matrix< T, PO, Concrete >	yn (const Matrix< T, PO, PS > &A, S b)
template<matrix_order RO, matrix_style RS, typename T , matrix_order PO, matrix_style PS, typename S >
Matrix< T, RO, RS >	yn (T a, const Matrix< S, PO, PS > &B)
template<typename T , typename S , matrix_order PO, matrix_style PS>
Matrix< T, PO, Concrete >	yn (T a, const Matrix< S, PO, PS > &B)
template<typename T , matrix_order PO, matrix_style PS>
T	sum (const Matrix< T, PO, PS > &A)
	Calculate the sum of a Matrix.
template<matrix_order RO, matrix_style RS, typename T , matrix_order PO, matrix_style PS>
Matrix< T, RO, RS >	sumc (const Matrix< T, PO, PS > &A)
	Calculate the sum of each column in a Matrix.
template<typename T , matrix_order O, matrix_style S>
Matrix< T, O, Concrete >	sumc (const Matrix< T, O, S > &A)
template<typename T , matrix_order PO, matrix_style PS>
T	prod (const Matrix< T, PO, PS > &A)
	Calculate the product of a Matrix.
template<matrix_order RO, matrix_style RS, typename T , matrix_order PO, matrix_style PS>
Matrix< T, RO, RS >	prodc (const Matrix< T, PO, PS > &A)
	Calculate the product of each column of a Matrix.
template<typename T , matrix_order O, matrix_style S>
Matrix< T, O, Concrete >	prodc (const Matrix< T, O, S > &A)
template<typename T , matrix_order PO, matrix_style PS>
T	mean (const Matrix< T, PO, PS > &A)
	Calculate the mean of a Matrix.
template<matrix_order RO, matrix_style RS, typename T , matrix_order PO, matrix_style PS>
Matrix< T, RO, RS >	meanc (const Matrix< T, PO, PS > &A)
	Calculate the mean of each column of a Matrix.
template<typename T , matrix_order O, matrix_style S>
Matrix< T, O, Concrete >	meanc (const Matrix< T, O, S > &A)
template<typename T , matrix_order PO, matrix_style PS>
T	median (const Matrix< T, PO, PS > &A)
	Calculate the median of a Matrix.
template<matrix_order RO, matrix_style RS, typename T , matrix_order PO, matrix_style PS>
Matrix< T, RO, RS >	medianc (const Matrix< T, PO, PS > &A)
	Calculate the median of each column a Matrix.
template<typename T , matrix_order O, matrix_style S>
Matrix< T, O, Concrete >	medianc (const Matrix< T, O, S > &A)
template<typename T , matrix_order PO, matrix_style PS>
T	mode (const Matrix< T, PO, PS > &A)
	Calculate the mode of a Matrix.
template<matrix_order RO, matrix_style RS, typename T , matrix_order PO, matrix_style PS>
Matrix< T, RO, RS >	modec (const Matrix< T, PO, PS > &A)
	Calculate the mode of the columns of a Matrix.
template<typename T , matrix_order O, matrix_style S>
Matrix< T, O, Concrete >	modec (const Matrix< T, O, S > &A)
template<typename T , matrix_order PO, matrix_style PS>
T	var (const Matrix< T, PO, PS > &A)
	Calculate the variance of a Matrix.
template<matrix_order RO, matrix_style RS, typename T , matrix_order PO, matrix_style PS>
Matrix< T, RO, RS >	varc (const Matrix< T, PO, PS > &A)
	Calculate the variance of each column of a Matrix.
template<typename T , matrix_order O, matrix_style S>
Matrix< T, O, Concrete >	varc (const Matrix< T, O, S > &A)
template<typename T , matrix_order PO, matrix_style PS>
T	var (const Matrix< T, PO, PS > &A, T mu)
	Calculate the variance of a Matrix.
template<typename T , matrix_order PO, matrix_style PS>
T	sd (const Matrix< T, PO, PS > &A)
	Calculate the standard deviation of a Matrix.
template<matrix_order RO, matrix_style RS, typename T , matrix_order PO, matrix_style PS>
Matrix< T, RO, RS >	sdc (const Matrix< T, PO, PS > &A)
	Calculate the standard deviation of each column of a Matrix.
template<typename T , matrix_order O, matrix_style S>
Matrix< T, O, Concrete >	sdc (const Matrix< T, O, S > &A)
template<typename T , matrix_order PO, matrix_style PS>
T	sd (const Matrix< T, PO, PS > &A, T mu)
	Calculate the standard deviation of a Matrix.
template<typename T , matrix_order PO, matrix_style PS>
T	skew (const Matrix< T, PO, PS > &A)
	Calculate the skew of a Matrix.
template<matrix_order RO, matrix_style RS, typename T , matrix_order PO, matrix_style PS>
Matrix< T, RO, RS >	skewc (const Matrix< T, PO, PS > &A)
	Calculate the skew of each column of a Matrix.
template<typename T , matrix_order O, matrix_style S>
Matrix< T, O, Concrete >	skewc (const Matrix< T, O, S > &A)
template<typename T , matrix_order PO, matrix_style PS>
T	kurtosis (const Matrix< T, PO, PS > &A)
	Calculate the kurtosis of a Matrix.
template<matrix_order RO, matrix_style RS, typename T , matrix_order PO, matrix_style PS>
Matrix< T, RO, RS >	kurtosisc (const Matrix< T, PO, PS > &A)
	Calculate the kurtosis of each column of a Matrix.
template<typename T , matrix_order O, matrix_style S>
Matrix< T, O, Concrete >	kurtosisc (const Matrix< T, O, S > &A)
template<typename T , matrix_order PO, matrix_style PS>
T	max (const Matrix< T, PO, PS > &A)
	Calculate the maximum element in a Matrix.
template<matrix_order RO, matrix_style RS, typename T , matrix_order PO, matrix_style PS>
Matrix< T, RO, RS >	maxc (const Matrix< T, PO, PS > &A)
	Calculate the maximum of each column of a Matrix.
template<typename T , matrix_order O, matrix_style S>
Matrix< T, O, Concrete >	maxc (const Matrix< T, O, S > &A)
template<typename T , matrix_order PO, matrix_style PS>
T	min (const Matrix< T, PO, PS > &A)
	Calculate the maximum element in a Matrix.
template<matrix_order RO, matrix_style RS, typename T , matrix_order PO, matrix_style PS>
Matrix< T, RO, RS >	minc (const Matrix< T, PO, PS > &A)
	Calculate the minimum of each column of a Matrix.
template<typename T , matrix_order O, matrix_style S>
Matrix< T, O, Concrete >	minc (const Matrix< T, O, S > &A)
template<typename T , matrix_order PO, matrix_style PS>
unsigned int	maxind (const Matrix< T, PO, PS > &A)
	Calculate the index of the maximum element in a Matrix.
template<matrix_order RO, matrix_style RS, typename T , matrix_order PO, matrix_style PS>
Matrix< T, RO, RS >	maxindc (const Matrix< T, PO, PS > &A)
	Calculate the index of the maximum for each column of a Matrix.
template<typename T , matrix_order O, matrix_style S>
Matrix< T, O, Concrete >	maxindc (const Matrix< T, O, S > &A)
template<typename T , matrix_order PO, matrix_style PS>
unsigned int	minind (const Matrix< T, PO, PS > &A)
	Calculate the index of the minimum element in a Matrix.
template<matrix_order RO, matrix_style RS, typename T , matrix_order PO, matrix_style PS>
Matrix< T, RO, RS >	minindc (const Matrix< T, PO, PS > &A)
	Calculate the index of the minimum for each column of a Matrix.
template<typename T , matrix_order O, matrix_style S>
Matrix< T, O, Concrete >	minindc (const Matrix< T, O, S > &A)
Variables
struct scythe::all_elements	_

Detailed Description

The Scythe library namespace.

All Scythe library declarations are defined within the scythe namespace. This prevents name clashing with other libraries' members or with declarations in users' program code.

Classes

Enumerations

Functions

Variables

Detailed Description