#include "main.h"
#include <typeinfo>

Classes
struct	vectorization_logic< Scalar, Enable >

struct	vectorization_logic< Scalar, false >

struct	vectorization_logic_half< Scalar, Enable >

struct	vectorization_logic_half< Scalar, false >

Macros
#define	EIGEN_DEBUG_ASSIGN

Functions
template<typename Dst , typename Src >
bool	test_assign (const Dst &, const Src &, int traversal, int unrolling)

template<typename Dst , typename Src >
bool	test_assign (int traversal, int unrolling)

template<typename Xpr >
bool	test_redux (const Xpr &, int traversal, int unrolling)

	EIGEN_DECLARE_TEST (vectorization_logic)

Macro Definition Documentation

◆ EIGEN_DEBUG_ASSIGN

#define EIGEN_DEBUG_ASSIGN

Function Documentation

◆ EIGEN_DECLARE_TEST()

EIGEN_DECLARE_TEST ( vectorization_logic )

                                         {
 #ifdef EIGEN_VECTORIZE
  
   CALL_SUBTEST(vectorization_logic<int>::run());
   CALL_SUBTEST(vectorization_logic<float>::run());
   CALL_SUBTEST(vectorization_logic<double>::run());
   CALL_SUBTEST(vectorization_logic<std::complex<float> >::run());
   CALL_SUBTEST(vectorization_logic<std::complex<double> >::run());
  
   CALL_SUBTEST(vectorization_logic_half<int>::run());
   CALL_SUBTEST(vectorization_logic_half<float>::run());
   CALL_SUBTEST(vectorization_logic_half<double>::run());
   CALL_SUBTEST(vectorization_logic_half<std::complex<float> >::run());
   CALL_SUBTEST(vectorization_logic_half<std::complex<double> >::run());
  
   if (internal::packet_traits<float>::Vectorizable) {
     VERIFY(test_assign(Matrix<float, 3, 3>(), Matrix<float, 3, 3>() + Matrix<float, 3, 3>(),
                        internal::packet_traits<float>::Vectorizable && EIGEN_UNALIGNED_VECTORIZE
                            ? LinearVectorizedTraversal
                            : LinearTraversal,
                        CompleteUnrolling));
  
     VERIFY(test_redux(Matrix<float, 5, 2>(),
                       internal::packet_traits<float>::Vectorizable && EIGEN_UNALIGNED_VECTORIZE
                           ? LinearVectorizedTraversal
                           : LinearTraversal,
                       CompleteUnrolling));
   }
  
   if (internal::packet_traits<double>::Vectorizable) {
     VERIFY(test_assign(Matrix<double, 3, 3>(), Matrix<double, 3, 3>() + Matrix<double, 3, 3>(),
                        internal::packet_traits<double>::Vectorizable && EIGEN_UNALIGNED_VECTORIZE
                            ? LinearVectorizedTraversal
                            : LinearTraversal,
                        CompleteUnrolling));
  
     VERIFY(test_redux(Matrix<double, 7, 3>(),
                       internal::packet_traits<double>::Vectorizable && EIGEN_UNALIGNED_VECTORIZE
                           ? LinearVectorizedTraversal
                           : LinearTraversal,
                       CompleteUnrolling));
   }
 #endif  // EIGEN_VECTORIZE
 }

References CALL_SUBTEST, Eigen::CompleteUnrolling, EIGEN_UNALIGNED_VECTORIZE, Eigen::LinearTraversal, Eigen::LinearVectorizedTraversal, run(), test_assign(), test_redux(), and VERIFY.

◆ test_assign() [1/2]

template<typename Dst , typename Src >

bool test_assign	(	const Dst &	,
		const Src &	,
		int	traversal,
		int	unrolling
	)

                                                                        {
   EIGEN_STATIC_ASSERT_SAME_MATRIX_SIZE(Dst, Src);
   typedef internal::copy_using_evaluator_traits<internal::evaluator<Dst>, internal::evaluator<Src>,
                                                 internal::assign_op<typename Dst::Scalar, typename Src::Scalar> >
       traits;
   // If traversal or unrolling are negative, ignore.
   bool res = traversal > -1 ? traits::Traversal == traversal : true;
   if (unrolling > -1) {
     if (unrolling == InnerUnrolling + CompleteUnrolling) {
       res = res && (int(traits::Unrolling) == InnerUnrolling || int(traits::Unrolling) == CompleteUnrolling);
     } else {
       res = res && int(traits::Unrolling) == unrolling;
     }
   }
   if (!res) {
     std::cerr << "Src: " << demangle_flags(Src::Flags) << std::endl;
     std::cerr << "     " << demangle_flags(internal::evaluator<Src>::Flags) << std::endl;
     std::cerr << "Dst: " << demangle_flags(Dst::Flags) << std::endl;
     std::cerr << "     " << demangle_flags(internal::evaluator<Dst>::Flags) << std::endl;
     traits::debug();
     std::cerr << " Expected Traversal == " << demangle_traversal(traversal) << " got "
               << demangle_traversal(traits::Traversal) << "\n";
     std::cerr << " Expected Unrolling == " << demangle_unrolling(unrolling) << " got "
               << demangle_unrolling(traits::Unrolling) << "\n";
   }
   return res;
 }

References Eigen::CompleteUnrolling, EIGEN_STATIC_ASSERT_SAME_MATRIX_SIZE, Eigen::InnerUnrolling, int(), and res.

Referenced by EIGEN_DECLARE_TEST(), vectorization_logic< Scalar, Enable >::run(), and vectorization_logic_half< Scalar, Enable >::run().

◆ test_assign() [2/2]

template<typename Dst , typename Src >

bool test_assign	(	int	traversal,
		int	unrolling
	)

                                                {
   EIGEN_STATIC_ASSERT_SAME_MATRIX_SIZE(Dst, Src);
   typedef internal::copy_using_evaluator_traits<internal::evaluator<Dst>, internal::evaluator<Src>,
                                                 internal::assign_op<typename Dst::Scalar, typename Src::Scalar> >
       traits;
   bool res = traits::Traversal == traversal && traits::Unrolling == unrolling;
   if (!res) {
     std::cerr << "Src: " << demangle_flags(Src::Flags) << std::endl;
     std::cerr << "     " << demangle_flags(internal::evaluator<Src>::Flags) << std::endl;
     std::cerr << "Dst: " << demangle_flags(Dst::Flags) << std::endl;
     std::cerr << "     " << demangle_flags(internal::evaluator<Dst>::Flags) << std::endl;
     traits::debug();
     std::cerr << " Expected Traversal == " << demangle_traversal(traversal) << " got "
               << demangle_traversal(traits::Traversal) << "\n";
     std::cerr << " Expected Unrolling == " << demangle_unrolling(unrolling) << " got "
               << demangle_unrolling(traits::Unrolling) << "\n";
   }
   return res;
 }

References EIGEN_STATIC_ASSERT_SAME_MATRIX_SIZE, and res.

◆ test_redux()

template<typename Xpr >

bool test_redux	(	const Xpr &	,
		int	traversal,
		int	unrolling
	)

                                                           {
   typedef typename Xpr::Scalar Scalar;
   typedef internal::redux_traits<internal::scalar_sum_op<Scalar, Scalar>, internal::redux_evaluator<Xpr> > traits;
  
   bool res = traits::Traversal == traversal && traits::Unrolling == unrolling;
   if (!res) {
     std::cerr << demangle_flags(Xpr::Flags) << std::endl;
     std::cerr << demangle_flags(internal::evaluator<Xpr>::Flags) << std::endl;
     traits::debug();
  
     std::cerr << " Expected Traversal == " << demangle_traversal(traversal) << " got "
               << demangle_traversal(traits::Traversal) << "\n";
     std::cerr << " Expected Unrolling == " << demangle_unrolling(unrolling) << " got "
               << demangle_unrolling(traits::Unrolling) << "\n";
   }
   return res;
 }

References res.