Classes
struct	divides

struct	divides< T, T, T >

struct	inf

struct	inf< alps::detail::type_wrapper< long double >::type >
	Class convertible to infinity of type alps::detail::type_wrapper<long double>::type.

struct	inf< boost::array< double, N > >

struct	inf< double >
	Class convertible to infinity of type double. More...

struct	inf< float >
	Class convertible to infinity of type float. More...

class	inf< std::vector< T > >
	Class convertible to std::vector<T> infinity. More...

struct	invert
	A service functor class for numerical inversion, to be used in transform() More...

struct	invert< std::vector< T > >
	Inversion for vectors, to be used in transform() More...

struct	minus

struct	minus< T, T, T >

struct	multiplies

struct	multiplies< T, T, T >

struct	negate
	"Imported" negation functor class (needed to define template specializations in this namespace) More...

struct	negate< std::vector< T > >
	Negation for vectors (specialization of the standard template, here to avoid changes in std::) More...

struct	plus

struct	plus< T, T, T >

struct	real_type

struct	real_type< std::complex< T > >

struct	real_type< std::vector< T > >

struct	scalar
	Metafunction returning "mathematical scalar" type for type T. More...

struct	scalar< std::complex< T > >
	Metafunction returning "mathematical scalar" type for a type: <complex<T>> specialization. More...

struct	unary_minus

Functions
template<typename T , std::size_t N>
boost::array< T, N > &	operator+= (boost::array< T, N > &lhs, boost::array< T, N > const &rhs)

template<typename T , std::size_t N>
boost::array< T, N > &	operator-= (boost::array< T, N > &lhs, boost::array< T, N > const &rhs)

template<typename T , std::size_t N>
boost::array< T, N > &	operator*= (boost::array< T, N > &lhs, boost::array< T, N > const &rhs)

template<typename T , std::size_t N>
boost::array< T, N > &	operator/= (boost::array< T, N > &lhs, boost::array< T, N > const &rhs)

template<typename T , std::size_t N>
boost::array< T, N >	operator- (boost::array< T, N > lhs)

template<typename T , typename U , std::size_t N>
boost::array< T, N >	operator+ (boost::array< T, N > lhs, boost::array< U, N > const &rhs)

template<typename T , std::size_t N>
boost::array< T, N >	operator+ (boost::array< T, N > arg, T const &scalar)

template<typename T , std::size_t N>
boost::array< T, N >	operator+ (T const &scalar, boost::array< T, N > arg)

template<typename T , typename U , std::size_t N>
boost::array< T, N >	operator- (boost::array< T, N > lhs, boost::array< U, N > const &rhs)

template<typename T , std::size_t N>
boost::array< T, N >	operator- (boost::array< T, N > arg, T const &scalar)

template<typename T , std::size_t N>
boost::array< T, N >	operator- (T const &scalar, boost::array< T, N > arg)

template<typename T , typename U , std::size_t N>
boost::array< T, N >	operator* (boost::array< T, N > lhs, boost::array< U, N > const &rhs)

template<typename T , typename U , std::size_t N>
boost::array< T, N >	operator/ (boost::array< T, N > lhs, boost::array< U, N > const &rhs)

template<typename T , std::size_t N>
boost::array< T, N >	operator* (boost::array< T, N > lhs, T const &scalar)

template<typename T , std::size_t N>
boost::array< T, N >	operator* (T const &scalar, boost::array< T, N > rhs)

template<typename T , std::size_t N>
boost::array< T, N >	operator/ (boost::array< T, N > lhs, T const &scalar)

template<typename T , std::size_t N>
boost::array< T, N >	operator/ (T const &scalar, boost::array< T, N > rhs)

template<typename T , std::size_t N>
boost::array< T, N >	sin (boost::array< T, N > arg)

template<typename T , std::size_t N>
boost::array< T, N >	cos (boost::array< T, N > arg)

template<typename T , std::size_t N>
boost::array< T, N >	tan (boost::array< T, N > arg)

template<typename T , std::size_t N>
boost::array< T, N >	sinh (boost::array< T, N > arg)

template<typename T , std::size_t N>
boost::array< T, N >	cosh (boost::array< T, N > arg)

template<typename T , std::size_t N>
boost::array< T, N >	tanh (boost::array< T, N > arg)

template<typename T , std::size_t N>
boost::array< T, N >	asin (boost::array< T, N > arg)

template<typename T , std::size_t N>
boost::array< T, N >	acos (boost::array< T, N > arg)

template<typename T , std::size_t N>
boost::array< T, N >	atan (boost::array< T, N > arg)

template<typename T , std::size_t N>
boost::array< T, N >	abs (boost::array< T, N > arg)

template<typename T , std::size_t N>
boost::array< T, N >	sqrt (boost::array< T, N > arg)

template<typename T , std::size_t N>
boost::array< T, N >	exp (boost::array< T, N > arg)

template<typename T , std::size_t N>
boost::array< T, N >	log (boost::array< T, N > arg)

template<typename T , std::size_t N>
boost::array< T, N >	sq (boost::array< T, N > arg)

template<typename T , std::size_t N>
boost::array< T, N >	cb (boost::array< T, N > arg)

template<typename T , std::size_t N>
boost::array< T, N >	cbrt (boost::array< T, N > arg)

template<typename T , typename U >
void	check_size (T &, U const &)

template<typename T , typename U >
void	check_size (std::vector< T > &a, std::vector< U > const &b)

template<typename T , typename U , std::size_t N, std::size_t M>
void	check_size (boost::array< T, N > &a, boost::array< U, M > const &b)

template<typename T , typename U , std::size_t N>
void	check_size (boost::array< T, N > &a, boost::array< U, N > const &b)

template<class T >
std::enable_if<!is_sequence< T >::value, T >::type	checked_divide (const T &a, const T &b)

template<class T >
std::enable_if< is_sequence< T >::value, T >::type	checked_divide (T a, const T &b)

template<unsigned int N, class T >
bool	is_zero (T x, typename std::enable_if< std::is_arithmetic< T >::value >::type =0, typename std::enable_if< std::is_float< T >::value >::type =0)
	checks if a number is zero in case of a floating point number, absolute values less than epsilon (1e-50 by default) count as zero More...

template<unsigned int N, class T >
bool	is_zero (T x, typename std::enable_if< std::is_arithmetic< T >::value >::type =0, typename std::enable_if< std::is_integral< T >::value >::type =0)

template<unsigned int N, class T >
bool	is_zero (const T &x, typename std::enable_if<!std::is_arithmetic< T >::value >::type *=0)

template<class T >
bool	is_zero (T x, typename std::enable_if< std::is_arithmetic< T >::value >::type =0, typename std::enable_if< std::is_float< T >::value >::type =0)

template<class T >
bool	is_zero (T x, typename std::enable_if< std::is_arithmetic< T >::value >::type =0, typename std::enable_if< std::is_integral< T >::value >::type =0)

template<class T >
bool	is_zero (const T &x, typename std::enable_if<!std::is_arithmetic< T >::value >::type *=0)

template<class T >
bool	is_zero (const std::complex< T > &x)

template<class T >
std::enable_if<!is_sequence< T >::value, typename covariance_type< T >::type >::type	outer_product (T a, T b)

template<class T >
std::complex< T >	outer_product (std::complex< T > const &a, std::complex< T > const &b)

template<class T >
std::enable_if< is_sequence< T >::value, typename covariance_type< T >::type >::type	outer_product (T a, T b)

template<class T >
real_type< T >::type	real (T x)

template<typename T >
void	rectangularize (const T &)
	Make sure that vector-of-vectors is a rectangular matrix (generic dummy template) More...

template<typename T >
void	rectangularize (std::vector< std::vector< T > > &vec)
	Make sure that vector-of-vectors is a rectangular matrix. More...

template<class T >
std::enable_if<!is_sequence< T >::value, void >::type	set_negative_0 (T &x)

template<class T >
void	set_negative_0 (std::complex< T > &x)

template<class T >
std::enable_if< is_sequence< T >::value, void >::type	set_negative_0 (T &a)

template<class T >
T	sq (T value)

template<class T >
T	cb (T value)

template<class T >
T	cbrt (T value)

template<class T >
T	norm (T x, T y=T(), T z=T())

template<class T >
T	r (T x, T y=T(), T z=T())

template<typename T >
std::vector< T >	sq (std::vector< T > vec)

template<typename T >
std::vector< T >	cb (std::vector< T > vec)

template<typename T >
std::vector< T >	cbrt (std::vector< T > vec)

template<typename T >
std::vector< T >	asinh (std::vector< T > vec)

template<typename T >
std::vector< T >	acosh (std::vector< T > vec)

template<typename T >
std::vector< T >	atanh (std::vector< T > vec)

template<typename T >
std::vector< T >	operator- (std::vector< T > lhs)
	Unary negation of a vector. More...

template<typename T , typename U >
std::vector< T >	operator+ (std::vector< T > const &lhs, std::vector< U > const &rhs)
	Sum of two vectors. Note: Treats a default-initialized vector (size 0) as 0-vector. More...

template<typename T , typename U >
std::vector< T >	operator- (std::vector< T > const &lhs, std::vector< U > const &rhs)
	Difference of two vectors. Note: Treats a default-initialized vector (size 0) as 0-vector. More...

template<typename T , typename U >
std::vector< T >	operator* (std::vector< T > const &lhs, std::vector< U > const &rhs)
	By-element product of two vectors. Note: Treats a default-initialized vector (size 0) as 0-vector. More...

template<typename T , typename U >
std::vector< T >	operator/ (std::vector< T > const &lhs, std::vector< U > const &rhs)
	By-element quotient of two vectors. Note: Treats a default-initialized vector (size 0) as 0-vector. More...

template<typename T >
std::vector< T >	operator+ (T const &scalar, std::vector< T > rhs)
	Sum of a scalar and a vector. More...

template<typename T >
std::vector< T >	operator+ (std::vector< T > lhs, T const &scalar)
	Sum of a vector and a scalar. More...

template<typename T >
std::vector< T >	operator- (T const &scalar, std::vector< T > const &rhs)
	Difference of a scalar and a vector. More...

template<typename T >
std::vector< T >	operator- (std::vector< T > const &lhs, T const &scalar)
	Difference of a vector and a scalar. More...

template<typename T >
std::vector< T >	operator* (std::vector< T > const &lhs, T const &scalar)
	Returns a vector scaled by a scalar. More...

template<typename T >
std::vector< T >	operator* (T const &scalar, std::vector< T > const &rhs)
	Returns a vector scaled by a scalar. More...

template<typename T >
std::vector< T >	operator/ (std::vector< T > const &lhs, T const &scalar)
	Returns a vector divided scaled by a scalar. More...

template<typename T >
std::vector< T >	operator/ (T const &scalar, std::vector< T > rhs)
	Returns a vector with elements inverted and scaled by a scalar. More...

template<typename T >
std::vector< T >	sin (std::vector< T > arg)

template<typename T >
std::vector< T >	cos (std::vector< T > arg)

template<typename T >
std::vector< T >	tan (std::vector< T > arg)

template<typename T >
std::vector< T >	sinh (std::vector< T > arg)

template<typename T >
std::vector< T >	cosh (std::vector< T > arg)

template<typename T >
std::vector< T >	tanh (std::vector< T > arg)

template<typename T >
std::vector< T >	asin (std::vector< T > arg)

template<typename T >
std::vector< T >	acos (std::vector< T > arg)

template<typename T >
std::vector< T >	atan (std::vector< T > arg)

template<typename T >
std::vector< T >	abs (std::vector< T > arg)

template<typename T >
std::vector< T >	sqrt (std::vector< T > arg)

template<typename T >
std::vector< T >	exp (std::vector< T > arg)

template<typename T >
std::vector< T >	log (std::vector< T > arg)

template<typename T , typename U >
std::vector< T >	pow (std::vector< T > vec, U index)

template<typename T >
std::vector< T > &	operator+= (std::vector< T > &lhs, std::vector< T > const &rhs)

template<typename T >
std::vector< T > &	operator-= (std::vector< T > &lhs, std::vector< T > const &rhs)

template<typename T >
std::vector< T > &	operator*= (std::vector< T > &lhs, std::vector< T > const &rhs)

template<typename T >
std::vector< T > &	operator/= (std::vector< T > &lhs, std::vector< T > const &rhs)

template<typename T >
std::vector< T > &	merge (std::vector< T > &left, const std::vector< T > &right)
	Vector merge. More...

Variables
template<class T >
real_type< T >::type	real (T)

Function Documentation

template<typename T , std::size_t N>

boost::array<T, N> alps::numeric::abs ( boost::array< T, N > arg )

Definition at line 155 of file boost_array_functions.hpp.

template<typename T >

std::vector<T> alps::numeric::abs ( std::vector< T > arg )

Definition at line 206 of file vector_functions.hpp.

template<typename T , std::size_t N>

boost::array<T, N> alps::numeric::acos ( boost::array< T, N > arg )

Definition at line 153 of file boost_array_functions.hpp.

template<typename T >

std::vector<T> alps::numeric::acos ( std::vector< T > arg )

Definition at line 204 of file vector_functions.hpp.

template<typename T >

std::vector<T> alps::numeric::acosh ( std::vector< T > vec )

Definition at line 67 of file vector_functions.hpp.

template<typename T , std::size_t N>

boost::array<T, N> alps::numeric::asin ( boost::array< T, N > arg )

Definition at line 152 of file boost_array_functions.hpp.

template<typename T >

std::vector<T> alps::numeric::asin ( std::vector< T > arg )

Definition at line 203 of file vector_functions.hpp.

template<typename T >

std::vector<T> alps::numeric::asinh ( std::vector< T > vec )

Definition at line 66 of file vector_functions.hpp.

template<typename T , std::size_t N>

boost::array<T, N> alps::numeric::atan ( boost::array< T, N > arg )

Definition at line 154 of file boost_array_functions.hpp.

template<typename T >

std::vector<T> alps::numeric::atan ( std::vector< T > arg )

Definition at line 205 of file vector_functions.hpp.

template<typename T >

std::vector<T> alps::numeric::atanh ( std::vector< T > vec )

Definition at line 68 of file vector_functions.hpp.

template<class T >

T alps::numeric::cb ( T value )

inline

Definition at line 28 of file special_functions.hpp.

template<typename T >

std::vector<T> alps::numeric::cb ( std::vector< T > vec )

Definition at line 53 of file vector_functions.hpp.

template<typename T , std::size_t N>

boost::array<T, N> alps::numeric::cb ( boost::array< T, N > arg )

Definition at line 170 of file boost_array_functions.hpp.

template<class T >

T alps::numeric::cbrt ( T value )

inline

Definition at line 34 of file special_functions.hpp.

template<typename T >

std::vector<T> alps::numeric::cbrt ( std::vector< T > vec )

Definition at line 54 of file vector_functions.hpp.

template<typename T , std::size_t N>

boost::array<T, N> alps::numeric::cbrt ( boost::array< T, N > arg )

Definition at line 171 of file boost_array_functions.hpp.

template<typename T , typename U >

void alps::numeric::check_size	(	T &	,
		U const &
	)

inline

Definition at line 40 of file check_size.hpp.

template<typename T , typename U >

void alps::numeric::check_size	(	std::vector< T > &	a,
		std::vector< U > const &	b
	)

inline

Definition at line 43 of file check_size.hpp.

template<typename T , typename U , std::size_t N, std::size_t M>

void alps::numeric::check_size	(	boost::array< T, N > &	a,
		boost::array< U, M > const &	b
	)

inline

Definition at line 51 of file check_size.hpp.

template<typename T , typename U , std::size_t N>

void alps::numeric::check_size	(	boost::array< T, N > &	a,
		boost::array< U, N > const &	b
	)

inline

Definition at line 56 of file check_size.hpp.

template<class T >

std::enable_if<!is_sequence<T>::value,T>::type alps::numeric::checked_divide	(	const T &	a,
		const T &	b
	)

inline

Definition at line 22 of file checked_divide.hpp.

template<class T >

std::enable_if<is_sequence<T>::value,T>::type alps::numeric::checked_divide	(	T	a,
		const T &	b
	)

inline

Definition at line 29 of file checked_divide.hpp.

template<typename T , std::size_t N>

boost::array<T, N> alps::numeric::cos ( boost::array< T, N > arg )

Definition at line 147 of file boost_array_functions.hpp.

template<typename T >

std::vector<T> alps::numeric::cos ( std::vector< T > arg )

Definition at line 198 of file vector_functions.hpp.

template<typename T , std::size_t N>

boost::array<T, N> alps::numeric::cosh ( boost::array< T, N > arg )

Definition at line 150 of file boost_array_functions.hpp.

template<typename T >

std::vector<T> alps::numeric::cosh ( std::vector< T > arg )

Definition at line 201 of file vector_functions.hpp.

template<typename T , std::size_t N>

boost::array<T, N> alps::numeric::exp ( boost::array< T, N > arg )

Definition at line 157 of file boost_array_functions.hpp.

template<typename T >

std::vector<T> alps::numeric::exp ( std::vector< T > arg )

Definition at line 208 of file vector_functions.hpp.

template<unsigned int N, class T >

bool alps::numeric::is_zero	(	T	x,
		typename std::enable_if< std::is_arithmetic< T >::value >::type *	= `0`,
		typename std::enable_if< std::is_float< T >::value >::type *	= `0`
	)

inline

checks if a number is zero in case of a floating point number, absolute values less than epsilon (1e-50 by default) count as zero

Returns: returns true if the value is zero

Definition at line 54 of file is_zero.hpp.

template<unsigned int N, class T >

bool alps::numeric::is_zero	(	T	x,
		typename std::enable_if< std::is_arithmetic< T >::value >::type *	= `0`,
		typename std::enable_if< std::is_integral< T >::value >::type *	= `0`
	)

inline

Definition at line 59 of file is_zero.hpp.

template<unsigned int N, class T >

bool alps::numeric::is_zero	(	const T &	x,
		typename std::enable_if<!std::is_arithmetic< T >::value >::type *	= `0`
	)

inline

Definition at line 81 of file is_zero.hpp.

template<class T >

bool alps::numeric::is_zero	(	T	x,
		typename std::enable_if< std::is_arithmetic< T >::value >::type *	= `0`,
		typename std::enable_if< std::is_float< T >::value >::type *	= `0`
	)

inline

Definition at line 86 of file is_zero.hpp.

template<class T >

bool alps::numeric::is_zero	(	T	x,
		typename std::enable_if< std::is_arithmetic< T >::value >::type *	= `0`,
		typename std::enable_if< std::is_integral< T >::value >::type *	= `0`
	)

inline

Definition at line 91 of file is_zero.hpp.

template<class T >

bool alps::numeric::is_zero	(	const T &	x,
		typename std::enable_if<!std::is_arithmetic< T >::value >::type *	= `0`
	)

inline

Definition at line 96 of file is_zero.hpp.

template<class T >

bool alps::numeric::is_zero ( const std::complex< T > & x )

inline

Definition at line 100 of file is_zero.hpp.

template<typename T , std::size_t N>

boost::array<T, N> alps::numeric::log ( boost::array< T, N > arg )

Definition at line 158 of file boost_array_functions.hpp.

template<typename T >

std::vector<T> alps::numeric::log ( std::vector< T > arg )

Definition at line 209 of file vector_functions.hpp.

template<typename T >

std::vector<T>& alps::numeric::merge	(	std::vector< T > &	left,
		const std::vector< T > &	right
	)

Vector merge.

Adds two vectors, possibly of different length, extending longer one with zeros to the right. Addition uses operator+, therefore element lengths must match.

Parameters

left	: the vector to be added to
right	the vector to add

Returns: the reference to the (modified) left vector

Definition at line 355 of file vector_functions.hpp.

template<class T >

T alps::numeric::norm	(	T	x,
		T	y = `T()`,
		T	z = `T()`
	)

inline

Definition at line 40 of file special_functions.hpp.

template<typename T , typename U , std::size_t N>

boost::array<T, N> alps::numeric::operator*	(	boost::array< T, N >	lhs,
		boost::array< U, N > const &	rhs
	)

Definition at line 101 of file boost_array_functions.hpp.

template<typename T , std::size_t N>

boost::array<T, N> alps::numeric::operator*	(	boost::array< T, N >	lhs,
		T const &	scalar
	)

Definition at line 116 of file boost_array_functions.hpp.

template<typename T , typename U >

std::vector<T> alps::numeric::operator*	(	std::vector< T > const &	lhs,
		std::vector< U > const &	rhs
	)

By-element product of two vectors. Note: Treats a default-initialized vector (size 0) as 0-vector.

Definition at line 120 of file vector_functions.hpp.

template<typename T , std::size_t N>

boost::array<T, N> alps::numeric::operator*	(	T const &	scalar,
		boost::array< T, N >	rhs
	)

Definition at line 121 of file boost_array_functions.hpp.

template<typename T >

std::vector<T> alps::numeric::operator*	(	std::vector< T > const &	lhs,
		T const &	scalar
	)

Returns a vector scaled by a scalar.

Definition at line 165 of file vector_functions.hpp.

template<typename T >

std::vector<T> alps::numeric::operator*	(	T const &	scalar,
		std::vector< T > const &	rhs
	)

Returns a vector scaled by a scalar.

Definition at line 171 of file vector_functions.hpp.

template<typename T , std::size_t N>

boost::array<T, N>& alps::numeric::operator*=	(	boost::array< T, N > &	lhs,
		boost::array< T, N > const &	rhs
	)

Definition at line 40 of file boost_array_functions.hpp.

template<typename T >

std::vector<T>& alps::numeric::operator*=	(	std::vector< T > &	lhs,
		std::vector< T > const &	rhs
	)

Definition at line 341 of file vector_functions.hpp.

template<typename T , typename U , std::size_t N>

boost::array<T, N> alps::numeric::operator+	(	boost::array< T, N >	lhs,
		boost::array< U, N > const &	rhs
	)

Definition at line 65 of file boost_array_functions.hpp.

template<typename T , std::size_t N>

boost::array<T, N> alps::numeric::operator+	(	boost::array< T, N >	arg,
		T const &	scalar
	)

Definition at line 71 of file boost_array_functions.hpp.

template<typename T , std::size_t N>

boost::array<T, N> alps::numeric::operator+	(	T const &	scalar,
		boost::array< T, N >	arg
	)

Definition at line 76 of file boost_array_functions.hpp.

template<typename T , typename U >

std::vector<T> alps::numeric::operator+	(	std::vector< T > const &	lhs,
		std::vector< U > const &	rhs
	)

Sum of two vectors. Note: Treats a default-initialized vector (size 0) as 0-vector.

Definition at line 100 of file vector_functions.hpp.

template<typename T >

std::vector<T> alps::numeric::operator+	(	T const &	scalar,
		std::vector< T >	rhs
	)

Sum of a scalar and a vector.

Definition at line 139 of file vector_functions.hpp.

template<typename T >

std::vector<T> alps::numeric::operator+	(	std::vector< T >	lhs,
		T const &	scalar
	)

Sum of a vector and a scalar.

Definition at line 145 of file vector_functions.hpp.

template<typename T , std::size_t N>

boost::array<T, N>& alps::numeric::operator+=	(	boost::array< T, N > &	lhs,
		boost::array< T, N > const &	rhs
	)

Definition at line 38 of file boost_array_functions.hpp.

template<typename T >

std::vector<T>& alps::numeric::operator+=	(	std::vector< T > &	lhs,
		std::vector< T > const &	rhs
	)

Definition at line 339 of file vector_functions.hpp.

template<typename T , std::size_t N>

boost::array<T, N> alps::numeric::operator- ( boost::array< T, N > lhs )

Definition at line 58 of file boost_array_functions.hpp.

template<typename T , typename U , std::size_t N>

boost::array<T, N> alps::numeric::operator-	(	boost::array< T, N >	lhs,
		boost::array< U, N > const &	rhs
	)

Definition at line 83 of file boost_array_functions.hpp.

template<typename T , std::size_t N>

boost::array<T, N> alps::numeric::operator-	(	boost::array< T, N >	arg,
		T const &	scalar
	)

Definition at line 89 of file boost_array_functions.hpp.

template<typename T >

std::vector<T> alps::numeric::operator- ( std::vector< T > lhs )

Unary negation of a vector.

Definition at line 92 of file vector_functions.hpp.

template<typename T , std::size_t N>

boost::array<T, N> alps::numeric::operator-	(	T const &	scalar,
		boost::array< T, N >	arg
	)

Definition at line 94 of file boost_array_functions.hpp.

template<typename T , typename U >

std::vector<T> alps::numeric::operator-	(	std::vector< T > const &	lhs,
		std::vector< U > const &	rhs
	)

Difference of two vectors. Note: Treats a default-initialized vector (size 0) as 0-vector.

Definition at line 110 of file vector_functions.hpp.

template<typename T >

std::vector<T> alps::numeric::operator-	(	T const &	scalar,
		std::vector< T > const &	rhs
	)

Difference of a scalar and a vector.

Definition at line 153 of file vector_functions.hpp.

template<typename T >

std::vector<T> alps::numeric::operator-	(	std::vector< T > const &	lhs,
		T const &	scalar
	)

Difference of a vector and a scalar.

Definition at line 158 of file vector_functions.hpp.

template<typename T , std::size_t N>

boost::array<T, N>& alps::numeric::operator-=	(	boost::array< T, N > &	lhs,
		boost::array< T, N > const &	rhs
	)

Definition at line 39 of file boost_array_functions.hpp.

template<typename T >

std::vector<T>& alps::numeric::operator-=	(	std::vector< T > &	lhs,
		std::vector< T > const &	rhs
	)

Definition at line 340 of file vector_functions.hpp.

template<typename T , typename U , std::size_t N>

boost::array<T, N> alps::numeric::operator/	(	boost::array< T, N >	lhs,
		boost::array< U, N > const &	rhs
	)

Definition at line 108 of file boost_array_functions.hpp.

template<typename T , std::size_t N>

boost::array<T, N> alps::numeric::operator/	(	boost::array< T, N >	lhs,
		T const &	scalar
	)

Definition at line 128 of file boost_array_functions.hpp.

template<typename T , typename U >

std::vector<T> alps::numeric::operator/	(	std::vector< T > const &	lhs,
		std::vector< U > const &	rhs
	)

By-element quotient of two vectors. Note: Treats a default-initialized vector (size 0) as 0-vector.

Definition at line 129 of file vector_functions.hpp.

template<typename T , std::size_t N>

boost::array<T, N> alps::numeric::operator/	(	T const &	scalar,
		boost::array< T, N >	rhs
	)

Definition at line 133 of file boost_array_functions.hpp.

template<typename T >

std::vector<T> alps::numeric::operator/	(	std::vector< T > const &	lhs,
		T const &	scalar
	)

Returns a vector divided scaled by a scalar.

Definition at line 178 of file vector_functions.hpp.

template<typename T >

std::vector<T> alps::numeric::operator/	(	T const &	scalar,
		std::vector< T >	rhs
	)

Returns a vector with elements inverted and scaled by a scalar.

Definition at line 184 of file vector_functions.hpp.

template<typename T , std::size_t N>

boost::array<T, N>& alps::numeric::operator/=	(	boost::array< T, N > &	lhs,
		boost::array< T, N > const &	rhs
	)

Definition at line 41 of file boost_array_functions.hpp.

template<typename T >

std::vector<T>& alps::numeric::operator/=	(	std::vector< T > &	lhs,
		std::vector< T > const &	rhs
	)

Definition at line 342 of file vector_functions.hpp.

template<class T >

std::enable_if<!is_sequence<T>::value,typename covariance_type<T>::type>::type alps::numeric::outer_product	(	T	a,
		T	b
	)

inline

Definition at line 23 of file outer_product.hpp.

template<class T >

std::complex<T> alps::numeric::outer_product	(	std::complex< T > const &	a,
		std::complex< T > const &	b
	)

inline

Definition at line 30 of file outer_product.hpp.

template<class T >

std::enable_if<is_sequence<T>::value,typename covariance_type<T>::type>::type alps::numeric::outer_product	(	T	a,
		T	b
	)

inline

Definition at line 39 of file outer_product.hpp.

template<typename T , typename U >

std::vector<T> alps::numeric::pow	(	std::vector< T >	vec,
		U	index
	)

Definition at line 213 of file vector_functions.hpp.

template<class T >

T alps::numeric::r	(	T	x,
		T	y = `T()`,
		T	z = `T()`
	)

inline

Definition at line 46 of file special_functions.hpp.

template<class T >

real_type<T>::type alps::numeric::real ( T x )

inline

Definition at line 133 of file real.hpp.

template<typename T >

void alps::numeric::rectangularize ( const T & )

Make sure that vector-of-vectors is a rectangular matrix (generic dummy template)

Definition at line 21 of file rectangularize.hpp.

template<typename T >

void alps::numeric::rectangularize ( std::vector< std::vector< T > > & vec )

Make sure that vector-of-vectors is a rectangular matrix.

Converts an uneven vector-of-vectors to a rectangular matrix, resizing rows as needed (that is, right-padding the rows with 0)

Note: Does not work with 3-tensors.

Definition at line 30 of file rectangularize.hpp.

template<class T >

std::enable_if<!is_sequence<T>::value,void>::type alps::numeric::set_negative_0 ( T & x )

inline

Definition at line 20 of file set_negative_0.hpp.

template<class T >

void alps::numeric::set_negative_0 ( std::complex< T > & x )

inline

Definition at line 27 of file set_negative_0.hpp.

template<class T >

std::enable_if<is_sequence<T>::value,void>::type alps::numeric::set_negative_0 ( T & a )

inline

Definition at line 35 of file set_negative_0.hpp.

template<typename T , std::size_t N>

boost::array<T, N> alps::numeric::sin ( boost::array< T, N > arg )

Definition at line 146 of file boost_array_functions.hpp.

template<typename T >

std::vector<T> alps::numeric::sin ( std::vector< T > arg )

Definition at line 197 of file vector_functions.hpp.

template<typename T , std::size_t N>

boost::array<T, N> alps::numeric::sinh ( boost::array< T, N > arg )

Definition at line 149 of file boost_array_functions.hpp.

template<typename T >

std::vector<T> alps::numeric::sinh ( std::vector< T > arg )

Definition at line 200 of file vector_functions.hpp.

template<class T >

T alps::numeric::sq ( T value )

inline

Definition at line 22 of file special_functions.hpp.

template<typename T >

std::vector<T> alps::numeric::sq ( std::vector< T > vec )

Definition at line 51 of file vector_functions.hpp.

template<typename T , std::size_t N>

boost::array<T, N> alps::numeric::sq ( boost::array< T, N > arg )

Definition at line 169 of file boost_array_functions.hpp.

template<typename T , std::size_t N>

boost::array<T, N> alps::numeric::sqrt ( boost::array< T, N > arg )

Definition at line 156 of file boost_array_functions.hpp.

template<typename T >

std::vector<T> alps::numeric::sqrt ( std::vector< T > arg )

Definition at line 207 of file vector_functions.hpp.

template<typename T , std::size_t N>

boost::array<T, N> alps::numeric::tan ( boost::array< T, N > arg )

Definition at line 148 of file boost_array_functions.hpp.

template<typename T >

std::vector<T> alps::numeric::tan ( std::vector< T > arg )

Definition at line 199 of file vector_functions.hpp.

template<typename T , std::size_t N>

boost::array<T, N> alps::numeric::tanh ( boost::array< T, N > arg )

Definition at line 151 of file boost_array_functions.hpp.

template<typename T >

std::vector<T> alps::numeric::tanh ( std::vector< T > arg )

Definition at line 202 of file vector_functions.hpp.

Variable Documentation

template<class T >

real_type<T>::type alps::numeric::real(T)

inline

Classes

Functions

Variables

Function Documentation

Variable Documentation