swap.cpp File Reference

#include "main.h"

Classes
struct	other_matrix_type< T >
struct	other_matrix_type< Matrix< Scalar_, Rows_, Cols_, Options_, MaxRows_, MaxCols_ > >

Functions
template<typename MatrixType >
std::enable_if_t<(MatrixType::RowsAtCompileTime==1||MatrixType::RowsAtCompileTime==Dynamic), void >	check_row_swap (MatrixType &m1)
template<typename MatrixType >
std::enable_if_t<!(MatrixType::RowsAtCompileTime==1||MatrixType::RowsAtCompileTime==Dynamic), void >	check_row_swap (MatrixType &)
template<typename MatrixType >
void	swap (const MatrixType &m)
	EIGEN_DECLARE_TEST (swap)

Function Documentation

check_row_swap() [1/2]

template<typename MatrixType >

std::enable_if_t<!(MatrixType::RowsAtCompileTime == 1 || MatrixType::RowsAtCompileTime == Dynamic), void> check_row_swap

(

MatrixType &

)

{}

check_row_swap() [2/2]

template<typename MatrixType >

std::enable_if_t<(MatrixType::RowsAtCompileTime == 1 || MatrixType::RowsAtCompileTime == Dynamic), void> check_row_swap

(

MatrixType &

m1

)

                    {
  if (m1.rows() != 1) {
    // test assertion on mismatching size -- matrix case
    VERIFY_RAISES_ASSERT(m1.swap(m1.row(0)));
    // test assertion on mismatching size -- xpr case
    VERIFY_RAISES_ASSERT(m1.row(0).swap(m1));
  }
}

References m1, and VERIFY_RAISES_ASSERT.

Referenced by swap().

EIGEN_DECLARE_TEST()

EIGEN_DECLARE_TEST

(

swap

)

                         {
  int s = internal::random<int>(1, EIGEN_TEST_MAX_SIZE);
  CALL_SUBTEST_1(swap(Matrix3f()));      // fixed size, no vectorization
  CALL_SUBTEST_2(swap(Matrix4d()));      // fixed size, possible vectorization
  CALL_SUBTEST_3(swap(MatrixXd(s, s)));  // dyn size, no vectorization
  CALL_SUBTEST_4(swap(MatrixXf(s, s)));  // dyn size, possible vectorization
  TEST_SET_BUT_UNUSED_VARIABLE(s)
}

References CALL_SUBTEST_1, CALL_SUBTEST_2, CALL_SUBTEST_3, CALL_SUBTEST_4, EIGEN_TEST_MAX_SIZE, s, swap(), and TEST_SET_BUT_UNUSED_VARIABLE.

swap()

template<typename MatrixType >

void swap

(

const MatrixType &

m

)

                               {
  typedef typename other_matrix_type<MatrixType>::type OtherMatrixType;
  typedef typename MatrixType::Scalar Scalar;
 
  eigen_assert((!internal::is_same<MatrixType, OtherMatrixType>::value));
  Index rows = m.rows();
  Index cols = m.cols();
 
  // construct 3 matrix guaranteed to be distinct
  MatrixType m1 = MatrixType::Random(rows, cols);
  MatrixType m2 = MatrixType::Random(rows, cols) + Scalar(100) * MatrixType::Identity(rows, cols);
  OtherMatrixType m3 = OtherMatrixType::Random(rows, cols) + Scalar(200) * OtherMatrixType::Identity(rows, cols);
 
  MatrixType m1_copy = m1;
  MatrixType m2_copy = m2;
  OtherMatrixType m3_copy = m3;
 
  // test swapping 2 matrices of same type
  Scalar *d1 = m1.data(), *d2 = m2.data();
  m1.swap(m2);
  VERIFY_IS_APPROX(m1, m2_copy);
  VERIFY_IS_APPROX(m2, m1_copy);
  if (MatrixType::SizeAtCompileTime == Dynamic) {
    VERIFY(m1.data() == d2);
    VERIFY(m2.data() == d1);
  }
  m1 = m1_copy;
  m2 = m2_copy;
  d1 = m1.data(), d2 = m2.data();
  swap(m1, m2);
  VERIFY_IS_APPROX(m1, m2_copy);
  VERIFY_IS_APPROX(m2, m1_copy);
  if (MatrixType::SizeAtCompileTime == Dynamic) {
    VERIFY(m1.data() == d2);
    VERIFY(m2.data() == d1);
  }
  m1 = m1_copy;
  m2 = m2_copy;
 
  // test swapping 2 matrices of different types
  m1.swap(m3);
  VERIFY_IS_APPROX(m1, m3_copy);
  VERIFY_IS_APPROX(m3, m1_copy);
  m1 = m1_copy;
  m3 = m3_copy;
  swap(m1, m3);
  VERIFY_IS_APPROX(m1, m3_copy);
  VERIFY_IS_APPROX(m3, m1_copy);
  m1 = m1_copy;
  m3 = m3_copy;
 
  // test swapping matrix with expression
  m1.swap(m2.block(0, 0, rows, cols));
  VERIFY_IS_APPROX(m1, m2_copy);
  VERIFY_IS_APPROX(m2, m1_copy);
  m1 = m1_copy;
  m2 = m2_copy;
  swap(m1, m2.block(0, 0, rows, cols));
  VERIFY_IS_APPROX(m1, m2_copy);
  VERIFY_IS_APPROX(m2, m1_copy);
  m1 = m1_copy;
  m2 = m2_copy;
 
  // test swapping two expressions of different types
  m1.transpose().swap(m3.transpose());
  VERIFY_IS_APPROX(m1, m3_copy);
  VERIFY_IS_APPROX(m3, m1_copy);
  m1 = m1_copy;
  m3 = m3_copy;
  swap(m1.transpose(), m3.transpose());
  VERIFY_IS_APPROX(m1, m3_copy);
  VERIFY_IS_APPROX(m3, m1_copy);
  m1 = m1_copy;
  m3 = m3_copy;
 
  check_row_swap(m1);
}

References check_row_swap(), cols, Eigen::Dynamic, eigen_assert, m, m1, m2(), rows, Eigen::value, VERIFY, and VERIFY_IS_APPROX.

Referenced by EIGEN_DECLARE_TEST().