lambda_lanczos::util Namespace Reference

Classes
class	TupleViewIterator
	Iterator for a container of tuples to iterate over the I-th tuple elements. More...
class	MapValueIterable
struct	realTypeMap
	Template class to map specific types. See real_t<T> for usage. More...
struct	realTypeMap< std::complex< T > >
struct	TypedConjugate
	Complex conjugate template. More...
struct	TypedConjugate< std::complex< T > >
struct	ManhattanNorm
struct	ManhattanNorm< std::complex< T > >

Typedefs
template<typename map_type>
using	MapValueIterator = TupleViewIterator<1, map_type>
	Iterator for a map to iterate over its values.
template<typename T>
using	real_t = typename realTypeMap<T>::type
	Type mapper from T to real type of T.

Functions
template<typename T>
T	typed_conj (const T &val)
	Complex conjugate with type. This function returns the argument itself for real type, and returns its complex conjugate for complex type.
template<typename T>
void	sort_eigenpairs (std::vector< real_t< T > > &eigenvalues, std::vector< std::vector< T > > &eigenvectors, bool sort_eigenvector, const std::function< bool(real_t< T >, real_t< T >)> predicate=std::less< real_t< T > >())
	Sorts eigenvalues and eigenvectors with respect to given predicate.
template<typename T>
constexpr int	sig_decimal_digit ()
	Returns the significant decimal digits of type T.
template<typename T>
constexpr T	minimum_effective_decimal ()
template<typename T>
T	sgn (T val)
	Return the sign of given value.
template<typename T>
std::string	vectorToString (const std::vector< T > &vec, std::string delimiter=" ")
	Returns string representation of given vector.
template<typename T>
T	inner_prod (const std::vector< T > &v1, const std::vector< T > &v2)
	Returns "mathematical" inner product of v1 and v2.
template<typename T>
real_t< T >	norm (const std::vector< T > &vec)
	Returns Euclidean norm of given vector.
template<typename T1, typename T2>
void	scalar_mul (T1 a, std::vector< T2 > &vec)
	Multiplies each element of vec by a.
template<typename T>
void	normalize (std::vector< T > &vec)
	Normalizes given vector.
template<typename T>
real_t< T >	m_norm (const std::vector< T > &vec)
	Returns Manhattan-like norm of given vector.
template<typename ForwardIterator, typename T>
void	schmidt_orth (std::vector< T > &uorth, ForwardIterator first, ForwardIterator last)
	Orthogonalizes vector uorth with respect to orthonormal vectors defined by given iterators.
template<typename T>
void	initAsIdentity (std::vector< std::vector< T > > &a, size_t n)
	Initializes the given matrix a to an n by n identity matrix.
float	inner_prod (const std::vector< float > &v1, const std::vector< float > &v2)
double	inner_prod (const std::vector< double > &v1, const std::vector< double > &v2)
std::complex< float >	inner_prod (const std::vector< std::complex< float > > &v1, const std::vector< std::complex< float > > &v2)
std::complex< double >	inner_prod (const std::vector< std::complex< double > > &v1, const std::vector< std::complex< double > > &v2)
float	norm (const std::vector< float > &vec)
double	norm (const std::vector< double > &vec)
float	norm (const std::vector< std::complex< float > > &vec)
double	norm (const std::vector< std::complex< double > > &vec)
void	scalar_mul (float a, std::vector< float > &vec)
void	scalar_mul (double a, std::vector< double > &vec)
void	scalar_mul (std::complex< float > a, std::vector< std::complex< float > > &vec)
void	scalar_mul (std::complex< double > a, std::vector< std::complex< double > > &vec)
void	scalar_mul (float a, std::vector< std::complex< float > > &vec)
void	scalar_mul (double a, std::vector< std::complex< double > > &vec)
float	m_norm (const std::vector< float > &vec)
double	m_norm (const std::vector< double > &vec)
float	m_norm (const std::vector< std::complex< float > > &vec)
double	m_norm (const std::vector< std::complex< double > > &vec)
template<typename ForwardIterator>
void	schmidt_orth (std::vector< float > &uorth, ForwardIterator first, ForwardIterator last)
template<typename ForwardIterator>
void	schmidt_orth (std::vector< double > &uorth, ForwardIterator first, ForwardIterator last)
template<typename ForwardIterator>
void	schmidt_orth (std::vector< std::complex< float > > &uorth, ForwardIterator first, ForwardIterator last)
template<typename ForwardIterator>
void	schmidt_orth (std::vector< std::complex< double > > &uorth, ForwardIterator first, ForwardIterator last)

Typedef Documentation

MapValueIterator

template<typename map_type>

using lambda_lanczos::util::MapValueIterator = TupleViewIterator<1, map_type>

Iterator for a map to iterate over its values.

real_t

template<typename T>

using lambda_lanczos::util::real_t = typename realTypeMap<T>::type

Type mapper from T to real type of T.

By default, real_t<T> returns T. However real_t<complex<T>> returns T. Usage example: This function returns a real number even if T is complex:

template <typename T>
inline real_t<T> norm(const std::vector<T>& vec);

Function Documentation

initAsIdentity()

template<typename T>

void lambda_lanczos::util::initAsIdentity	(	std::vector< std::vector< T > > &	a,
		size_t	n )

Initializes the given matrix a to an n by n identity matrix.

inner_prod() [1/5]

double lambda_lanczos::util::inner_prod ( const std::vector< double > & v1, const std::vector< double > & v2 )

inline

inner_prod() [2/5]

float lambda_lanczos::util::inner_prod ( const std::vector< float > & v1, const std::vector< float > & v2 )

inline

inner_prod() [3/5]

std::complex< double > lambda_lanczos::util::inner_prod ( const std::vector< std::complex< double > > & v1, const std::vector< std::complex< double > > & v2 )

inline

inner_prod() [4/5]

std::complex< float > lambda_lanczos::util::inner_prod ( const std::vector< std::complex< float > > & v1, const std::vector< std::complex< float > > & v2 )

inline

inner_prod() [5/5]

template<typename T>

T lambda_lanczos::util::inner_prod ( const std::vector< T > & v1, const std::vector< T > & v2 )

inline

Returns "mathematical" inner product of v1 and v2.

This function is needed because std::inner_product calculates transpose(v1)*v2 instead of dagger(v1)*v2 for complex type.

m_norm() [1/5]

double lambda_lanczos::util::m_norm ( const std::vector< double > & vec )

inline

m_norm() [2/5]

float lambda_lanczos::util::m_norm ( const std::vector< float > & vec )

inline

m_norm() [3/5]

double lambda_lanczos::util::m_norm ( const std::vector< std::complex< double > > & vec )

inline

m_norm() [4/5]

float lambda_lanczos::util::m_norm ( const std::vector< std::complex< float > > & vec )

inline

m_norm() [5/5]

template<typename T>

real_t< T > lambda_lanczos::util::m_norm ( const std::vector< T > & vec )

inline

Returns Manhattan-like norm of given vector.

Note

For a real vector {r_i}, returned value is sum_i |r_i|, i.e. the L1 norm in mathematical definition. For a complex vector {c_i}, returned value is sum_i |Re(c_i)| + |Im(c_i)|, instead of sum_i sqrt(Re(c_i)^2 + Im(c_i)^2) in mathematical definition. This definition can avoid sqrt calculations and is also implemented as _ASUM routines in BLAS.

minimum_effective_decimal()

template<typename T>

T lambda_lanczos::util::minimum_effective_decimal ( )

inlineconstexpr

norm() [1/5]

double lambda_lanczos::util::norm ( const std::vector< double > & vec )

inline

norm() [2/5]

float lambda_lanczos::util::norm ( const std::vector< float > & vec )

inline

norm() [3/5]

double lambda_lanczos::util::norm ( const std::vector< std::complex< double > > & vec )

inline

norm() [4/5]

float lambda_lanczos::util::norm ( const std::vector< std::complex< float > > & vec )

inline

norm() [5/5]

template<typename T>

real_t< T > lambda_lanczos::util::norm ( const std::vector< T > & vec )

inline

Returns Euclidean norm of given vector.

normalize()

template<typename T>

void lambda_lanczos::util::normalize ( std::vector< T > & vec )

inline

Normalizes given vector.

scalar_mul() [1/7]

void lambda_lanczos::util::scalar_mul ( double a, std::vector< double > & vec )

inline

scalar_mul() [2/7]

void lambda_lanczos::util::scalar_mul ( double a, std::vector< std::complex< double > > & vec )

inline

scalar_mul() [3/7]

void lambda_lanczos::util::scalar_mul ( float a, std::vector< float > & vec )

inline

scalar_mul() [4/7]

void lambda_lanczos::util::scalar_mul ( float a, std::vector< std::complex< float > > & vec )

inline

scalar_mul() [5/7]

void lambda_lanczos::util::scalar_mul ( std::complex< double > a, std::vector< std::complex< double > > & vec )

inline

scalar_mul() [6/7]

void lambda_lanczos::util::scalar_mul ( std::complex< float > a, std::vector< std::complex< float > > & vec )

inline

scalar_mul() [7/7]

template<typename T1, typename T2>

void lambda_lanczos::util::scalar_mul ( T1 a, std::vector< T2 > & vec )

inline

Multiplies each element of vec by a.

schmidt_orth() [1/5]

template<typename ForwardIterator>

void lambda_lanczos::util::schmidt_orth ( std::vector< double > & uorth, ForwardIterator first, ForwardIterator last )

inline

schmidt_orth() [2/5]

template<typename ForwardIterator>

void lambda_lanczos::util::schmidt_orth ( std::vector< float > & uorth, ForwardIterator first, ForwardIterator last )

inline

schmidt_orth() [3/5]

template<typename ForwardIterator>

void lambda_lanczos::util::schmidt_orth ( std::vector< std::complex< double > > & uorth, ForwardIterator first, ForwardIterator last )

inline

schmidt_orth() [4/5]

template<typename ForwardIterator>

void lambda_lanczos::util::schmidt_orth ( std::vector< std::complex< float > > & uorth, ForwardIterator first, ForwardIterator last )

inline

schmidt_orth() [5/5]

template<typename ForwardIterator, typename T>

void lambda_lanczos::util::schmidt_orth ( std::vector< T > & uorth, ForwardIterator first, ForwardIterator last )

inline

Orthogonalizes vector uorth with respect to orthonormal vectors defined by given iterators.

Vectors in u must be normalized, but uorth doesn't have to be.

sgn()

template<typename T>

T lambda_lanczos::util::sgn

(

T

val

)

Return the sign of given value.

If 0 is given, this function returns +1.

sig_decimal_digit()

template<typename T>

int lambda_lanczos::util::sig_decimal_digit ( )

inlineconstexpr

Returns the significant decimal digits of type T.

sort_eigenpairs()

template<typename T>

void lambda_lanczos::util::sort_eigenpairs ( std::vector< real_t< T > > & eigenvalues, std::vector< std::vector< T > > & eigenvectors, bool sort_eigenvector, const std::function< bool(real_t< T >, real_t< T >)> predicate = std::less<real_t<T>>() )

inline

Sorts eigenvalues and eigenvectors with respect to given predicate.

Note

This function changes the memory location of the eigenpairs.

typed_conj()

template<typename T>

T lambda_lanczos::util::typed_conj ( const T & val )

inline

Complex conjugate with type. This function returns the argument itself for real type, and returns its complex conjugate for complex type.

vectorToString()

template<typename T>

std::string lambda_lanczos::util::vectorToString	(	const std::vector< T > &	vec,
		std::string	delimiter = " " )

Returns string representation of given vector.