matrix_function.cpp File Reference

#include "main.h"
#include <unsupported/Eigen/MatrixFunctions>

Classes
struct	randomMatrixWithImagEivals< MatrixType, IsComplex >
struct	randomMatrixWithImagEivals< MatrixType, 0 >
struct	randomMatrixWithImagEivals< MatrixType, 1 >

Macros
#define	VERIFY_IS_APPROX_ABS(a, b)   VERIFY(test_isApprox_abs(a, b))

Functions
template<typename Type1 , typename Type2 >
bool	test_isApprox_abs (const Type1 &a, const Type2 &b)
template<typename MatrixType >
MatrixType	randomMatrixWithRealEivals (const Index size)
template<typename MatrixType >
void	testMatrixExponential (const MatrixType &A)
template<typename MatrixType >
void	testMatrixLogarithm (const MatrixType &A)
template<typename MatrixType >
void	testHyperbolicFunctions (const MatrixType &A)
template<typename MatrixType >
void	testGonioFunctions (const MatrixType &A)
template<typename MatrixType >
void	testMatrix (const MatrixType &A)
template<typename MatrixType >
void	testMatrixType (const MatrixType &m)
template<typename MatrixType >
void	testMapRef (const MatrixType &A)
	EIGEN_DECLARE_TEST (matrix_function)

Macro Definition Documentation

VERIFY_IS_APPROX_ABS

#define VERIFY_IS_APPROX_ABS	(		a,
			b
	)		VERIFY(test_isApprox_abs(a, b))

Function Documentation

EIGEN_DECLARE_TEST()

EIGEN_DECLARE_TEST

(

matrix_function

)

                                    {
  CALL_SUBTEST_1(testMatrixType(Matrix<float, 1, 1>()));
  CALL_SUBTEST_2(testMatrixType(Matrix3cf()));
  CALL_SUBTEST_3(testMatrixType(MatrixXf(8, 8)));
  CALL_SUBTEST_4(testMatrixType(Matrix2d()));
  CALL_SUBTEST_5(testMatrixType(Matrix<double, 5, 5, RowMajor>()));
  CALL_SUBTEST_6(testMatrixType(Matrix4cd()));
  CALL_SUBTEST_7(testMatrixType(MatrixXd(13, 13)));
 
  CALL_SUBTEST_1(testMapRef(Matrix<float, 1, 1>()));
  CALL_SUBTEST_2(testMapRef(Matrix3cf()));
  CALL_SUBTEST_3(testMapRef(MatrixXf(8, 8)));
  CALL_SUBTEST_7(testMapRef(MatrixXd(13, 13)));
}

References CALL_SUBTEST_1, CALL_SUBTEST_2, CALL_SUBTEST_3, CALL_SUBTEST_4, CALL_SUBTEST_5, CALL_SUBTEST_6, CALL_SUBTEST_7, testMapRef(), and testMatrixType().

randomMatrixWithRealEivals()

template<typename MatrixType >

MatrixType randomMatrixWithRealEivals

(

const Index

size

)

                                                        {
  typedef typename MatrixType::Scalar Scalar;
  typedef typename MatrixType::RealScalar RealScalar;
  MatrixType diag = MatrixType::Zero(size, size);
  for (Index i = 0; i < size; ++i) {
    diag(i, i) =
        Scalar(RealScalar(internal::random<int>(0, 2))) + internal::random<Scalar>() * Scalar(RealScalar(0.01));
  }
  MatrixType A = MatrixType::Random(size, size);
  HouseholderQR<MatrixType> QRofA(A);
  return QRofA.householderQ().inverse() * diag * QRofA.householderQ();
}

References diag, Eigen::HouseholderQR< MatrixType_ >::householderQ(), i, Eigen::HouseholderSequence< VectorsType, CoeffsType, Side >::inverse(), size, and oomph::PseudoSolidHelper::Zero.

test_isApprox_abs()

template<typename Type1 , typename Type2 >

bool test_isApprox_abs ( const Type1 &  a, const Type2 &  b  )

inline

                                                              {
  return ((a - b).array().abs() < test_precision<typename Type1::RealScalar>()).all();
}

References a, abs(), and b.

testGonioFunctions()

template<typename MatrixType >

void testGonioFunctions

(

const MatrixType &

A

)

                                             {
  typedef typename MatrixType::Scalar Scalar;
  typedef typename NumTraits<Scalar>::Real RealScalar;
  typedef std::complex<RealScalar> ComplexScalar;
  typedef Matrix<ComplexScalar, MatrixType::RowsAtCompileTime, MatrixType::ColsAtCompileTime, MatrixType::Options>
      ComplexMatrix;
 
  ComplexScalar imagUnit(0, 1);
  ComplexScalar two(2, 0);
 
  ComplexMatrix Ac = A.template cast<ComplexScalar>();
 
  ComplexMatrix exp_iA = (imagUnit * Ac).exp();
  ComplexMatrix exp_miA = (-imagUnit * Ac).exp();
 
  ComplexMatrix sinAc = A.sin().template cast<ComplexScalar>();
  VERIFY_IS_APPROX_ABS(sinAc, (exp_iA - exp_miA) / (two * imagUnit));
 
  ComplexMatrix cosAc = A.cos().template cast<ComplexScalar>();
  VERIFY_IS_APPROX_ABS(cosAc, (exp_iA + exp_miA) / 2);
}

References Eigen::bfloat16_impl::exp(), and VERIFY_IS_APPROX_ABS.

Referenced by testMatrix().

testHyperbolicFunctions()

template<typename MatrixType >

void testHyperbolicFunctions

(

const MatrixType &

A

)

                                                  {
  // Need to use absolute error because of possible cancellation when
  // adding/subtracting expA and expmA.
  VERIFY_IS_APPROX_ABS(A.sinh(), (A.exp() - (-A).exp()) / 2);
  VERIFY_IS_APPROX_ABS(A.cosh(), (A.exp() + (-A).exp()) / 2);
}

References VERIFY_IS_APPROX_ABS.

Referenced by testMatrix().

testMapRef()

template<typename MatrixType >

void testMapRef

(

const MatrixType &

A

)

                                     {
  // Test if passing Ref and Map objects is possible
  // (Regression test for Bug #1796)
  Index size = A.rows();
  MatrixType X;
  X.setRandom(size, size);
  MatrixType Y(size, size);
  Ref<MatrixType> R(Y);
  Ref<const MatrixType> Rc(X);
  Map<MatrixType> M(Y.data(), size, size);
  Map<const MatrixType> Mc(X.data(), size, size);
 
  X = X * X;  // make sure sqrt is possible
  Y = X.sqrt();
  R = Rc.sqrt();
  M = Mc.sqrt();
  Y = X.exp();
  R = Rc.exp();
  M = Mc.exp();
  X = Y;  // make sure log is possible
  Y = X.log();
  R = Rc.log();
  M = Mc.log();
 
  Y = X.cos() + Rc.cos() + Mc.cos();
  Y = X.sin() + Rc.sin() + Mc.sin();
 
  Y = X.cosh() + Rc.cosh() + Mc.cosh();
  Y = X.sinh() + Rc.sinh() + Mc.sinh();
}

References R, Eigen::PlainObjectBase< Derived >::rows(), size, X, and Y.

Referenced by EIGEN_DECLARE_TEST().

testMatrix()

template<typename MatrixType >

void testMatrix

(

const MatrixType &

A

)

                                     {
  testMatrixExponential(A);
  testMatrixLogarithm(A);
  testHyperbolicFunctions(A);
  testGonioFunctions(A);
}

References testGonioFunctions(), testHyperbolicFunctions(), testMatrixExponential(), and testMatrixLogarithm().

Referenced by testMatrixType().

testMatrixExponential()

template<typename MatrixType >

void testMatrixExponential

(

const MatrixType &

A

)

                                                {
  typedef typename internal::traits<MatrixType>::Scalar Scalar;
  typedef typename NumTraits<Scalar>::Real RealScalar;
  typedef std::complex<RealScalar> ComplexScalar;
 
  VERIFY_IS_APPROX(A.exp(), A.matrixFunction(internal::stem_function_exp<ComplexScalar>));
}

References VERIFY_IS_APPROX.

Referenced by testMatrix().

testMatrixLogarithm()

template<typename MatrixType >

void testMatrixLogarithm

(

const MatrixType &

A

)

                                              {
  typedef typename internal::traits<MatrixType>::Scalar Scalar;
  typedef typename NumTraits<Scalar>::Real RealScalar;
 
  MatrixType scaledA;
  RealScalar maxImagPartOfSpectrum = A.eigenvalues().imag().cwiseAbs().maxCoeff();
  if (maxImagPartOfSpectrum >= RealScalar(0.9L * EIGEN_PI))
    scaledA = A * RealScalar(0.9L * EIGEN_PI) / maxImagPartOfSpectrum;
  else
    scaledA = A;
 
  // identity X.exp().log() = X only holds if Im(lambda) < pi for all eigenvalues of X
  MatrixType expA = scaledA.exp();
  MatrixType logExpA = expA.log();
  VERIFY_IS_APPROX(logExpA, scaledA);
}

References EIGEN_PI, and VERIFY_IS_APPROX.

Referenced by testMatrix().

testMatrixType()

template<typename MatrixType >

void testMatrixType

(

const MatrixType &

m

)

                                         {
  // Matrices with clustered eigenvalue lead to different code paths
  // in MatrixFunction.h and are thus useful for testing.
 
  const Index size = m.rows();
  for (int i = 0; i < g_repeat; i++) {
    testMatrix(MatrixType::Random(size, size).eval());
    testMatrix(randomMatrixWithRealEivals<MatrixType>(size));
    testMatrix(randomMatrixWithImagEivals<MatrixType>::run(size));
  }
}

References eval(), Eigen::g_repeat, i, m, size, and testMatrix().

Referenced by EIGEN_DECLARE_TEST().