Eigen::internal::copy_using_evaluator_traits< DstEvaluator, SrcEvaluator, AssignFunc > Struct Template Reference

#include <src/eigen/Eigen/src/Core/AssignEvaluator.h>

Public Types
enum	{ DstFlags = DstEvaluator::Flags , SrcFlags = SrcEvaluator::Flags }
enum	{ DstAlignment = DstEvaluator::Alignment , SrcAlignment = SrcEvaluator::Alignment , DstHasDirectAccess = (DstFlags & DirectAccessBit) == DirectAccessBit , JointAlignment = EIGEN_PLAIN_ENUM_MIN(DstAlignment,SrcAlignment) }
enum	{ LinearRequiredAlignment = unpacket_traits<LinearPacketType>::alignment , InnerRequiredAlignment = unpacket_traits<InnerPacketType>::alignment }
enum	{ Traversal , Vectorized }
enum	{ Unrolling }
typedef DstEvaluator::XprType	Dst
typedef Dst::Scalar	DstScalar
typedef conditional< int(Traversal)==LinearVectorizedTraversal, LinearPacketType, InnerPacketType >::type	PacketType

Private Types
enum	{ InnerSize , InnerMaxSize , OuterStride = int(outer_stride_at_compile_time<Dst>::ret) , MaxSizeAtCompileTime = Dst::SizeAtCompileTime }
enum	{ LinearPacketSize = unpacket_traits<LinearPacketType>::size , InnerPacketSize = unpacket_traits<InnerPacketType>::size }
enum	{   DstIsRowMajor = DstFlags&RowMajorBit , SrcIsRowMajor = SrcFlags&RowMajorBit , StorageOrdersAgree = (int(DstIsRowMajor) == int(SrcIsRowMajor)) , MightVectorize ,   MayInnerVectorize , MayLinearize = bool(StorageOrdersAgree) && (int(DstFlags) & int(SrcFlags) & LinearAccessBit) , MayLinearVectorize , MaySliceVectorize }
enum	{ ActualPacketSize , UnrollingLimit = EIGEN_UNROLLING_LIMIT * ActualPacketSize }
typedef find_best_packet< DstScalar, Dst::SizeAtCompileTime >::type	LinearPacketType
typedef find_best_packet< DstScalar, InnerSize >::type	InnerPacketType

Detailed Description

template<typename DstEvaluator, typename SrcEvaluator, typename AssignFunc>
struct Eigen::internal::copy_using_evaluator_traits< DstEvaluator, SrcEvaluator, AssignFunc >

Member Typedef Documentation

Dst

template<typename DstEvaluator , typename SrcEvaluator , typename AssignFunc >

typedef DstEvaluator::XprType Eigen::internal::copy_using_evaluator_traits< DstEvaluator, SrcEvaluator, AssignFunc >::Dst

DstScalar

template<typename DstEvaluator , typename SrcEvaluator , typename AssignFunc >

typedef Dst::Scalar Eigen::internal::copy_using_evaluator_traits< DstEvaluator, SrcEvaluator, AssignFunc >::DstScalar

InnerPacketType

template<typename DstEvaluator , typename SrcEvaluator , typename AssignFunc >

typedef find_best_packet<DstScalar,InnerSize>::type Eigen::internal::copy_using_evaluator_traits< DstEvaluator, SrcEvaluator, AssignFunc >::InnerPacketType

private

LinearPacketType

template<typename DstEvaluator , typename SrcEvaluator , typename AssignFunc >

typedef find_best_packet<DstScalar,Dst::SizeAtCompileTime>::type Eigen::internal::copy_using_evaluator_traits< DstEvaluator, SrcEvaluator, AssignFunc >::LinearPacketType

private

PacketType

template<typename DstEvaluator , typename SrcEvaluator , typename AssignFunc >

typedef conditional<int(Traversal)==LinearVectorizedTraversal,LinearPacketType,InnerPacketType>::type Eigen::internal::copy_using_evaluator_traits< DstEvaluator, SrcEvaluator, AssignFunc >::PacketType

Member Enumeration Documentation

anonymous enum

template<typename DstEvaluator , typename SrcEvaluator , typename AssignFunc >

anonymous enum

Enumerator
DstFlags
SrcFlags

       {
    DstFlags = DstEvaluator::Flags,
    SrcFlags = SrcEvaluator::Flags
  };

anonymous enum

template<typename DstEvaluator , typename SrcEvaluator , typename AssignFunc >

anonymous enum

Enumerator
DstAlignment
SrcAlignment
DstHasDirectAccess
JointAlignment

       {
    DstAlignment = DstEvaluator::Alignment,
    SrcAlignment = SrcEvaluator::Alignment,
    DstHasDirectAccess = (DstFlags & DirectAccessBit) == DirectAccessBit,
    JointAlignment = EIGEN_PLAIN_ENUM_MIN(DstAlignment,SrcAlignment)
  };

anonymous enum

template<typename DstEvaluator , typename SrcEvaluator , typename AssignFunc >

anonymous enum

private

Enumerator
InnerSize
InnerMaxSize
OuterStride
MaxSizeAtCompileTime

       {
    InnerSize = int(Dst::IsVectorAtCompileTime) ? int(Dst::SizeAtCompileTime)
              : int(DstFlags)&RowMajorBit ? int(Dst::ColsAtCompileTime)
              : int(Dst::RowsAtCompileTime),
    InnerMaxSize = int(Dst::IsVectorAtCompileTime) ? int(Dst::MaxSizeAtCompileTime)
              : int(DstFlags)&RowMajorBit ? int(Dst::MaxColsAtCompileTime)
              : int(Dst::MaxRowsAtCompileTime),
    OuterStride = int(outer_stride_at_compile_time<Dst>::ret),
    MaxSizeAtCompileTime = Dst::SizeAtCompileTime
  };

anonymous enum

template<typename DstEvaluator , typename SrcEvaluator , typename AssignFunc >

anonymous enum

private

Enumerator
LinearPacketSize
InnerPacketSize

       {
    LinearPacketSize = unpacket_traits<LinearPacketType>::size,
    InnerPacketSize = unpacket_traits<InnerPacketType>::size
  };

anonymous enum

template<typename DstEvaluator , typename SrcEvaluator , typename AssignFunc >

anonymous enum

Enumerator
LinearRequiredAlignment
InnerRequiredAlignment

       {
    LinearRequiredAlignment = unpacket_traits<LinearPacketType>::alignment,
    InnerRequiredAlignment = unpacket_traits<InnerPacketType>::alignment
  };

anonymous enum

template<typename DstEvaluator , typename SrcEvaluator , typename AssignFunc >

anonymous enum

private

Enumerator
DstIsRowMajor
SrcIsRowMajor
StorageOrdersAgree
MightVectorize
MayInnerVectorize
MayLinearize
MayLinearVectorize
MaySliceVectorize

       {
    DstIsRowMajor = DstFlags&RowMajorBit,
    SrcIsRowMajor = SrcFlags&RowMajorBit,
    StorageOrdersAgree = (int(DstIsRowMajor) == int(SrcIsRowMajor)),
    MightVectorize = bool(StorageOrdersAgree)
                  && (int(DstFlags) & int(SrcFlags) & ActualPacketAccessBit)
                  && bool(functor_traits<AssignFunc>::PacketAccess),
    MayInnerVectorize  = MightVectorize
                       && int(InnerSize)!=Dynamic && int(InnerSize)%int(InnerPacketSize)==0
                       && int(OuterStride)!=Dynamic && int(OuterStride)%int(InnerPacketSize)==0
                       && (EIGEN_UNALIGNED_VECTORIZE  || int(JointAlignment)>=int(InnerRequiredAlignment)),
    MayLinearize = bool(StorageOrdersAgree) && (int(DstFlags) & int(SrcFlags) & LinearAccessBit),
    MayLinearVectorize = bool(MightVectorize) && bool(MayLinearize) && bool(DstHasDirectAccess)
                       && (EIGEN_UNALIGNED_VECTORIZE || (int(DstAlignment)>=int(LinearRequiredAlignment)) || MaxSizeAtCompileTime == Dynamic),
      /* If the destination isn't aligned, we have to do runtime checks and we don't unroll,
         so it's only good for large enough sizes. */
    MaySliceVectorize  = bool(MightVectorize) && bool(DstHasDirectAccess)
                       && (int(InnerMaxSize)==Dynamic || int(InnerMaxSize)>=(EIGEN_UNALIGNED_VECTORIZE?InnerPacketSize:(3*InnerPacketSize)))
      /* slice vectorization can be slow, so we only want it if the slices are big, which is
         indicated by InnerMaxSize rather than InnerSize, think of the case of a dynamic block
         in a fixed-size matrix
         However, with EIGEN_UNALIGNED_VECTORIZE and unrolling, slice vectorization is still worth it */
  };

anonymous enum

template<typename DstEvaluator , typename SrcEvaluator , typename AssignFunc >

anonymous enum

Enumerator
Traversal
Vectorized

       {
    Traversal = int(MayLinearVectorize) && (LinearPacketSize>InnerPacketSize) ? int(LinearVectorizedTraversal)
              : int(MayInnerVectorize)   ? int(InnerVectorizedTraversal)
              : int(MayLinearVectorize)  ? int(LinearVectorizedTraversal)
              : int(MaySliceVectorize)   ? int(SliceVectorizedTraversal)
              : int(MayLinearize)        ? int(LinearTraversal)
                                         : int(DefaultTraversal),
    Vectorized = int(Traversal) == InnerVectorizedTraversal
              || int(Traversal) == LinearVectorizedTraversal
              || int(Traversal) == SliceVectorizedTraversal
  };

anonymous enum

template<typename DstEvaluator , typename SrcEvaluator , typename AssignFunc >

anonymous enum

private

Enumerator
ActualPacketSize
UnrollingLimit

       {
    ActualPacketSize    = int(Traversal)==LinearVectorizedTraversal ? LinearPacketSize
                        : Vectorized ? InnerPacketSize
                        : 1,
    UnrollingLimit      = EIGEN_UNROLLING_LIMIT * ActualPacketSize,
    MayUnrollCompletely = int(Dst::SizeAtCompileTime) != Dynamic
                       && int(Dst::SizeAtCompileTime) * (int(DstEvaluator::CoeffReadCost)+int(SrcEvaluator::CoeffReadCost)) <= int(UnrollingLimit),
    MayUnrollInner      = int(InnerSize) != Dynamic
                       && int(InnerSize) * (int(DstEvaluator::CoeffReadCost)+int(SrcEvaluator::CoeffReadCost)) <= int(UnrollingLimit)
  };

anonymous enum

template<typename DstEvaluator , typename SrcEvaluator , typename AssignFunc >

anonymous enum

Enumerator
Unrolling

       {
    Unrolling = (int(Traversal) == int(InnerVectorizedTraversal) || int(Traversal) == int(DefaultTraversal))
                ? (
                    int(MayUnrollCompletely) ? int(CompleteUnrolling)
                  : int(MayUnrollInner)      ? int(InnerUnrolling)
                                             : int(NoUnrolling)
                  )
              : int(Traversal) == int(LinearVectorizedTraversal)
                ? ( bool(MayUnrollCompletely) && ( EIGEN_UNALIGNED_VECTORIZE || (int(DstAlignment)>=int(LinearRequiredAlignment)))
                          ? int(CompleteUnrolling)
                          : int(NoUnrolling) )
              : int(Traversal) == int(LinearTraversal)
                ? ( bool(MayUnrollCompletely) ? int(CompleteUnrolling) 
                                              : int(NoUnrolling) )
#if EIGEN_UNALIGNED_VECTORIZE
              : int(Traversal) == int(SliceVectorizedTraversal)
                ? ( bool(MayUnrollInner) ? int(InnerUnrolling)
                                         : int(NoUnrolling) )
#endif
              : int(NoUnrolling)
  };

---

The documentation for this struct was generated from the following file:

• src/eigen/Eigen/src/Core/AssignEvaluator.h