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

#include <AssignEvaluator.h>

List of all members.

Public Types
enum	{ DstFlags = DstEvaluator::Flags, SrcFlags = SrcEvaluator::Flags, RequiredAlignment = unpacket_traits<PacketType>::alignment }
enum	{ DstAlignment = DstEvaluator::Alignment, SrcAlignment = SrcEvaluator::Alignment, DstHasDirectAccess = DstFlags & DirectAccessBit, JointAlignment = EIGEN_PLAIN_ENUM_MIN(DstAlignment,SrcAlignment) }
enum	{ Traversal, Vectorized }
enum	{ Unrolling }
typedef DstEvaluator::XprType	Dst
typedef Dst::Scalar	DstScalar
typedef find_best_packet < DstScalar, Dst::SizeAtCompileTime >::type	PacketType
Private Types
enum	{   InnerSize, InnerMaxSize, OuterStride = int(outer_stride_at_compile_time<Dst>::ret), MaxSizeAtCompileTime = Dst::SizeAtCompileTime,   PacketSize = unpacket_traits<PacketType>::size }
enum	{ DstIsRowMajor = DstFlags&RowMajorBit, SrcIsRowMajor = SrcFlags&RowMajorBit, StorageOrdersAgree = (int(DstIsRowMajor) == int(SrcIsRowMajor)), MightVectorize }
enum	{ UnrollingLimit = EIGEN_UNROLLING_LIMIT * (Vectorized ? int(PacketSize) : 1) }

---

Detailed Description

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

Definition at line 28 of file AssignEvaluator.h.

---

Member Typedef Documentation

template<typename DstEvaluator , typename SrcEvaluator , typename AssignFunc >

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

Definition at line 30 of file AssignEvaluator.h.

template<typename DstEvaluator , typename SrcEvaluator , typename AssignFunc >

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

Definition at line 31 of file AssignEvaluator.h.

template<typename DstEvaluator , typename SrcEvaluator , typename AssignFunc >

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

Definition at line 33 of file AssignEvaluator.h.

---

Member Enumeration Documentation

template<typename DstEvaluator , typename SrcEvaluator , typename AssignFunc >

anonymous enum

Enumerator:

DstFlags
SrcFlags
RequiredAlignment

Definition at line 35 of file AssignEvaluator.h.

       {
    DstFlags = DstEvaluator::Flags,
    SrcFlags = SrcEvaluator::Flags,
    RequiredAlignment = unpacket_traits<PacketType>::alignment
  };

template<typename DstEvaluator , typename SrcEvaluator , typename AssignFunc >

anonymous enum

Enumerator:

DstAlignment
SrcAlignment
DstHasDirectAccess
JointAlignment

Definition at line 42 of file AssignEvaluator.h.

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

template<typename DstEvaluator , typename SrcEvaluator , typename AssignFunc >

anonymous enum [private]

Enumerator:

InnerSize
InnerMaxSize
OuterStride
MaxSizeAtCompileTime
PacketSize

Definition at line 50 of file AssignEvaluator.h.

       {
    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,
    PacketSize = unpacket_traits<PacketType>::size
  };

template<typename DstEvaluator , typename SrcEvaluator , typename AssignFunc >

anonymous enum [private]

Enumerator:

DstIsRowMajor
SrcIsRowMajor
StorageOrdersAgree
MightVectorize

Definition at line 62 of file AssignEvaluator.h.

       {
    DstIsRowMajor = DstFlags&RowMajorBit,
    SrcIsRowMajor = SrcFlags&RowMajorBit,
    StorageOrdersAgree = (int(DstIsRowMajor) == int(SrcIsRowMajor)),
    MightVectorize = StorageOrdersAgree
                  && (int(DstFlags) & int(SrcFlags) & ActualPacketAccessBit)
                  && (functor_traits<AssignFunc>::PacketAccess),
    MayInnerVectorize  = MightVectorize
                       && int(InnerSize)!=Dynamic && int(InnerSize)%int(PacketSize)==0
                       && int(OuterStride)!=Dynamic && int(OuterStride)%int(PacketSize)==0
                       && int(JointAlignment)>=int(RequiredAlignment),
    MayLinearize = StorageOrdersAgree && (int(DstFlags) & int(SrcFlags) & LinearAccessBit),
    MayLinearVectorize = MightVectorize && MayLinearize && DstHasDirectAccess
                       && ((int(DstAlignment)>=int(RequiredAlignment)) || 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  = MightVectorize && DstHasDirectAccess
                       && (int(InnerMaxSize)==Dynamic || int(InnerMaxSize)>=3*PacketSize)
      /* 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 */
  };

template<typename DstEvaluator , typename SrcEvaluator , typename AssignFunc >

anonymous enum

Enumerator:

Traversal
Vectorized

Definition at line 86 of file AssignEvaluator.h.

       {
    Traversal = 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
  };

template<typename DstEvaluator , typename SrcEvaluator , typename AssignFunc >

anonymous enum [private]

Enumerator:

UnrollingLimit

Definition at line 98 of file AssignEvaluator.h.

       {
    UnrollingLimit      = EIGEN_UNROLLING_LIMIT * (Vectorized ? int(PacketSize) : 1),
    MayUnrollCompletely = int(Dst::SizeAtCompileTime) != Dynamic
                       && int(Dst::SizeAtCompileTime) * int(SrcEvaluator::CoeffReadCost) <= int(UnrollingLimit),
    MayUnrollInner      = int(InnerSize) != Dynamic
                       && int(InnerSize) * int(SrcEvaluator::CoeffReadCost) <= int(UnrollingLimit)
  };

template<typename DstEvaluator , typename SrcEvaluator , typename AssignFunc >

anonymous enum

Enumerator:

Unrolling

Definition at line 107 of file AssignEvaluator.h.

       {
    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) && (int(DstAlignment)>=int(RequiredAlignment)) ? int(CompleteUnrolling)
                                                                                             : int(NoUnrolling) )
              : int(Traversal) == int(LinearTraversal)
                ? ( bool(MayUnrollCompletely) ? int(CompleteUnrolling) 
                                              : int(NoUnrolling) )
              : int(NoUnrolling)
  };

---

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

• AssignEvaluator.h