Eigen::internal::companion< Scalar_, Deg_ > Class Template Reference

#include <Companion.h>

Public Types
enum	{ Deg = Deg_ , Deg_1 = decrement_if_fixed_size<Deg>::ret }
typedef Scalar_	Scalar
typedef NumTraits< Scalar >::Real	RealScalar
typedef Matrix< Scalar, Deg, 1 >	RightColumn
typedef Matrix< Scalar, Deg_1, 1 >	BottomLeftDiagonal
typedef Matrix< Scalar, Deg, Deg >	DenseCompanionMatrixType
typedef Matrix< Scalar, Deg_, Deg_1 >	LeftBlock
typedef Matrix< Scalar, Deg_1, Deg_1 >	BottomLeftBlock
typedef Matrix< Scalar, 1, Deg_1 >	LeftBlockFirstRow
typedef DenseIndex	Index

Public Member Functions
EIGEN_STRONG_INLINE const Scalar_	operator() (Index row, Index col) const
template<typename VectorType >
void	setPolynomial (const VectorType &poly)
template<typename VectorType >
	companion (const VectorType &poly)
DenseCompanionMatrixType	denseMatrix () const
void	balance ()

Protected Member Functions
bool	balanced (RealScalar colNorm, RealScalar rowNorm, bool &isBalanced, RealScalar &colB, RealScalar &rowB)
bool	balancedR (RealScalar colNorm, RealScalar rowNorm, bool &isBalanced, RealScalar &colB, RealScalar &rowB)

Protected Attributes
RightColumn	m_monic
BottomLeftDiagonal	m_bl_diag

Member Typedef Documentation

BottomLeftBlock

template<typename Scalar_ , int Deg_>

typedef Matrix<Scalar, Deg_1, Deg_1> Eigen::internal::companion< Scalar_, Deg_ >::BottomLeftBlock

BottomLeftDiagonal

template<typename Scalar_ , int Deg_>

typedef Matrix<Scalar, Deg_1, 1> Eigen::internal::companion< Scalar_, Deg_ >::BottomLeftDiagonal

DenseCompanionMatrixType

template<typename Scalar_ , int Deg_>

typedef Matrix<Scalar, Deg, Deg> Eigen::internal::companion< Scalar_, Deg_ >::DenseCompanionMatrixType

Index

template<typename Scalar_ , int Deg_>

typedef DenseIndex Eigen::internal::companion< Scalar_, Deg_ >::Index

LeftBlock

template<typename Scalar_ , int Deg_>

typedef Matrix<Scalar, Deg_, Deg_1> Eigen::internal::companion< Scalar_, Deg_ >::LeftBlock

LeftBlockFirstRow

template<typename Scalar_ , int Deg_>

typedef Matrix<Scalar, 1, Deg_1> Eigen::internal::companion< Scalar_, Deg_ >::LeftBlockFirstRow

RealScalar

template<typename Scalar_ , int Deg_>

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

RightColumn

template<typename Scalar_ , int Deg_>

typedef Matrix<Scalar, Deg, 1> Eigen::internal::companion< Scalar_, Deg_ >::RightColumn

Scalar

template<typename Scalar_ , int Deg_>

typedef Scalar_ Eigen::internal::companion< Scalar_, Deg_ >::Scalar

Member Enumeration Documentation

anonymous enum

template<typename Scalar_ , int Deg_>

anonymous enum

Enumerator
Deg
Deg_1

{ Deg = Deg_, Deg_1 = decrement_if_fixed_size<Deg>::ret };

Constructor & Destructor Documentation

companion()

template<typename Scalar_ , int Deg_>

template<typename VectorType >

Eigen::internal::companion< Scalar_, Deg_ >::companion ( const VectorType &  poly )

inline

                                    {
    setPolynomial(poly);
  }

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

Member Function Documentation

balance()

template<typename Scalar_ , int Deg_>

void Eigen::internal::companion< Scalar_, Deg_ >::balance

Balancing algorithm from B. N. PARLETT and C. REINSCH (1969) "Balancing a matrix for calculation of eigenvalues and eigenvectors" adapted to the case of companion matrices. A matrix with non zero row and non zero column is balanced for a certain norm if the i-th row and the i-th column have same norm for all i.

                                       {
  using std::abs;
  EIGEN_STATIC_ASSERT(Deg == Dynamic || 1 < Deg, YOU_MADE_A_PROGRAMMING_MISTAKE);
  const Index deg = m_monic.size();
  const Index deg_1 = deg - 1;
 
  bool hasConverged = false;
  while (!hasConverged) {
    hasConverged = true;
    RealScalar colNorm, rowNorm;
    RealScalar colB, rowB;
 
    // First row, first column excluding the diagonal
    //==============================================
    colNorm = abs(m_bl_diag[0]);
    rowNorm = abs(m_monic[0]);
 
    // Compute balancing of the row and the column
    if (!balanced(colNorm, rowNorm, hasConverged, colB, rowB)) {
      m_bl_diag[0] *= colB;
      m_monic[0] *= rowB;
    }
 
    // Middle rows and columns excluding the diagonal
    //==============================================
    for (Index i = 1; i < deg_1; ++i) {
      // column norm, excluding the diagonal
      colNorm = abs(m_bl_diag[i]);
 
      // row norm, excluding the diagonal
      rowNorm = abs(m_bl_diag[i - 1]) + abs(m_monic[i]);
 
      // Compute balancing of the row and the column
      if (!balanced(colNorm, rowNorm, hasConverged, colB, rowB)) {
        m_bl_diag[i] *= colB;
        m_bl_diag[i - 1] *= rowB;
        m_monic[i] *= rowB;
      }
    }
 
    // Last row, last column excluding the diagonal
    //============================================
    const Index ebl = m_bl_diag.size() - 1;
    VectorBlock<RightColumn, Deg_1> headMonic(m_monic, 0, deg_1);
    colNorm = headMonic.array().abs().sum();
    rowNorm = abs(m_bl_diag[ebl]);
 
    // Compute balancing of the row and the column
    if (!balanced(colNorm, rowNorm, hasConverged, colB, rowB)) {
      headMonic *= colB;
      m_bl_diag[ebl] *= rowB;
    }
  }
}

References abs(), Eigen::Dynamic, EIGEN_STATIC_ASSERT, and i.

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

balanced()

template<typename Scalar_ , int Deg_>

bool Eigen::internal::companion< Scalar_, Deg_ >::balanced ( RealScalar  colNorm, RealScalar  rowNorm, bool &  isBalanced, RealScalar &  colB, RealScalar &  rowB  )

inlineprotected

Helper function for the balancing algorithm.

Returns

true if the row and the column, having colNorm and rowNorm as norms, are balanced, false otherwise. colB and rowB are respectively the multipliers for the column and the row in order to balance them.

                                                                                   {
  if (RealScalar(0) == colNorm || RealScalar(0) == rowNorm || !(numext::isfinite)(colNorm) ||
      !(numext::isfinite)(rowNorm)) {
    return true;
  } else {
    // To find the balancing coefficients, if the radix is 2,
    // one finds \f$ \sigma \f$ such that
    //  \f$ 2^{2\sigma-1} < rowNorm / colNorm \le 2^{2\sigma+1} \f$
    //  then the balancing coefficient for the row is \f$ 1/2^{\sigma} \f$
    //  and the balancing coefficient for the column is \f$ 2^{\sigma} \f$
    const RealScalar radix = RealScalar(2);
    const RealScalar radix2 = RealScalar(4);
 
    rowB = rowNorm / radix;
    colB = RealScalar(1);
    const RealScalar s = colNorm + rowNorm;
 
    // Find sigma s.t. rowNorm / 2 <= 2^(2*sigma) * colNorm
    RealScalar scout = colNorm;
    while (scout < rowB) {
      colB *= radix;
      scout *= radix2;
    }
 
    // We now have an upper-bound for sigma, try to lower it.
    // Find sigma s.t. 2^(2*sigma) * colNorm / 2 < rowNorm
    scout = colNorm * (colB / radix) * colB;  // Avoid overflow.
    while (scout >= rowNorm) {
      colB /= radix;
      scout /= radix2;
    }
 
    // This line is used to avoid insubstantial balancing.
    if ((rowNorm + radix * scout) < RealScalar(0.95) * s * colB) {
      isBalanced = false;
      rowB = RealScalar(1) / colB;
      return false;
    } else {
      return true;
    }
  }
}

References Eigen::numext::isfinite(), and s.

balancedR()

template<typename Scalar_ , int Deg_>

bool Eigen::internal::companion< Scalar_, Deg_ >::balancedR ( RealScalar  colNorm, RealScalar  rowNorm, bool &  isBalanced, RealScalar &  colB, RealScalar &  rowB  )

inlineprotected

Helper function for the balancing algorithm.

Returns

true if the row and the column, having colNorm and rowNorm as norms, are balanced, false otherwise. colB and rowB are respectively the multipliers for the column and the row in order to balance them.

Set the norm of the column and the row to the geometric mean of the row and column norm

                                                                                    {
  if (RealScalar(0) == colNorm || RealScalar(0) == rowNorm) {
    return true;
  } else {
    const RealScalar q = colNorm / rowNorm;
    if (!isApprox(q, Scalar_(1))) {
      rowB = sqrt(colNorm / rowNorm);
      colB = RealScalar(1) / rowB;
 
      isBalanced = false;
      return false;
    } else {
      return true;
    }
  }
}

References Eigen::internal::isApprox(), Eigen::numext::q, and sqrt().

denseMatrix()

template<typename Scalar_ , int Deg_>

DenseCompanionMatrixType Eigen::internal::companion< Scalar_, Deg_ >::denseMatrix ( ) const

inline

                                               {
    const Index deg = m_monic.size();
    const Index deg_1 = deg - 1;
    DenseCompanionMatrixType companMat(deg, deg);
    companMat << (LeftBlock(deg, deg_1) << LeftBlockFirstRow::Zero(1, deg_1),
                  BottomLeftBlock::Identity(deg - 1, deg - 1) * m_bl_diag.asDiagonal())
                     .finished(),
        m_monic;
    return companMat;
  }

References MergeRestartFiles::finished, Eigen::internal::companion< Scalar_, Deg_ >::m_bl_diag, Eigen::internal::companion< Scalar_, Deg_ >::m_monic, and oomph::PseudoSolidHelper::Zero.

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

operator()()

template<typename Scalar_ , int Deg_>

EIGEN_STRONG_INLINE const Scalar_ Eigen::internal::companion< Scalar_, Deg_ >::operator() ( Index  row, Index  col  ) const

inline

                                                                           {
    if (m_bl_diag.rows() > col) {
      if (0 < row) {
        return m_bl_diag[col];
      } else {
        return 0;
      }
    } else {
      return m_monic[row];
    }
  }

References col(), Eigen::internal::companion< Scalar_, Deg_ >::m_bl_diag, Eigen::internal::companion< Scalar_, Deg_ >::m_monic, row(), and Eigen::PlainObjectBase< Derived >::rows().

setPolynomial()

template<typename Scalar_ , int Deg_>

template<typename VectorType >

void Eigen::internal::companion< Scalar_, Deg_ >::setPolynomial ( const VectorType &  poly )

inline

                                             {
    const Index deg = poly.size() - 1;
    m_monic = -poly.head(deg) / poly[deg];
    m_bl_diag.setOnes(deg - 1);
  }

References Eigen::internal::companion< Scalar_, Deg_ >::m_bl_diag, Eigen::internal::companion< Scalar_, Deg_ >::m_monic, and Eigen::PlainObjectBase< Derived >::setOnes().

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

Member Data Documentation

m_bl_diag

template<typename Scalar_ , int Deg_>

BottomLeftDiagonal Eigen::internal::companion< Scalar_, Deg_ >::m_bl_diag

protected

Referenced by Eigen::internal::companion< Scalar_, Deg_ >::denseMatrix(), Eigen::internal::companion< Scalar_, Deg_ >::operator()(), and Eigen::internal::companion< Scalar_, Deg_ >::setPolynomial().

m_monic

template<typename Scalar_ , int Deg_>

RightColumn Eigen::internal::companion< Scalar_, Deg_ >::m_monic

protected

Referenced by Eigen::internal::companion< Scalar_, Deg_ >::denseMatrix(), Eigen::internal::companion< Scalar_, Deg_ >::operator()(), and Eigen::internal::companion< Scalar_, Deg_ >::setPolynomial().

---

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

• Companion.h