rvalue_types.cpp File Reference

#include "main.h"
#include "MovableScalar.h"
#include "SafeScalar.h"
#include <Eigen/Core>

Macros
#define	EIGEN_RUNTIME_NO_MALLOC

Functions
template<typename MatrixType >
void	rvalue_copyassign (const MatrixType &m)
template<typename TranspositionsType >
void	rvalue_transpositions (Index rows)
template<typename MatrixType >
void	rvalue_move (const MatrixType &m)
	EIGEN_DECLARE_TEST (rvalue_types)

Macro Definition Documentation

EIGEN_RUNTIME_NO_MALLOC

#define EIGEN_RUNTIME_NO_MALLOC

Function Documentation

EIGEN_DECLARE_TEST()

EIGEN_DECLARE_TEST

(

rvalue_types

)

                                 {
  for (int i = 0; i < g_repeat; i++) {
    CALL_SUBTEST_1(rvalue_copyassign(MatrixXf::Random(50, 50).eval()));
    CALL_SUBTEST_1(rvalue_copyassign(ArrayXXf::Random(50, 50).eval()));
 
    CALL_SUBTEST_1(rvalue_copyassign(Matrix<float, 1, Dynamic>::Random(50).eval()));
    CALL_SUBTEST_1(rvalue_copyassign(Array<float, 1, Dynamic>::Random(50).eval()));
 
    CALL_SUBTEST_1(rvalue_copyassign(Matrix<float, Dynamic, 1>::Random(50).eval()));
    CALL_SUBTEST_1(rvalue_copyassign(Array<float, Dynamic, 1>::Random(50).eval()));
 
    CALL_SUBTEST_2(rvalue_copyassign(Array<float, 2, 1>::Random().eval()));
    CALL_SUBTEST_2(rvalue_copyassign(Array<float, 3, 1>::Random().eval()));
    CALL_SUBTEST_2(rvalue_copyassign(Array<float, 4, 1>::Random().eval()));
 
    CALL_SUBTEST_2(rvalue_copyassign(Array<float, 2, 2>::Random().eval()));
    CALL_SUBTEST_2(rvalue_copyassign(Array<float, 3, 3>::Random().eval()));
    CALL_SUBTEST_2(rvalue_copyassign(Array<float, 4, 4>::Random().eval()));
 
    CALL_SUBTEST_3((rvalue_transpositions<PermutationMatrix<Dynamic, Dynamic, int> >(
        internal::random<int>(1, EIGEN_TEST_MAX_SIZE))));
    CALL_SUBTEST_3((rvalue_transpositions<PermutationMatrix<Dynamic, Dynamic, Index> >(
        internal::random<int>(1, EIGEN_TEST_MAX_SIZE))));
    CALL_SUBTEST_4(
        (rvalue_transpositions<Transpositions<Dynamic, Dynamic, int> >(internal::random<int>(1, EIGEN_TEST_MAX_SIZE))));
    CALL_SUBTEST_4((rvalue_transpositions<Transpositions<Dynamic, Dynamic, Index> >(
        internal::random<int>(1, EIGEN_TEST_MAX_SIZE))));
 
    CALL_SUBTEST_5(rvalue_move(Eigen::Matrix<MovableScalar<float>, 1, 3>::Random().eval()));
    CALL_SUBTEST_5(rvalue_move(Eigen::Matrix<SafeScalar<float>, 1, 3>::Random().eval()));
    CALL_SUBTEST_5(rvalue_move(Eigen::Matrix<SafeScalar<float>, Eigen::Dynamic, Eigen::Dynamic>::Random(1, 3).eval()));
  }
}

References CALL_SUBTEST_1, CALL_SUBTEST_2, CALL_SUBTEST_3, CALL_SUBTEST_4, CALL_SUBTEST_5, Eigen::Dynamic, EIGEN_TEST_MAX_SIZE, eval(), Eigen::g_repeat, i, rvalue_copyassign(), rvalue_move(), and rvalue_transpositions().

rvalue_copyassign()

template<typename MatrixType >

void rvalue_copyassign

(

const MatrixType &

m

)

                                            {
  typedef typename internal::traits<MatrixType>::Scalar Scalar;
 
  // create a temporary which we are about to destroy by moving
  MatrixType tmp = m;
  std::uintptr_t src_address = reinterpret_cast<std::uintptr_t>(tmp.data());
 
  Eigen::internal::set_is_malloc_allowed(false);  // moving from an rvalue reference shall never allocate
  // move the temporary to n
  MatrixType n = std::move(tmp);
  std::uintptr_t dst_address = reinterpret_cast<std::uintptr_t>(n.data());
  if (MatrixType::RowsAtCompileTime == Dynamic || MatrixType::ColsAtCompileTime == Dynamic) {
    // verify that we actually moved the guts
    VERIFY_IS_EQUAL(src_address, dst_address);
    VERIFY_IS_EQUAL(tmp.size(), 0);
    VERIFY_IS_EQUAL(reinterpret_cast<std::uintptr_t>(tmp.data()), std::uintptr_t(0));
  }
 
  // verify that the content did not change
  Scalar abs_diff = (m - n).array().abs().sum();
  VERIFY_IS_EQUAL(abs_diff, Scalar(0));
  Eigen::internal::set_is_malloc_allowed(true);
}

References Eigen::PlainObjectBase< Derived >::data(), Eigen::Dynamic, m, n, tmp, and VERIFY_IS_EQUAL.

Referenced by EIGEN_DECLARE_TEST().

rvalue_move()

template<typename MatrixType >

void rvalue_move

(

const MatrixType &

m

)

                                      {
  // lvalue reference is copied
  MatrixType b(m);
  VERIFY_IS_EQUAL(b, m);
 
  // lvalue reference is copied
  MatrixType c{m};
  VERIFY_IS_EQUAL(c, m);
 
  // lvalue reference is copied
  MatrixType d = m;
  VERIFY_IS_EQUAL(d, m);
 
  // rvalue reference is moved - copy constructor.
  MatrixType e_src(m);
  VERIFY_IS_EQUAL(e_src, m);
  MatrixType e_dst(std::move(e_src));
  VERIFY_IS_EQUAL(e_dst, m);
 
  // rvalue reference is moved - copy constructor.
  MatrixType f_src(m);
  VERIFY_IS_EQUAL(f_src, m);
  MatrixType f_dst = std::move(f_src);
  VERIFY_IS_EQUAL(f_dst, m);
 
  // rvalue reference is moved - copy assignment.
  MatrixType g_src(m);
  VERIFY_IS_EQUAL(g_src, m);
  MatrixType g_dst;
  g_dst = std::move(g_src);
  VERIFY_IS_EQUAL(g_dst, m);
}

References b, calibrate::c, m, and VERIFY_IS_EQUAL.

Referenced by EIGEN_DECLARE_TEST().

rvalue_transpositions()

template<typename TranspositionsType >

void rvalue_transpositions

(

Index

rows

)

                                       {
  typedef typename TranspositionsType::IndicesType PermutationVectorType;
 
  PermutationVectorType vec;
  randomPermutationVector(vec, rows);
  TranspositionsType t0(vec);
 
  Eigen::internal::set_is_malloc_allowed(false);  // moving from an rvalue reference shall never allocate
 
  std::uintptr_t t0_address = reinterpret_cast<std::uintptr_t>(t0.indices().data());
 
  // Move constructors:
  TranspositionsType t1 = std::move(t0);
  std::uintptr_t t1_address = reinterpret_cast<std::uintptr_t>(t1.indices().data());
  VERIFY_IS_EQUAL(t0_address, t1_address);
  // t0 must be de-allocated:
  VERIFY_IS_EQUAL(t0.size(), 0);
  VERIFY_IS_EQUAL(reinterpret_cast<std::uintptr_t>(t0.indices().data()), std::uintptr_t(0));
 
  // Move assignment:
  t0 = std::move(t1);
  t0_address = reinterpret_cast<std::uintptr_t>(t0.indices().data());
  VERIFY_IS_EQUAL(t0_address, t1_address);
  // t1 must be de-allocated:
  VERIFY_IS_EQUAL(t1.size(), 0);
  VERIFY_IS_EQUAL(reinterpret_cast<std::uintptr_t>(t1.indices().data()), std::uintptr_t(0));
 
  Eigen::internal::set_is_malloc_allowed(true);
}

References Eigen::randomPermutationVector(), rows, and VERIFY_IS_EQUAL.

Referenced by EIGEN_DECLARE_TEST().