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> | |
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) |
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).
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