Eigen::internal::MatrixFunctionAtomic< MatrixType > Class Template Reference

Helper class for computing matrix functions of atomic matrices. More...

#include <MatrixFunction.h>

Public Types
typedef MatrixType::Scalar	Scalar
typedef stem_function< Scalar >::type	StemFunction

Public Member Functions
	MatrixFunctionAtomic (StemFunction f)
	Constructor. More...
MatrixType	compute (const MatrixType &A)
	Compute matrix function of atomic matrix. More...

Private Attributes
StemFunction *	m_f

Detailed Description

template<typename MatrixType>
class Eigen::internal::MatrixFunctionAtomic< MatrixType >

Helper class for computing matrix functions of atomic matrices.

Here, an atomic matrix is a triangular matrix whose diagonal entries are close to each other.

Member Typedef Documentation

Scalar

template<typename MatrixType >

typedef MatrixType::Scalar Eigen::internal::MatrixFunctionAtomic< MatrixType >::Scalar

StemFunction

template<typename MatrixType >

typedef stem_function<Scalar>::type Eigen::internal::MatrixFunctionAtomic< MatrixType >::StemFunction

Constructor & Destructor Documentation

MatrixFunctionAtomic()

template<typename MatrixType >

Eigen::internal::MatrixFunctionAtomic< MatrixType >::MatrixFunctionAtomic ( StemFunction  f )

inline

Constructor.

Parameters

[in]

f

matrix function to compute.

: m_f(f) {}

Member Function Documentation

compute()

template<typename MatrixType >

MatrixType Eigen::internal::MatrixFunctionAtomic< MatrixType >::compute

(

const MatrixType &

A

)

Compute matrix function of atomic matrix.

Parameters

[in]

A

argument of matrix function, should be upper triangular and atomic

Returns

f(A), the matrix function evaluated at the given matrix

                                                                        {
  // TODO: Use that A is upper triangular
  typedef typename NumTraits<Scalar>::Real RealScalar;
  Index rows = A.rows();
  Scalar avgEival = A.trace() / Scalar(RealScalar(rows));
  MatrixType Ashifted = A - avgEival * MatrixType::Identity(rows, rows);
  RealScalar mu = matrix_function_compute_mu(Ashifted);
  MatrixType F = m_f(avgEival, 0) * MatrixType::Identity(rows, rows);
  MatrixType P = Ashifted;
  MatrixType Fincr;
  for (Index s = 1; double(s) < 1.1 * double(rows) + 10.0; s++) {  // upper limit is fairly arbitrary
    Fincr = m_f(avgEival, static_cast<int>(s)) * P;
    F += Fincr;
    P = Scalar(RealScalar(1) / RealScalar(s + 1)) * P * Ashifted;
 
    // test whether Taylor series converged
    const RealScalar F_norm = F.cwiseAbs().rowwise().sum().maxCoeff();
    const RealScalar Fincr_norm = Fincr.cwiseAbs().rowwise().sum().maxCoeff();
    if (Fincr_norm < NumTraits<Scalar>::epsilon() * F_norm) {
      RealScalar delta = 0;
      RealScalar rfactorial = 1;
      for (Index r = 0; r < rows; r++) {
        RealScalar mx = 0;
        for (Index i = 0; i < rows; i++)
          mx = (std::max)(mx, std::abs(m_f(Ashifted(i, i) + avgEival, static_cast<int>(s + r))));
        if (r != 0) rfactorial *= RealScalar(r);
        delta = (std::max)(delta, mx / rfactorial);
      }
      const RealScalar P_norm = P.cwiseAbs().rowwise().sum().maxCoeff();
      if (mu * delta * P_norm < NumTraits<Scalar>::epsilon() * F_norm)  // series converged
        break;
    }
  }
  return F;
}

References abs(), MultiOpt::delta, oomph::OcTreeNames::F, i, Eigen::internal::matrix_function_compute_mu(), max, Global_Parameters::mu, Global_Physical_Variables::P, UniformPSDSelfTest::r, rows, Eigen::PlainObjectBase< Derived >::rows(), and s.

Member Data Documentation

m_f

template<typename MatrixType >

StemFunction* Eigen::internal::MatrixFunctionAtomic< MatrixType >::m_f

private

---

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

• MatrixFunction.h