ALPSCore reference
Classes | Functions | Variables
alps::numeric Namespace Reference

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 >
sq (T value)
 
template<class T >
cb (T value)
 
template<class T >
cbrt (T value)
 
template<class T >
norm (T x, T y=T(), T z=T())
 
template<class 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 ( 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 ( 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 ( 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 ( 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 ( 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 ( 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 ( 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
rightthe 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 ( x,
y = 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 ( a,
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 ( a,
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,
index 
)

Definition at line 213 of file vector_functions.hpp.

template<class T >
T alps::numeric::r ( x,
y = T(),
z = T() 
)
inline

Definition at line 46 of file special_functions.hpp.

template<class T >
real_type<T>::type alps::numeric::real ( 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 ( 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