Eigen::PolynomialSolverBase< Scalar_, Deg_ > Class Template Reference

Defined to be inherited by polynomial solvers: it provides convenient methods such as. More...

#include <PolynomialSolver.h>

Inheritance diagram for Eigen::PolynomialSolverBase< Scalar_, Deg_ >:

Public Types
typedef Scalar_	Scalar
typedef NumTraits< Scalar >::Real	RealScalar
typedef std::complex< RealScalar >	RootType
typedef Matrix< RootType, Deg_, 1 >	RootsType
typedef DenseIndex	Index

Public Member Functions
template<typename OtherPolynomial >
	PolynomialSolverBase (const OtherPolynomial &poly)
	PolynomialSolverBase ()
const RootsType &	roots () const
template<typename Stl_back_insertion_sequence >
void	realRoots (Stl_back_insertion_sequence &bi_seq, const RealScalar &absImaginaryThreshold=NumTraits< Scalar >::dummy_precision()) const
const RootType &	greatestRoot () const
const RootType &	smallestRoot () const
const RealScalar &	absGreatestRealRoot (bool &hasArealRoot, const RealScalar &absImaginaryThreshold=NumTraits< Scalar >::dummy_precision()) const
const RealScalar &	absSmallestRealRoot (bool &hasArealRoot, const RealScalar &absImaginaryThreshold=NumTraits< Scalar >::dummy_precision()) const
const RealScalar &	greatestRealRoot (bool &hasArealRoot, const RealScalar &absImaginaryThreshold=NumTraits< Scalar >::dummy_precision()) const
const RealScalar &	smallestRealRoot (bool &hasArealRoot, const RealScalar &absImaginaryThreshold=NumTraits< Scalar >::dummy_precision()) const

Protected Member Functions
template<typename OtherPolynomial >
void	setPolynomial (const OtherPolynomial &poly)
template<typename squaredNormBinaryPredicate >
const RootType &	selectComplexRoot_withRespectToNorm (squaredNormBinaryPredicate &pred) const
template<typename squaredRealPartBinaryPredicate >
const RealScalar &	selectRealRoot_withRespectToAbsRealPart (squaredRealPartBinaryPredicate &pred, bool &hasArealRoot, const RealScalar &absImaginaryThreshold=NumTraits< Scalar >::dummy_precision()) const
template<typename RealPartBinaryPredicate >
const RealScalar &	selectRealRoot_withRespectToRealPart (RealPartBinaryPredicate &pred, bool &hasArealRoot, const RealScalar &absImaginaryThreshold=NumTraits< Scalar >::dummy_precision()) const

Protected Attributes
RootsType	m_roots

Detailed Description

template<typename Scalar_, int Deg_>
class Eigen::PolynomialSolverBase< Scalar_, Deg_ >

Defined to be inherited by polynomial solvers: it provides convenient methods such as.

• real roots,
• greatest, smallest complex roots,
• real roots with greatest, smallest absolute real value,
• greatest, smallest real roots.

It stores the set of roots as a vector of complexes.

Member Typedef Documentation

Index

template<typename Scalar_ , int Deg_>

typedef DenseIndex Eigen::PolynomialSolverBase< Scalar_, Deg_ >::Index

RealScalar

template<typename Scalar_ , int Deg_>

typedef NumTraits<Scalar>::Real Eigen::PolynomialSolverBase< Scalar_, Deg_ >::RealScalar

RootsType

template<typename Scalar_ , int Deg_>

typedef Matrix<RootType, Deg_, 1> Eigen::PolynomialSolverBase< Scalar_, Deg_ >::RootsType

RootType

template<typename Scalar_ , int Deg_>

typedef std::complex<RealScalar> Eigen::PolynomialSolverBase< Scalar_, Deg_ >::RootType

Scalar

template<typename Scalar_ , int Deg_>

typedef Scalar_ Eigen::PolynomialSolverBase< Scalar_, Deg_ >::Scalar

Constructor & Destructor Documentation

PolynomialSolverBase() [1/2]

template<typename Scalar_ , int Deg_>

template<typename OtherPolynomial >

Eigen::PolynomialSolverBase< Scalar_, Deg_ >::PolynomialSolverBase ( const OtherPolynomial &  poly )

inline

                                                           {
    setPolynomial(poly());
  }

References Eigen::PolynomialSolverBase< Scalar_, Deg_ >::setPolynomial().

PolynomialSolverBase() [2/2]

template<typename Scalar_ , int Deg_>

Eigen::PolynomialSolverBase< Scalar_, Deg_ >::PolynomialSolverBase ( )

inline

{}

Member Function Documentation

absGreatestRealRoot()

template<typename Scalar_ , int Deg_>

const RealScalar& Eigen::PolynomialSolverBase< Scalar_, Deg_ >::absGreatestRealRoot ( bool &  hasArealRoot, const RealScalar &  absImaginaryThreshold = NumTraits<Scalar>::dummy_precision()  ) const

inline

Returns

a real root with greatest absolute magnitude. A real root is defined as the real part of a complex root with absolute imaginary part smallest than absImaginaryThreshold. absImaginaryThreshold takes the dummy_precision associated with the Scalar_ template parameter of the PolynomialSolver class as the default value. If no real root is found the boolean hasArealRoot is set to false and the real part of the root with smallest absolute imaginary part is returned instead.

Parameters

[out]	hasArealRoot	: boolean true if a real root is found according to the absImaginaryThreshold criterion, false otherwise.
[in]	absImaginaryThreshold	: threshold on the absolute imaginary part to decide whether or not a root is real.

                                                                                                              {
    std::greater<RealScalar> greater;
    return selectRealRoot_withRespectToAbsRealPart(greater, hasArealRoot, absImaginaryThreshold);
  }

References Eigen::PolynomialSolverBase< Scalar_, Deg_ >::selectRealRoot_withRespectToAbsRealPart().

absSmallestRealRoot()

template<typename Scalar_ , int Deg_>

const RealScalar& Eigen::PolynomialSolverBase< Scalar_, Deg_ >::absSmallestRealRoot ( bool &  hasArealRoot, const RealScalar &  absImaginaryThreshold = NumTraits<Scalar>::dummy_precision()  ) const

inline

Returns

a real root with smallest absolute magnitude. A real root is defined as the real part of a complex root with absolute imaginary part smallest than absImaginaryThreshold. absImaginaryThreshold takes the dummy_precision associated with the Scalar_ template parameter of the PolynomialSolver class as the default value. If no real root is found the boolean hasArealRoot is set to false and the real part of the root with smallest absolute imaginary part is returned instead.

Parameters

[out]	hasArealRoot	: boolean true if a real root is found according to the absImaginaryThreshold criterion, false otherwise.
[in]	absImaginaryThreshold	: threshold on the absolute imaginary part to decide whether or not a root is real.

                                                                                                              {
    std::less<RealScalar> less;
    return selectRealRoot_withRespectToAbsRealPart(less, hasArealRoot, absImaginaryThreshold);
  }

References Eigen::PolynomialSolverBase< Scalar_, Deg_ >::selectRealRoot_withRespectToAbsRealPart().

greatestRealRoot()

template<typename Scalar_ , int Deg_>

const RealScalar& Eigen::PolynomialSolverBase< Scalar_, Deg_ >::greatestRealRoot ( bool &  hasArealRoot, const RealScalar &  absImaginaryThreshold = NumTraits<Scalar>::dummy_precision()  ) const

inline

Returns

the real root with greatest value. A real root is defined as the real part of a complex root with absolute imaginary part smallest than absImaginaryThreshold. absImaginaryThreshold takes the dummy_precision associated with the Scalar_ template parameter of the PolynomialSolver class as the default value. If no real root is found the boolean hasArealRoot is set to false and the real part of the root with smallest absolute imaginary part is returned instead.

Parameters

[out]	hasArealRoot	: boolean true if a real root is found according to the absImaginaryThreshold criterion, false otherwise.
[in]	absImaginaryThreshold	: threshold on the absolute imaginary part to decide whether or not a root is real.

                                                                                                              {
    std::greater<RealScalar> greater;
    return selectRealRoot_withRespectToRealPart(greater, hasArealRoot, absImaginaryThreshold);
  }

References Eigen::PolynomialSolverBase< Scalar_, Deg_ >::selectRealRoot_withRespectToRealPart().

greatestRoot()

template<typename Scalar_ , int Deg_>

const RootType& Eigen::PolynomialSolverBase< Scalar_, Deg_ >::greatestRoot ( ) const

inline

Returns

the complex root with greatest norm.

                                              {
    std::greater<RealScalar> greater;
    return selectComplexRoot_withRespectToNorm(greater);
  }

References Eigen::PolynomialSolverBase< Scalar_, Deg_ >::selectComplexRoot_withRespectToNorm().

realRoots()

template<typename Scalar_ , int Deg_>

template<typename Stl_back_insertion_sequence >

void Eigen::PolynomialSolverBase< Scalar_, Deg_ >::realRoots ( Stl_back_insertion_sequence &  bi_seq, const RealScalar &  absImaginaryThreshold = NumTraits<Scalar>::dummy_precision()  ) const

inline

Clear and fills the back insertion sequence with the real roots of the polynomial i.e. the real part of the complex roots that have an imaginary part which absolute value is smaller than absImaginaryThreshold. absImaginaryThreshold takes the dummy_precision associated with the Scalar_ template parameter of the PolynomialSolver class as the default value.

Parameters

[out]	bi_seq	: the back insertion sequence (stl concept)
[in]	absImaginaryThreshold	: the maximum bound of the imaginary part of a complex number that is considered as real.

                                                                                                            {
    using std::abs;
    bi_seq.clear();
    for (Index i = 0; i < m_roots.size(); ++i) {
      if (abs(m_roots[i].imag()) < absImaginaryThreshold) {
        bi_seq.push_back(m_roots[i].real());
      }
    }
  }

References abs(), i, Eigen::imag(), Eigen::PolynomialSolverBase< Scalar_, Deg_ >::m_roots, and Eigen::real().

Referenced by evalSolverSugarFunction(), and main().

roots()

template<typename Scalar_ , int Deg_>

const RootsType& Eigen::PolynomialSolverBase< Scalar_, Deg_ >::roots ( ) const

inline

Returns

the complex roots of the polynomial

{ return m_roots; }

References Eigen::PolynomialSolverBase< Scalar_, Deg_ >::m_roots.

Referenced by main().

selectComplexRoot_withRespectToNorm()

template<typename Scalar_ , int Deg_>

template<typename squaredNormBinaryPredicate >

const RootType& Eigen::PolynomialSolverBase< Scalar_, Deg_ >::selectComplexRoot_withRespectToNorm ( squaredNormBinaryPredicate &  pred ) const

inlineprotected

                                                                                                     {
    Index res = 0;
    RealScalar norm2 = numext::abs2(m_roots[0]);
    for (Index i = 1; i < m_roots.size(); ++i) {
      const RealScalar currNorm2 = numext::abs2(m_roots[i]);
      if (pred(currNorm2, norm2)) {
        res = i;
        norm2 = currNorm2;
      }
    }
    return m_roots[res];
  }

References Eigen::numext::abs2(), i, Eigen::PolynomialSolverBase< Scalar_, Deg_ >::m_roots, and res.

Referenced by Eigen::PolynomialSolverBase< Scalar_, Deg_ >::greatestRoot(), and Eigen::PolynomialSolverBase< Scalar_, Deg_ >::smallestRoot().

selectRealRoot_withRespectToAbsRealPart()

template<typename Scalar_ , int Deg_>

template<typename squaredRealPartBinaryPredicate >

const RealScalar& Eigen::PolynomialSolverBase< Scalar_, Deg_ >::selectRealRoot_withRespectToAbsRealPart ( squaredRealPartBinaryPredicate &  pred, bool &  hasArealRoot, const RealScalar &  absImaginaryThreshold = NumTraits<Scalar>::dummy_precision()  ) const

inlineprotected

                                                                                          {
    using std::abs;
    hasArealRoot = false;
    Index res = 0;
    RealScalar abs2(0);
 
    for (Index i = 0; i < m_roots.size(); ++i) {
      if (abs(m_roots[i].imag()) <= absImaginaryThreshold) {
        if (!hasArealRoot) {
          hasArealRoot = true;
          res = i;
          abs2 = m_roots[i].real() * m_roots[i].real();
        } else {
          const RealScalar currAbs2 = m_roots[i].real() * m_roots[i].real();
          if (pred(currAbs2, abs2)) {
            abs2 = currAbs2;
            res = i;
          }
        }
      } else if (!hasArealRoot) {
        if (abs(m_roots[i].imag()) < abs(m_roots[res].imag())) {
          res = i;
        }
      }
    }
    return numext::real_ref(m_roots[res]);
  }

References abs(), Eigen::numext::abs2(), i, Eigen::imag(), Eigen::PolynomialSolverBase< Scalar_, Deg_ >::m_roots, Eigen::numext::real_ref(), and res.

Referenced by Eigen::PolynomialSolverBase< Scalar_, Deg_ >::absGreatestRealRoot(), and Eigen::PolynomialSolverBase< Scalar_, Deg_ >::absSmallestRealRoot().

selectRealRoot_withRespectToRealPart()

template<typename Scalar_ , int Deg_>

template<typename RealPartBinaryPredicate >

const RealScalar& Eigen::PolynomialSolverBase< Scalar_, Deg_ >::selectRealRoot_withRespectToRealPart ( RealPartBinaryPredicate &  pred, bool &  hasArealRoot, const RealScalar &  absImaginaryThreshold = NumTraits<Scalar>::dummy_precision()  ) const

inlineprotected

                                                                                          {
    using std::abs;
    hasArealRoot = false;
    Index res = 0;
    RealScalar val(0);
 
    for (Index i = 0; i < m_roots.size(); ++i) {
      if (abs(m_roots[i].imag()) <= absImaginaryThreshold) {
        if (!hasArealRoot) {
          hasArealRoot = true;
          res = i;
          val = m_roots[i].real();
        } else {
          const RealScalar curr = m_roots[i].real();
          if (pred(curr, val)) {
            val = curr;
            res = i;
          }
        }
      } else {
        if (abs(m_roots[i].imag()) < abs(m_roots[res].imag())) {
          res = i;
        }
      }
    }
    return numext::real_ref(m_roots[res]);
  }

References abs(), i, Eigen::imag(), Eigen::PolynomialSolverBase< Scalar_, Deg_ >::m_roots, Eigen::numext::real_ref(), res, and calibrate::val.

Referenced by Eigen::PolynomialSolverBase< Scalar_, Deg_ >::greatestRealRoot(), and Eigen::PolynomialSolverBase< Scalar_, Deg_ >::smallestRealRoot().

setPolynomial()

template<typename Scalar_ , int Deg_>

template<typename OtherPolynomial >

void Eigen::PolynomialSolverBase< Scalar_, Deg_ >::setPolynomial ( const OtherPolynomial &  poly )

inlineprotected

                                                         {
    m_roots.resize(poly.size() - 1);
  }

References Eigen::PolynomialSolverBase< Scalar_, Deg_ >::m_roots, and Eigen::PlainObjectBase< Derived >::resize().

Referenced by Eigen::PolynomialSolverBase< Scalar_, Deg_ >::PolynomialSolverBase().

smallestRealRoot()

template<typename Scalar_ , int Deg_>

const RealScalar& Eigen::PolynomialSolverBase< Scalar_, Deg_ >::smallestRealRoot ( bool &  hasArealRoot, const RealScalar &  absImaginaryThreshold = NumTraits<Scalar>::dummy_precision()  ) const

inline

Returns

the real root with smallest value. A real root is defined as the real part of a complex root with absolute imaginary part smallest than absImaginaryThreshold. absImaginaryThreshold takes the dummy_precision associated with the Scalar_ template parameter of the PolynomialSolver class as the default value. If no real root is found the boolean hasArealRoot is set to false and the real part of the root with smallest absolute imaginary part is returned instead.

Parameters

[out]	hasArealRoot	: boolean true if a real root is found according to the absImaginaryThreshold criterion, false otherwise.
[in]	absImaginaryThreshold	: threshold on the absolute imaginary part to decide whether or not a root is real.

                                                                                                              {
    std::less<RealScalar> less;
    return selectRealRoot_withRespectToRealPart(less, hasArealRoot, absImaginaryThreshold);
  }

References Eigen::PolynomialSolverBase< Scalar_, Deg_ >::selectRealRoot_withRespectToRealPart().

smallestRoot()

template<typename Scalar_ , int Deg_>

const RootType& Eigen::PolynomialSolverBase< Scalar_, Deg_ >::smallestRoot ( ) const

inline

Returns

the complex root with smallest norm.

                                              {
    std::less<RealScalar> less;
    return selectComplexRoot_withRespectToNorm(less);
  }

References Eigen::PolynomialSolverBase< Scalar_, Deg_ >::selectComplexRoot_withRespectToNorm().

Member Data Documentation

m_roots

template<typename Scalar_ , int Deg_>

RootsType Eigen::PolynomialSolverBase< Scalar_, Deg_ >::m_roots

protected

Referenced by Eigen::PolynomialSolverBase< Scalar_, Deg_ >::realRoots(), Eigen::PolynomialSolverBase< Scalar_, Deg_ >::roots(), Eigen::PolynomialSolverBase< Scalar_, Deg_ >::selectComplexRoot_withRespectToNorm(), Eigen::PolynomialSolverBase< Scalar_, Deg_ >::selectRealRoot_withRespectToAbsRealPart(), Eigen::PolynomialSolverBase< Scalar_, Deg_ >::selectRealRoot_withRespectToRealPart(), and Eigen::PolynomialSolverBase< Scalar_, Deg_ >::setPolynomial().

---

The documentation for this class was generated from the following file:

• PolynomialSolver.h