Eigen::Util Namespace Reference


Functions

double abs2 (const std::complex< double > &x)
float abs2 (const std::complex< float > &x)
double abs2 (const double &x)
float abs2 (const float &x)
template<typename T>
std::complex< T > conj (const std::complex< T > &x)
double conj (const double &x)
float conj (const float &x)
template<typename T>
epsilon ()
template<>
double epsilon< double > ()
template<>
float epsilon< float > ()
template<>
std::complex< double > epsilon< std::complex< double > > ()
template<>
std::complex< float > epsilon< std::complex< float > > ()
template<typename T>
bool isApprox (const T &a, const T &b)
template<typename T>
bool isNegligible (const T &a, const T &b)
template<typename T>
void pickRandom (std::complex< T > &x)
void pickRandom (double &x)
void pickRandom (float &x)


Function Documentation

double Eigen::Util::abs2 ( const std::complex< double > &  x  )  [inline]

float Eigen::Util::abs2 ( const std::complex< float > &  x  )  [inline]

double Eigen::Util::abs2 ( const double &  x  )  [inline]

float Eigen::Util::abs2 ( const float &  x  )  [inline]

std::complex<T> Eigen::Util::conj ( const std::complex< T > &  x  )  [inline]

overloaded function that returns the complex conjugate of a complex x.

double Eigen::Util::conj ( const double &  x  )  [inline]

overloaded function that returns the complex conjugate of a double x. Of course, as doubles are reals, this is just the trivial function returning x. But that'll become useful to handle matrices of complex numbers.

float Eigen::Util::conj ( const float &  x  )  [inline]

overloaded function that returns the complex conjugate of a float x. Of course, as floats are reals, this is just the trivial function returning x. But that'll become useful to handle matrices of complex numbers.

T Eigen::Util::epsilon (  )  [inline]

double Eigen::Util::epsilon< double > (  )  [inline]

float Eigen::Util::epsilon< float > (  )  [inline]

std::complex<double> Eigen::Util::epsilon< std::complex< double > > (  )  [inline]

std::complex<float> Eigen::Util::epsilon< std::complex< float > > (  )  [inline]

bool Eigen::Util::isApprox ( const T &  a,
const T &  b 
) [inline]

Returns true if a is very close to b, false otherwise.

In other words: returns abs( a - b ) <= min( abs(a), abs(b) ) * epsilon(b).

Parameters:
a,b can be real or complex numbers (std::complex).

bool Eigen::Util::isNegligible ( const T &  a,
const T &  b 
) [inline]

Short version: returns true if the absolute value of a is much smaller than that of b, false otherwise.

Long version: returns ( abs(a) <= abs(b) * epsilon(b) ).

This function uses the epsilon overloaded function to determine what's "small".

void Eigen::Util::pickRandom ( std::complex< T > &  x  )  [inline]

Stores in the real and imaginary parts of x random values between -1.0 and 1.0

void Eigen::Util::pickRandom ( double &  x  )  [inline]

Stores in x a random double between -1.0 and 1.0

void Eigen::Util::pickRandom ( float &  x  )  [inline]

Stores in x a random float between -1.0 and 1.0


Generated on Sat Apr 19 04:06:40 2008 for Eigen by  doxygen 1.5.5