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
1.5.9