inverse.cpp File Reference

#include "main.h"
#include <Eigen/LU>

Functions
template<typename MatrixType >
void	inverse_for_fixed_size (const MatrixType &, std::enable_if_t< MatrixType::SizeAtCompileTime==Dynamic > *=0)
template<typename MatrixType >
void	inverse_for_fixed_size (const MatrixType &m1, std::enable_if_t< MatrixType::SizeAtCompileTime !=Dynamic > *=0)
template<typename MatrixType >
void	inverse (const MatrixType &m)
template<typename Scalar >
void	inverse_zerosized ()
	EIGEN_DECLARE_TEST (inverse)

Function Documentation

EIGEN_DECLARE_TEST()

EIGEN_DECLARE_TEST

(

inverse

)

                            {
  int s = 0;
  for (int i = 0; i < g_repeat; i++) {
    CALL_SUBTEST_1(inverse(Matrix<double, 1, 1>()));
    CALL_SUBTEST_2(inverse(Matrix2d()));
    CALL_SUBTEST_3(inverse(Matrix3f()));
    CALL_SUBTEST_4(inverse(Matrix4f()));
    CALL_SUBTEST_4(inverse(Matrix<float, 4, 4, DontAlign>()));
 
    s = internal::random<int>(50, 320);
    CALL_SUBTEST_5(inverse(MatrixXf(s, s)));
    TEST_SET_BUT_UNUSED_VARIABLE(s)
    CALL_SUBTEST_5(inverse_zerosized<float>());
    CALL_SUBTEST_5(inverse(MatrixXf(0, 0)));
    CALL_SUBTEST_5(inverse(MatrixXf(1, 1)));
 
    s = internal::random<int>(25, 100);
    CALL_SUBTEST_6(inverse(MatrixXcd(s, s)));
    TEST_SET_BUT_UNUSED_VARIABLE(s)
 
    CALL_SUBTEST_7(inverse(Matrix4d()));
    CALL_SUBTEST_7(inverse(Matrix<double, 4, 4, DontAlign>()));
 
    CALL_SUBTEST_8(inverse(Matrix4cd()));
  }
}

References CALL_SUBTEST_1, CALL_SUBTEST_2, CALL_SUBTEST_3, CALL_SUBTEST_4, CALL_SUBTEST_5, CALL_SUBTEST_6, CALL_SUBTEST_7, CALL_SUBTEST_8, Eigen::g_repeat, i, inverse(), s, and TEST_SET_BUT_UNUSED_VARIABLE.

inverse()

template<typename MatrixType >

void inverse

(

const MatrixType &

m

)

                                  {
  /* this test covers the following files:
     Inverse.h
  */
  Index rows = m.rows();
  Index cols = m.cols();
 
  typedef typename MatrixType::Scalar Scalar;
 
  MatrixType m1(rows, cols), m2(rows, cols), identity = MatrixType::Identity(rows, rows);
  createRandomPIMatrixOfRank(rows, rows, rows, m1);
  m2 = m1.inverse();
  VERIFY_IS_APPROX(m1, m2.inverse());
 
  VERIFY_IS_APPROX((Scalar(2) * m2).inverse(), m2.inverse() * Scalar(0.5));
 
  VERIFY_IS_APPROX(identity, m1.inverse() * m1);
  VERIFY_IS_APPROX(identity, m1 * m1.inverse());
 
  VERIFY_IS_APPROX(m1, m1.inverse().inverse());
 
  // since for the general case we implement separately row-major and col-major, test that
  VERIFY_IS_APPROX(MatrixType(m1.transpose().inverse()), MatrixType(m1.inverse().transpose()));
 
  inverse_for_fixed_size(m1);
 
  // check in-place inversion
  if (MatrixType::RowsAtCompileTime >= 2 && MatrixType::RowsAtCompileTime <= 4) {
    // in-place is forbidden
    VERIFY_RAISES_ASSERT(m1 = m1.inverse());
  } else {
    m2 = m1.inverse();
    m1 = m1.inverse();
    VERIFY_IS_APPROX(m1, m2);
  }
}

References cols, Eigen::createRandomPIMatrixOfRank(), inverse_for_fixed_size(), m, m1, m2(), rows, VERIFY_IS_APPROX, and VERIFY_RAISES_ASSERT.

Referenced by array_complex(), array_real(), Eigen::MatrixBase< Derived >::computeInverseAndDetWithCheck(), EIGEN_DECLARE_TEST(), Eigen::internal::kissfft_impl< Scalar_ >::get_plan(), Eigen::internal::fftw_impl< Scalar_ >::get_plan(), Eigen::internal::kiss_cpx_fft< Scalar_ >::make_twiddles(), Eigen::internal::compute_inverse_and_det_with_check< MatrixType, ResultType, 2 >::run(), Eigen::internal::compute_inverse_and_det_with_check< MatrixType, ResultType, 3 >::run(), Eigen::internal::compute_inverse_and_det_with_check< MatrixType, ResultType, 4 >::run(), test_3d(), and test_unary_builtins_for_assignement().

inverse_for_fixed_size() [1/2]

template<typename MatrixType >

void inverse_for_fixed_size	(	const MatrixType &	,
		std::enable_if_t< MatrixType::SizeAtCompileTime==Dynamic > *	= 0
	)

{}

Referenced by inverse().

inverse_for_fixed_size() [2/2]

template<typename MatrixType >

void inverse_for_fixed_size	(	const MatrixType &	m1,
		std::enable_if_t< MatrixType::SizeAtCompileTime !=Dynamic > *	= 0
	)

                                                                                                               {
  using std::abs;
 
  MatrixType m2, identity = MatrixType::Identity();
 
  typedef typename MatrixType::Scalar Scalar;
  typedef typename NumTraits<Scalar>::Real RealScalar;
  typedef Matrix<Scalar, MatrixType::ColsAtCompileTime, 1> VectorType;
 
  // computeInverseAndDetWithCheck tests
  // First: an invertible matrix
  bool invertible;
  Scalar det;
 
  m2.setZero();
  m1.computeInverseAndDetWithCheck(m2, det, invertible);
  VERIFY(invertible);
  VERIFY_IS_APPROX(identity, m1 * m2);
  VERIFY_IS_APPROX(det, m1.determinant());
 
  m2.setZero();
  m1.computeInverseWithCheck(m2, invertible);
  VERIFY(invertible);
  VERIFY_IS_APPROX(identity, m1 * m2);
 
  // Second: a rank one matrix (not invertible, except for 1x1 matrices)
  VectorType v3 = VectorType::Random();
  MatrixType m3 = v3 * v3.transpose(), m4;
  m3.computeInverseAndDetWithCheck(m4, det, invertible);
  VERIFY(m1.rows() == 1 ? invertible : !invertible);
  VERIFY_IS_MUCH_SMALLER_THAN(abs(det - m3.determinant()), RealScalar(1));
  m3.computeInverseWithCheck(m4, invertible);
  VERIFY(m1.rows() == 1 ? invertible : !invertible);
 
  // check with submatrices
  {
    Matrix<Scalar, MatrixType::RowsAtCompileTime + 1, MatrixType::RowsAtCompileTime + 1, MatrixType::Options> m5;
    m5.setRandom();
    m5.topLeftCorner(m1.rows(), m1.rows()) = m1;
    m2 = m5.template topLeftCorner<MatrixType::RowsAtCompileTime, MatrixType::ColsAtCompileTime>().inverse();
    VERIFY_IS_APPROX((m5.template topLeftCorner<MatrixType::RowsAtCompileTime, MatrixType::ColsAtCompileTime>()),
                     m2.inverse());
  }
}

References abs(), m1, m2(), Eigen::PlainObjectBase< Derived >::setRandom(), VERIFY, VERIFY_IS_APPROX, and VERIFY_IS_MUCH_SMALLER_THAN.

inverse_zerosized()

template<typename Scalar >

void inverse_zerosized

(

)

                         {
  Matrix<Scalar, Dynamic, Dynamic> A(0, 0);
  {
    Matrix<Scalar, 0, 1> b, x;
    x = A.inverse() * b;
  }
  {
    Matrix<Scalar, Dynamic, Dynamic> b(0, 1), x;
    x = A.inverse() * b;
    VERIFY_IS_EQUAL(x.rows(), 0);
    VERIFY_IS_EQUAL(x.cols(), 1);
  }
}

References b, VERIFY_IS_EQUAL, and plotDoE::x.