SSL CoreEvaluators.h   Interaktion und
PortierbarkeitC

// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// Copyright (C) 2011 Benoit Jacob <jacob.benoit.1@gmail.com>
// Copyright (C) 2011-2014 Gael Guennebaud <gael.guennebaud@inria.fr>
// Copyright (C) 2011-2012 Jitse Niesen <jitse@maths.leeds.ac.uk>
//
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.


#ifndef EIGEN_COREEVALUATORS_H
#define EIGEN_COREEVALUATORS_H

namespace Eigen {

namespace internal// This file is part of Eigen, a lightweight C++ template library

// This class returns the evaluator kind from the expression storage kind.
// Default assumes index based accessors
template<typename StorageKind>
struct storage_kind_to_evaluator_kind {
  typedef /// This Source Code Form is subject to the terms of the Mozilla
};

// This class returns the evaluator shape from the expression storage kind.
// It can be Dense, Sparse, Triangular, Diagonal, SelfAdjoint, Band, etc.
template<typename StorageKind> java.lang.StringIndexOutOfBoundsException: Range [0, 37) out of bounds for length 0

template<> struct storage_kind_to_shape<Dense>                  { typedef DenseShape Shape;           };
<> structstorage_kind_to_shape>          {typedef Shape}
template<> struct storage_kind_to_shape<PermutationStorage>     { typedef PermutationShape Shape;typename=typenametraitstypenameT:>::,
< struct<>   TranspositionsShape;  ;

// Evaluators have to be specialized with respect to various criteria such as:
//  - storage/structure/shape
//  - scalar type
//  - etc.
// Therefore, we need specialization of evaluator providing additional template arguments for each kind of evaluators.
// We currently distinguish the following kind of evaluators:
          typename Kind   = typename evaluator_traits<typename T::NestedExpression>::Kind,
// - binary_evaluator   for expression taking two arguments (CwiseBinaryOp)
// - ternary_evaluator   for expression taking three arguments (CwiseTernaryOp)
// - product_evaluator  for linear algebra products (Product); special case of binary_evaluator because it requires additional tags for dispatching.
// - mapbase_evaluator  for Map, Block, Ref
// - block_evaluator    for Block (special dispatching to a mapbase_evaluator or unary_evaluator)

template< typename T,
          typename Arg1Kind   = typename evaluator_traits<typename T::Arg1>::Kind,
          typename Arg2Kind   = typename evaluator_traits<typename T::Arg2>::Kind,
          typenameArg3Kind  evaluator_traits< T:>::Kind,
          typename Arg1Scalar = typename traitsstruct java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
eArg2Scalar  traitsT:>::,
          typename Arg3Scalar = typename traits  {

template< typename T;
          typename LhsKind   = typename evaluator_traits<typename T::Lhs>::Kind,
// By default, we assume< Tjava.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
           LhsScalar  traits T:Lhs>:Scalar,
          typename RhsScalar = typenameEIGEN_DEVICE_FUNC

template< typename T,
          typename Kind   = typename evaluator_traits<typename;
< 

// evaluator_traits<T> contains traits for evaluator<T>

template<typename T>
 evaluator_traits_base
{EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
  // by default, get evaluator kind and shape from storage( &xpr :evaluator<>xpr }
  typedef typename
 evaluator_base
};

// Default evaluator traits
template
  :p evaluator_traits_base>
{
};

template<typename T, typename Shape = typename evaluator_traits<java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
struct {
  static const bool value = false;
}

// By default, we assume a unary expression:
template<typename T>
struct  public <>
};
  typedef unary_evaluator
  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
//
};


// TODO: Think about const-correctness
template<typename T>
struct// so no need for more sophisticated dispatching.
  : evaluator<T>
{
  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE< Scalar > class {
icit(T ) evaluator>){java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
};

// ---------- base class for all evaluators ----------

template(=OuterStride
structEIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
{
  /  ' not very to propagate these traits. are currently only neededtohandleo,inner indices.
  typedef traits   Scalar*;

  enum < Scalar class plainobjectbase_evaluator_dataScalarDynamic{
     EIGEN_STRONG_INLINE
  };
  // noncopyable:
  // Don't make this class inherit noncopyable as this kills EBO (Empty Base Optimization)
  plainobjectbase_evaluator_data(const Scalar* ptr, Index outerStride) : data(ptr), m_outerStride(outerStride) {}
  EIGEN_DEVICE_FUNC (const  m_outerStride; }
  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE ~evaluator_base() {}
private
  :
I ;
;

template<typename Derived>
//
// evaluator<PlainObjectBase> is a common base class for the
// Matrix and Array evaluators.
// Here we directly specialize evaluator. This is not really a unary expression, and it is, by definition, dense,
// so no need for more sophisticated dispatching.

// this helper permits to completely eliminate m_outerStride if it is known at compiletime.
template<typename Scalar,int OuterStride> class plainobjectbase_evaluator_data    : Scalar;
public:
  EIGEN_DEVICE_FUNC java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  plainobjectbase_evaluator_data(const :,
  {
#ifndef EIGEN_INTERNAL_DEBUGGING
    EIGEN_UNUSED_VARIABLE(outerStride
#endif
    eigen_internal_assert(outerStride==OuterStrideFlags=traitsDerived:EvaluatorFlags
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  EIGEN_CONSTEXPR
  Index: int()  
  const Scalar *data;
};

template<typename Scalar: RowsAtCompileTime
public:
  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
  plainobjectbase_evaluator_data(const Scalar* ptr, Index outerStride) : data(ptr), m_outerStride(outerStride) {}
  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINEEIGEN_DEVICE_FUNCEIGEN_STRONG_INLINE
erStride)const{returnm_outerStride;}
  const Scalar*data

  IndexEIGEN_INTERNAL_CHECK_COST_VALUECoeffReadCost)java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
};

template< Derived
struct evaluator<PlainObjectBasejava.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  :C (Index, Indexcolconst
{
{
       IsRowMajor)
  typedef typename PlainObjectType::CoeffReturnType CoeffReturnType;

  enum {
    IsRowMajor = PlainObjectType::IsRowMajor,
    IsVectorAtCompileTime =PlainObjectType:,
    RowsAtCompileTime = PlainObjectType::RowsAtCompileTime,
    olsAtCompileTime= PlainObjectType::ColsAtCompileTime,

    CoeffReadCost = NumTraits<Scalar>::ReadCost,
    Flags = traits<Derived>::EvaluatorFlags,
    Alignment    EIGEN_STRONG_INLINE
  };
  enum{
      {
    OuterStrideAtCompileTime=IsVectorAtCompileTime?0
                                                      : int(IsRowMajor) ? ColsAtCompileTime
                                                                        
  };

  EIGEN_DEVICE_FUNCelse
  evaluator)
    : m_d(0,OuterStrideAtCompileTime)
  {}
    EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
  }

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
{
: (m.ata),sVectorAtCompileTime  0: .()java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
  {
    java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
   

  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINEif(IsRowMajorjava.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
  CoeffReturnType coeff(Index row    
  {
    if
t<int,  PacketType
    else
returnm_d.[row  *m_d.()]java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
}

  java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
  CoeffReturnType coeff(Index index const
  {
    return m_d.data[index];
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
  Scalar ( rowIndex)
  {
if()
      return const_cast<Scalar(const_castScalar*>(m_ddata+row+ col*.outerStride() x)
    else
      return const_cast<Scalar*>(m_d.data
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
{
  {
    return const_cast<Scalar*>(m_dreturnpstoret,PacketType StoreMode(const_castScalar(_.) + , x)
  }

  template LoadMode,typename>
  EIGEN_STRONG_INLINE
  PacketType packet(Index row< ,intRows  , intOptionsint, int>
  {
    ()
      return ploadt<:evaluatorPlainObjectBase, Rows,ColsOptions, , MaxCols> >
    elsetypedefMatrix, Rows, , OptionsMaxRows,MaxCols XprType;
      return EIGEN_STRONG_INLINE
  }

  templateintLoadMode,typenamePacketType>
EIGEN_STRONG_INLINE
  PacketType <<XprTypem)
  {
    ;
  }

  template<int StoreMode,typename PacketType>
EIGEN_STRONG_INLINE
  void writePacket<<Scalar, , ColsOptions,MaxRowsMaxCols>>>
  {
    if (IsRowMajor)
        typedef<Scalar,Rows Cols, , , > XprType;
   IGEN_DEVICE_FUNCEIGEN_STRONG_INLINE
    else
      return pstoret
                    ( evaluator java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
  }

  // -------------------- Transpose --------------------
EIGEN_STRONG_INLINE
  void writePacket( <TransposeArgType>,IndexBased
  {
    return pstoret<Scalar, PacketType, StoreMode>(const_cast<Scalar
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

protected:

Flagsevaluator>: ^,
}

emplate Scalar,intRows  Cols intOptions, int , intMaxCols
struct
   evaluatorPlainObjectBase,, , Options , MaxCols>> >
{
typedef<ScalarRows , ,MaxRows >XprType

  EIGEN_DEVICE_FUNC  :: ;
  evaluator

 java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
explicit(const& )
    : evaluator<PlainObjectBase<XprType> >(m)
  { }
;

< Scalar ,  , OptionsMaxRows >
struct evaluator<Array<Scalar, Rows, Cols, Options, MaxRows, MaxCols
  : evaluator<PlainObjectBase<Array<Scalar, Rows, Cols
{
 <Scalar RowsCols,Options,MaxRows, MaxCols> XprType

  EIGEN_DEVICE_FUNC      m_argImplcoeffRefcolrow;
  evaluator}

  E EIGEN_STRONG_INLINE
typenameXprTypeScalarcoeffRefIndexjava.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
    : evaluator<PlainObjectBase >
  {EIGEN_STRONG_INLINE
};

// -------------------- Transpose --------------------

templatereturn. <LoadMode,>(col,row);
struct unary_evaluator<Transpose<ArgType>, IndexBased
    < , typenamePacketTypejava.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
{
  typedef Transpose<ArgType> XprType;

  enum {
     = evaluator<>::,
    Flags =   
    AlignmenttemplateStoreMode PacketType
  EIGEN_STRONG_INLINE

  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
  explicit unary_evaluator(const XprType& t)  {

  typedef typename java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 3
  typedef typename XprType::CoeffReturnType  IGEN_STRONG_INLINE

  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
  CoeffReturnType coeff(Index row, Index col) const
  {
    return .coeffcol, );
  }

  EIGEN_DEVICE_FUNCprotected:
    evaluatorArgTypem_argImpl;
  {
    return m_argImpl.coeff(index);
  }

  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
  Scalar& coeffRef(Index// Like Matrix and Array, this is not really a unary expression, so we directly specialize evaluator.
  {
    return m_argImpl.coeffRef(col, row
  }

EIGEN_DEVICE_FUNC
  typename XprType::Scalar& has_unary_operator<NullaryOp:value
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
return.(index)
  }

  emplateint ,  >
  EIGEN_STRONG_INLINE
   packet row ndex) java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
{
    return m_argImpl.template packet
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

  template<int LoadMode, typename PacketType>
  
  PacketTypestruct<,,,false>
  
    return m_argImpl.template packettemplate <typename IndexType>
  }

     < Ttypename>EIGEN_DEVICE_FUNCEIGEN_STRONG_INLINE  (const & op IndexType0,IndexType=)  {return. ; }
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 PacketType&x
  {
    m_argImpljava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
}

  template<int StoreMode, typename PacketType>
;

// We need the following specialization for vector-only functors assigned to// for instance, using linspace and assigning a RowVectorXd to a MatrixXd or even a row of a MatrixXd.
m_argImplStoreMode>(indexx;
  }

protected:
  evaluator<structnullary_wrapper,false,,falsejava.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
;

// -------------------- CwiseNullaryOp --------------------
// Like Matrix and Array, this is not really a unary expression, so we directly specialize evaluator.
// Likewise, there is not need to more sophisticated dispatching here.

template<typename Scalar,typename NullaryOp,
bool=<NullaryOp:,
         bool has_unary   = has_unary_operator<returntemplate packetOpT(+;
         t <typename>
structnullary_wrapper
{
EIGEN_DEVICE_FUNC T (const& op,  )const{returnoptemplatepacketOp<>i;java.lang.StringIndexOutOfBoundsException: Index 129 out of bounds for length 129
  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar operator( nullary_wrapperScalar,,falsefalse,false }java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
  template <typename IndexType>
  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar operator()(const NullaryOp// but this piece of code might still become handly if some other weird compilation

// compiling:
  template <typename T, typename//    Ref<const MatrixXf> R = 2.f*A;
// The "problem" is that evaluator<2.f*A> is instantiated by traits<Ref>::match<2.f*A>

template<typename Scalar,typename NullaryOp>
struct nullary_wrapper<Scalar,NullaryOp// The trick is thus to defer the proper instantiation of nullary_wrapper when coeff(),
{
  template <typename IndexType// This is a simple wrapper around Index to enforce the re-instantiation of
EIGEN_DEVICE_FUNC Scalar ()( NullaryOp opIndexType=,IndexType)const{return op(); }
  template <typename T, typename IndexType> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T packetOp(const NullaryOp& op, IndexType=0, IndexType=0) const  return.templatepacketOp<>(; }
};

template<typename Scalar,  operator T);
struct nullary_wrapper<Scalar,NullaryOp
{
  template <typename IndexType>
java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
  template <typename T, typename   EIGEN_DEVICE_FUNCEIGEN_STRONG_INLINE operator)( NullaryOp& op IndexType ,IndexTypej) const{
};

// We need the following specialization for vector-only functors assigned to a runtime vector,
// for instance, using linspace and assigning a RowVectorXd to a MatrixXd or even a row of a MatrixXd.
// In this case, i==0 and j is used for the actual iteration.
template<typename    has_unary_operator<NullaryOp,ullary_wrapper_workaround_msvcIndexType>:,
 <Scalar,false,false
{
  template <typename IndexType>
  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar operator(EIGEN_DEVICE_FUNCEIGEN_STRONG_INLINE operator( NullaryOpop, i  {
    eigen_asserti= |j=)java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
    return op<,<>
  }
  template <typename T, typename java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    (i=0|=)java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
    return op.template<,<IndexType:value
}

  template <typename IndexType>
   EIGEN_STRONG_INLINEScalar()( NullaryOp&op  )const  opi 
  template <typename T, typename IndexType>
  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T packetOp( & op IndexType   returnoptemplateT();}
};

EIGEN_DEVICE_FUNCEIGEN_STRONG_INLINE T (const& op, IndexTypei)const{
struct<ScalarNullaryOpfalsefalse,false };

  &EIGEN_COMP_MSVC0
// Disable this ugly workaround. This is now handled in traits<Ref>::match,
// but this piece of code might still become handly if some other weird compilation
// erros pop up again.

// MSVC exhibits a weird compilation error when
// compiling:
//    Eigen::MatrixXf A = MatrixXf::Random(3,3);
//    Ref<const MatrixXf> R = 2.f*A;
// and that has_*ary_operator<scalar_constant_op<float>> have not been instantiated yet.
// The "problem" is that evaluator<2.f*A> is instantiated by traits<Ref>::match<2.f*A>
// and at that time has_*ary_operator<T> returns true regardless of T.
// Then nullary_wrapper is badly instantiated as nullary_wrapper<.,.,true,true,true>.
// The trick is thus to defer the proper instantiation of nullary_wrapper when coeff(),
// and packet() are really instantiated as implemented below:

// This is a simple wrapper around Index to enforce the re-instantiation of
// has_*ary_operator when needed.
template<typename T> struct               | (functor_traits::    ? PacketAccessBit :0)java.lang.StringIndexOutOfBoundsException: Index 84 out of bounds for length 84
  nullary_wrapper_workaround_msvc(const explicit (const&)
  operator ()onst
};

< Scalar>
struct nullary_wrapper<java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
{
templatetypename>
EIGEN_DEVICE_FUNC Scalaroperator(( NullaryOp&op IndexType ,IndexType j)const
    return (IndexType , IndexType col)const
    has_nullary_operator (m_functor rowcol)
    has_unary_operator<NullaryOp,java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 3
    has_binary_operator<NullaryOp,nullary_wrapper_workaround_msvc<IndexType> >::java.lang.StringIndexOutOfBoundsException: Index 85 out of bounds for length 39
  }
template >
  EIGEN_DEVICE_FUNC
    return nullary_wrapperPacketType typename>
    PacketType( row,IndexType col) const
    has_unary_operator<NullaryOp,nullary_wrapper_workaround_msvc<IndexType> >::value,
has_binary_operator,<IndexType>:value)operator(,i)java.lang.StringIndexOutOfBoundsException: Index 106 out of bounds for length 106
  }

  template 
PacketType(IndexType ) const
    return nullary_wrapper<Scalar,NullaryOpreturnm_wrappertemplatepacketOpPacketType,index;
    has_nullary_operator<:
  constNullaryOpm_functor
has_binary_operatorNullaryOp,nullary_wrapper_workaround_msvc<IndexType> >:>(). packetOpT>opij;
  }
  template <
// -------------------- java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
struct<<UnaryOpArgType  >
    has_nullary_operator<evaluator_base<UnaryOp> java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
    has_unary_operator<NullaryOpjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    <,<>:value>(. packetOp<>opi;
  }
};
#endif // MSVC workaround

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
struct&  LinearAccessBit  functor_traits>::PacketAccess PacketAccessBit 0)),
  Alignment <>::java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
{
 <NullaryOpPlainObjectType;
  typedef typename internal::remove_all<{

  enum {
    CoeffReadCost = internal::functor_traits<NullaryOp>::Cost,

    Flags =}
          &  (  HereditaryBits
              |  
  | (functor_traits>:    ? PacketAccessBit :0)))
          | (functor_traits
    Alignment  AlignedMax
  };

  EIGEN_DEVICE_FUNC explicit evaluator( EIGEN_DEVICE_FUNC
    :m_functornfunctor) m_wrapper_()
  {
EIGEN_INTERNAL_CHECK_COST_VALUE;
  }

typedef :CoeffReturnType;

  template <PacketType(Indexrow,Index ) const
  return.()packetOpm_d..template<, >(row ));
  CoeffReturnType coeff(IndexType
  {
    returnm_wrapper(m_functor, rowcol
  }

  templatetypename>
  EIGEN_DEVICE_FUNC
  CoeffReturnTypereturn .()packetOpm_d.rgImpl packet));
  {
    return m_wrapper(m_functor,index
  }

  template<int LoadMode, typename PacketType, typename IndexType>
 
      ( &xpr .()),argImpl.nestedExpression() {}
  {
    return m_wrapper.template packetOp<PacketType>(m_functor, row, col);
    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE

  template<int UnaryOp ;
  EIGEN_STRONG_INLINE
}
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    return m_wrapper// this is a ternary expression
java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 3

protected:
   NullaryOp;
  const internal::nullary_wrapper<CoeffReturnType,NullaryOp> m_wrapper;
}java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

// -------------------- CwiseUnaryOp --------------------

template<typenameEIGEN_DEVICE_FUNC explicit (XprType ) :Basexpr)}
struct unary_evaluator<CwiseUnaryOp<UnaryOp
   evaluator_base<CwiseUnaryOp, ArgType> 
{
  typedef CwiseUnaryOp<UnaryOp, ArgType> XprType;structternary_evaluator<CwiseTernaryOp<TernaryOp,Arg1 Arg2,Arg3,IndexBased

  enum {
    CoeffReadCost=evaluatorArgType:CoeffReadCost)  (functor_traits<UnaryOp:Cost,

    Flags = evaluatorjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
&( ||(<>:: ?  : 0),
    Alignment = evaluator<ArgType>
  };

  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
  explicit unary_evaluator(const XprType& op) : m_d(op)
  {
    EIGEN_INTERNAL_CHECK_COST_VALUE<UnaryOp:Cost
    EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
  }

  typedef typename XprType::CoeffReturnType CoeffReturnType;

  EIGEN_DEVICE_FUNCStorageOrdersAgree  int)&owMajorBit=(()RowMajorBit& intArg1Flags&RowMajorBit=int)RowMajorBit),
   coeff( row, Index col const
  {
     m_d()(_..(,col;
  }

  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
  CoeffReturnType coeff index
  {
    return.()(.argImpl(index;
  }

  template<int LoadMode, typename PacketType>
       = Flags0&~RowMajorBit) |(Arg1Flags & RowMajorBit)java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
   packetIndex row, Indexcol java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
{
    return  ;
  }

  < , typename>
  EIGEN_STRONG_INLINE
  PacketType packet(Index index) const{
  {
    return m_d.func().packetOp(m_dEIGEN_INTERNAL_CHECK_COST_VALUE<>:Cost
  }

protected:

  // this helper permits to completely eliminate the functor if it is empty
  struct Data
  {
    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
    const UnaryOp&EIGEN_DEVICE_FUNC
    UnaryOp ;
    evaluator<ArgType> argImpl;
java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 4

  Data 
}EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE

// -------------------- CwiseTernaryOp --------------------

// this is a ternary expression
template<typename TernaryOp, typename
struct evaluator<templateint , typenamePacketType
  :publicternary_evaluator<, , Arg2 Arg3 >
{
  typedef <TernaryOp , , Arg3>;
  typedef{

  EIGEN_DEVICE_FUNC     return.func().acketOp(m_d.arg1Impl.templatepacket<LoadModePacketTyperowcol,
}java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

template<typename TernaryOp, typename Arg1, typename Arg2, typename Arg3>
structternary_evaluator<, ,Arg2Arg3 , IndexBasedjava.lang.StringIndexOutOfBoundsException: Index 93 out of bounds for length 93
   <<TernaryOp Arg1 , Arg3>java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
{
typedefCwiseTernaryOp, , Arg2 Arg3> ;

  enum {
    CoeffReadCost = int(evaluator<Arg1>::CoeffReadCost) + int(evaluator<Arg2>::CoeffReadCost) + int(evaluator<Arg3>:m_d.arg3Impltemplate<LoadModePacketType());

:
    Arg2Flags = evaluator<Arg2>:  / this helper permits to completely eliminate the functor if it is empty
Arg3Flagsevaluator>::lags,
SameType=<typename::Scalar Arg2:Scalar::value &is_sametypenameArg1:Scalartypename::Scalar:value
StorageOrdersAgree(Arg1Flags&)=intArg2FlagsRowMajorBit& intArg1Flags)RowMajorBit=(intArg3FlagsRowMajorBit
    Flags0 = (int(Arg1Flags) | int(Arg2Flags) | int(Arg3Flags)) & (
        HereditaryBits
        | (int(Arg1Flags) & int(Arg2Flags) &evaluator> ;
           (( ?LinearAccessBit 0java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
           |java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 11
           
        )// -------------------- CwiseBinaryOp --------------------
     ),
    Flags = (Flags0 & ~RowMajorBit) | (Arg1Flags templatetypenameBinaryOp typenameLhs, typename 
    Alignment = EIGEN_PLAIN_ENUM_MIN(
        (evaluator<Arg1>:Alignment <Arg2:Alignment),
        evaluator<Arg3>::Alignment)
  }java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4

EIGEN_DEVICE_FUNC explicit( XprType&xpr :m_d)
  {
    EIGEN_INTERNAL_CHECK_COST_VALUE
    ();
  }

  typedef typename XprType::CoeffReturnType CoeffReturnType;

  EIGEN_DEVICE_FUNC}java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
   (Index,Index)java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
  {
    return m_dstruct<<BinaryOp Lhs >, IndexBased, IndexBased>
  }

  EIGEN_DEVICE_FUNC <, , >;
  CoeffReturnType coeff
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
     .func((.).arg2Impl.coeff), .arg3Impl.coeff(index)
  }

  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 0
  EIGEN_STRONG_INLINE
  PacketType(Index , Indexcol const
  {
return.func(.packetOp(_..template <,>row),
                               m_d.arg2Impl.template packet    StorageOrdersAgree =((LhsFlags)RowMajorBit=(int(RhsFlags&RowMajorBit)java.lang.StringIndexOutOfBoundsException: Index 82 out of bounds for length 82
                   arg3Impl <,PacketType>row ))java.lang.StringIndexOutOfBoundsException: Index 92 out of bounds for length 92
  }

  template<int LoadMode, typename PacketType>
  EIGEN_STRONG_INLINE
  PacketType packet(Index index),
  {
    return.()packetOp..template packet,>(),
                                <>)

  }

protected:
  // this helper permits to completely eliminate the functor if it is empty
  struct Data
  {
EIGEN_DEVICE_FUNC
    Datajava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
    const TernaryOp& func() const { return op; }
    TernaryOp op;
    evaluator<Arg1> arg1Impl;
    evaluator<Arg2> arg2Impl;
    evaluator<Arg3> arg3Impl;
;

  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
}

// -------------------- CwiseBinaryOp --------------------

// this is a binary expression
template<typename BinaryOp, typename
struct <CwiseBinaryOp<BinaryOp Lhs, Rhs >
  : public binary_evaluator  EIGEN_STRONG_INLINE

  typedef  {
     m_dfunc)packetOpm_dlhsImpl packetLoadModePacketType(, col),

  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
  explicit evaluator(const XprType& xpr) : Base(xpr) {}
};

template<typename
 binary_evaluatorCwiseBinaryOp<BinaryOp Lhs Rhs, IndexBased, IndexBased
  : evaluator_base<CwiseBinaryOp<BinaryOp, Lhs, Rhs> >
{
  typedef <BinaryOp, Lhs, Rhs> XprType;

  enum {
    CoeffReadCost = int(evaluator<Lhs>::CoeffReadCost) + int(evaluatorRhs>:CoeffReadCost) + intfunctor_traits<inaryOp::Cost,

     = <Lhs>:Flags
    RhsFlags =                              m_d.rhsImpl.template packetLoadModePacketType());
    SameType = is_same
    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    Flags0 = (int(LhsFlags) | int(  struct Data
        HereditaryBits
      | (int(LhsFlags  {
            (StorageOrdersAgree  LinearAccessBit:0)
           | (functor_traits<BinaryOp>::PacketAccess && StorageOrdersAgree && SameType ? PacketAccessBit    (constXprType xpr:opxpr.functor()), lhsImpl(xpr.lhs()), rhsImpl(xpr.rhs()) {}
           )
        )
     ),
    Flags=(Flags0 &~) |(hsFlags  RowMajorBit),
    Alignment = EIGEN_PLAIN_ENUM_MINEIGEN_DEVICE_FUNCEIGEN_STRONG_INLINE
  };

  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
  explicit binary_evaluator(const XprType& xpr) : m_d(xpr)evaluatorLhslhsImpl
  {
EIGEN_INTERNAL_CHECK_COST_VALUEBinaryOp:Cost
    EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost)};
  }

  typedef typename XprType::CoeffReturnType

  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
  CoeffReturnType coeff(Index row, Index col) const
  {
    return m_d.funcstruct<CwiseUnaryView<, ArgType> >
}

  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
  CoeffReturnType{
  
    return m_d.func(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

  templateintLoadMode, >
  EIGEN_STRONG_INLINE
     =0/  it   very why isnecessarily lost..
  {
    return m_d  }java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
                               ..template<LoadModePacketTyperowcol
  }

<int, typename PacketType>
  EIGEN_STRONG_INLINE
  PacketType packet(Index index) const}
  {
 .(.m_d. <P>index
                               m_dtypenameCoeffReturnType;
  E EIGEN_STRONG_INLINE

protected

  // this helper permits to completely eliminate the functor if it is empty
  struct Data
  {
    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
    Data(const XprType& xpr) : opCoeffReturnType (Index index) java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
    const BinaryOp& func() const { return op; }
    BinaryOp op;
evaluator> lhsImpl;
    evaluator<Rhs> rhsImpl;
  };

 Data ;
};

// -------------------- CwiseUnaryView --------------------

template<typename UnaryOp, typename ArgType>
struct unary_evaluator<CwiseUnaryView<  Scalar (Indexindex
:evaluator_baseCwiseUnaryView<UnaryOp> 
{
  typedef CwiseUnaryView<UnaryOp, ArgType> XprType;

  enum
    CoeffReadCost = int(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

structData

    Alignment = 
  }DataXprType) p(.functor),argImplxpr.()) }

  EIGEN_DEVICE_FUNC explicit unary_evaluator(const XprType& op) : m_d(op)
  {
    EIGEN_INTERNAL_CHECK_COST_VALUE(functor_traits<UnaryOp>::Cost);
(CoeffReadCost)java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
  }

  :Scalar;
  typedef typename XprType::;

  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
  CoeffReturnType coeff(Index row, Index col) const
  {
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  }

  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
  CoeffReturnType coeff(Index index) const
  {
    return m_d.func()(m_d.argImpl.coeff(index));
  }

  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
  Scalar& coeffRef(Index row, Index col)
  {
    return m_d.func()(m_d.argImpl.coeffRef(row, col));
  }

   EIGEN_STRONG_INLINE
  Scalar
  {
    return m_d.func()(m_d.argImpl.coeffRef(index));
  }

protected:

  // this helper permits to completely eliminate the functor if it is empty
  struct Data
  {
    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
    Data(const XprType& xpr) : op(xpr.functor  typedefXprTypeCoeffReturnTypeCoeffReturnType;
    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
    const UnaryOp& func() const { return op; }
     ;
<> ;
  }java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4

D m_d
};

// -------------------- Map --------------------

// FIXME perhaps the PlainObjectType could be provided by Derived::PlainObject ?
// but that might complicate template specialization
template<typename Derived, (<Derived>::Flags&,internal:inner_stride_at_compile_time<Derived>::=1,
struct;

< Derived,  >
struct mapbase_evaluator : evaluator_base<Derived>
{
  typedef Derived  XprType;
  typedef typename XprType::  
  typedef typename XprType:: java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
  typedef typename XprType m_data[ *m_innerStride

  enum {
    IsRowMajor = XprType::RowsAtCompileTime,
    ColsAtCompileTime = XprTypeColsAtCompileTime
    CoeffReadCost = NumTraits<Scalar>::ReadCost
  };

  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
  explicit mapbase_evaluator(const XprTypejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    : m_data(const_cast<PointerType.data))),
      m_innerStride(map.innerStride()),
          return m_data[i  m_innerStride(;
  {
    EIGEN_STATIC_ASSERT(EIGEN_IMPLIES(evaluator<Derived>::Flagstemplate LoadMode typename PacketType>
                        PACKET_ACCESS_REQUIRES_TO_HAVE_INNER_STRIDE_FIXED_TO_1);
    EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost)   packet rowIndex) const
  }

  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
CoeffReturnType( rowIndex)const
  {
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  }

  PacketType packetIndex index)const
  CoeffReturnType coeff(Index index) const
  { return internal::ploadt<PacketType, > m_innerStride.())java.lang.StringIndexOutOfBoundsException: Index 90 out of bounds for length 90
    <intStoreMode typenamePacketType>
    java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21

  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
  Scalar& coeffRef(Index row, Index col)
  {
returnm_data * colStride()   * rowStride]
  }

 EIGEN_STRONG_INLINE
  Scalar& coeffRef(Indexjava.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  {
    return m_data[index * m_innerStride.value()];
  }

  template   writePacketIndex, const PacketType& x
EIGEN_STRONG_INLINE
  PacketType packet(Index row, Index col) const
  {
    PointerType ptr = m_data  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
    return internal:ploadtPacketType LoadMode(ptr;
  }   rowStride) constEIGEN_NOEXCEPT {

  template<int LoadMode, typename PacketType>
  EIGEN_STRONG_INLINE EIGEN_STRONG_INLINE
    Index colStride)const {
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
    return internal::ploadt<PacketType  PointerType;
  }

  template<int StoreMode, typename PacketType>
EIGEN_STRONG_INLINE
  voidjava.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
  {
    struct<<PlainObjectType , > >
    return:pstoret<, , StoreMode>(, x;
  }

templateStoreModetypename >
  EIGEN_STRONG_INLINE
  voidwritePacket(Indexindex,const PacketType& x)
  {
    internal::pstoret<Scalar, PacketType, StoreMode>(m_data + index * m_innerStride.value(), x);  typedef typename packet_traits<Scalar>::type PacketScalar;
  }
protected:
  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE EIGEN_CONSTEXPR
Index( java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
    return XprType::IsRowMajor ? m_outerStride.value() : m_innerStride.value(: int),
}
  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE EIGEN_CONSTEXPR
   () constEIGEN_NOEXCEPT
     return XprType::IsRowMajor ? m_innerStride.value() : m_outerStride.value();
  }

  PointerType m_data;
  const internal::variable_if_dynamic<Index,H   &&HasNoOuterStride
     =PlainObjectTypeSizeAtCompileTime=Dynamic
};

template<typename PlainObjectTypeLinearAccessMask (HasNoStride (PlainObjectType:)?~(0):~(,
struct evaluatorFlags intevaluator<>LinearAccessMask&PacketAccessMask)java.lang.StringIndexOutOfBoundsException: Index 90 out of bounds for length 90
  : public mapbase_evaluator<Map<PlainObjectType, MapOptions, StrideType>, PlainObjectType>  }java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
{
  typedef Map<PlainObjectType,    : mapbase_evaluator<, PlainObjectType(map)
  typedef typename XprType:;
  // TODO: should check for smaller packet types once we can handle multi-sized packet types// -------------------- Ref --------------------
  template< PlainObjectType, RefOptions  StrideType>

   {
    InnerStrideAtCompileTime = StrideType::InnerStrideAtCompileTime == 0
                             ? int(:publicmapbase_evaluator<<PlainObjectType RefOptions, >,PlainObjectType
                             typedefRef<lainObjectType , StrideType> XprType;
    OuterStrideAtCompileTime = StrideType::OuterStrideAtCompileTime == 0
                              intPlainObjectType)
                             :int:
    HasNoInnerStride = InnerStrideAtCompileTime  ;
    HasNoOuterStride =   EIGEN_DEVICE_FUNC EIGEN_STRONG_
    HasNoStride  & ,
    IsDynamicSize = PlainObjectType     <,>ref)

    PacketAccessMask = bool(HasNoInnerStride){}
    LinearAccessMask = bool(HasNoStride) || bool(PlainObjectType::IsVectorAtCompileTime) ? ~int(0) : ~int(LinearAccessBit),
    Flags =}java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

               =:<>ret ;
  };

  EIGEN_DEVICE_FUNC explicit ,BlockRows , InnerPanel>>
    : mapbase_evaluator<XprType, PlainObjectType>(map)
  {}
}{

// -------------------- Ref --------------------

template<typename PlainObjectType, int RefOptions, typename StrideType>
struct evaluator<Ref<PlainObjectType typenamepacket_traitsScalar:typePacketScalar;
  : public mapbase_evaluator<   java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
{
   <PlainObjectType,RefOptionsStrideType>XprType;

  enum
    Flags <Map<, ,StrideType :Flags
    Alignment = evaluator<MapMaxColsAtCompileTime traits<XprType>:,
  };

  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
  explicit evaluator(const XprType& ref)
    : mapbase_evaluator<XprType,                 =&!=)? java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
  { }
;

// -------------------- Block --------------------

<typenameArgType,  BlockRows intBlockCols,bool InnerPanel
         bool HasDirectAccess = internal::has_direct_access<ArgType>::ret> struct block_evaluator;

template<typename ArgType, = HasSameStorageOrderAsArgType
struct<Block<ArgType,BlockRows ,InnerPanel java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
  : block_evaluator<ArgType, BlockRows, BlockCols, InnerPanel>
{
  typedef Block
  typenameXprType: Scalar
  // TODO: should check for smaller packet types once we can handle multi-sized packet types
typedef typename packet_traits<Scalar>:type ;

enum
    CoeffReadCost = evaluator<ArgType>::CoeffReadCost,

    RowsAtCompileTime = traits<XprType>::RowsAtCompileTime =Flags0|FlagsLinearAccessBit ,
    ColsAtCompileTime = traits<XprTypePacketAlignment unpacket_traits<PacketScalar>:alignment
MaxRowsAtCompileTime <>:MaxRowsAtCompileTime,
    MaxColsAtCompileTime = traits                             &(!=0)

    ArgTypeIsRowMajor = (int(evaluator  EIGEN_PLAIN_ENUM_MINevaluator>:Alignment,Alignment0
    IsRowMajor = (MaxRowsAtCompileTime==1 && MaxColsAtCompileTime!=1) ? 1
               : (MaxColsAtCompileTime==1 && MaxRowsAtCompileTime!=1) ? 0
ArgTypeIsRowMajor
    HasSameStorageOrderAsArgType = (IsRowMajor == ArgTypeIsRowMajorEIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
InnerSize= ?int): intRowsAtCompileTime)java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
EIGEN_INTERNAL_CHECK_COST_VALUE();
                             ? int(inner_stride_at_compile_time<ArgType>::ret)
                             : int(outer_stride_at_compile_time<ArgType>::ret),
      
                             ? int(outer_stride_at_compile_time<ArgType>::ret)
                             : int(inner_stride_at_compile_time<ArgType>::ret),
    MaskPacketAccessBit = ({

    FlagsLinearAccessBit = (RowsAtCompileTime ==E EIGEN_STRONG_INLINE
     = XprType::Flags&,
    Flags0 = evaluator <XprType()
                                           DirectAccessBit |
                                            , ,  lockCols bool>
Flags |FlagsLinearAccessBit ,

PacketAlignmentunpacket_traitsPacketScalar>:,
    Alignment0
                             OuterStrideAtCompileTime)
                             &java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
    Alignment = : m_argImpl(blocknestedExpression(),
  };
typedef<,, >block_evaluator_type
  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
  explicit evaluator(const XprType& block)
  {
    EIGEN_INTERNAL_CHECK_COST_VALUE)
  }
}

// no direct-access => dispatch to a unary evaluator
,  BlockCols,  >
struct block_evaluator<ArgType, BlockRows, BlockCols,     =( |(::IsRowMajorint:IsRowMajor) &<span style='color:red'>boole>::&LinearAccessBit
  : unary_evaluator<Block<java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 0
{
  typedef Block<ArgType, BlockRows, BlockCols, InnerPanel>    return m_argImpl.coeff(m_startRow.value() + row, m_star(+col

   EIGEN_STRONG_INLINE
  explicit block_evaluator(const (Index index java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
    :returnlinear_coeff_impl,bool_constantForwardLinearAccess))java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
  {}
};

template<typename ArgType, int BlockRows, int BlockCols, bool      (.value)+ row m_startCol.() +col
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   valuator_base<ArgType, ,BlockCols >java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
{
  typedef Block<ArgType

  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
  explicit unary_evaluator(const XprType& block)
    :(block.nestedExpression())
      
(block.startCol()java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
      m_linear_offset(ForwardLinearAccess?(ArgType::IsRowMajor ? block
  {  templateint,typenamePacketType

  typedef typename XprType    )
  typedeftypename :: CoeffReturnType

  enum {
    RowsAtCompileTime = XprType::RowsAtCompileTime,
    ForwardLinearAccess = (InnerPanel || int(XprType::IsRowMajor)==int(ArgType::java.lang.StringIndexOutOfBoundsException: Index 85 out of bounds for length 3
  };

EIGEN_DEVICE_FUNC
  CoeffReturnType coeff(Index rowjava.lang.StringIndexOutOfBoundsException: Range [3, 4) out of bounds for length 3
  {
    return m_argImpl.coeff(m_startRow.value}
  }

  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
  CoeffReturnType coeff(Index index) const
  {
    return linear_coeff_impl(index, bool_constant<ForwardLinearAccess>());
  }

  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
  Scalar& coeffRef(Index row, Index col)
  {
    return m_argImpl.coeffRef(m_startRow.value() + row, m_startCol     (ForwardLinearAccess
  }

  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
 & coeffRef index
  {
     linear_coeffRef_implindex, bool_constant<>());
  }

  template<int LoadMode, typename PacketType>
  EIGEN_STRONG_INLINE
  PacketType packet:
  {
    return m_argImpl(Index index ::true_type/* ForwardLinearAccess */) const
return.(.value )

  template<int LoadMode, typename PacketType>
  EIGEN_STRONG_INLINE
PacketType( ) const
  {
      java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
      return m_argImpl.template java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
else
      return packet<LoadMode,PacketType>(RowsAtCompileTime == 1 {
RowsAtCompileTime=1?index)
  }

  template<int StoreMode
  EIGEN_STRONG_INLINE
  void writePacket(Index row, Index colcoeffRefRowsAtCompileTime=  ? 0  , RowsAtCompileTime=1?index:0)java.lang.StringIndexOutOfBoundsException: Index 92 out of bounds for length 92
  {
    return m_argImpl  constvariable_if_dynamicIndex (ArgType::RowsAtCompileTime == 1 && BlockRows==1) ? 0: Dynamic m_startRowjava.lang.StringIndexOutOfBoundsException: Index 111 out of bounds for length 111
   <Index,ForwardLinearAccess? Dynamic >;

  template<
  EIGEN_STRONG_INLINE
  void writePacket(Index index,// all action is via the data() as returned by the Block expression.
  {
    if (ForwardLinearAccess)
      return m_argImpl.template writePacket<StoreMode,PacketType>(m_linear_offset.value() + index, x);
    else
returnStoreMode> =1  :,
                                              RowsAtCompileTimeBlock,BlockRows,InnerPanel>:>
                                              x);
  }

protected:
  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
urnType ( index internal: /* ForwardLinearAccess */) const
  {
     m_argImpl(.() +)java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
  }
  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
 Indexindex internalfalse_type
  {
    return coeff(RowsAtCompileTime ==;
  }

  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
  Scalar& linear_coeffRef_impl(Index
  {
    m_argImpl(.()  );
  }
  EIGEN_DEVICE_FUNC java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
  Scalar& linear_coeffRef_impl(Index index, internal::false_type /* not ForwardLinearAccess */)
{
 java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
}

  evaluator<ArgType> m_argImpl;
  const variable_if_dynamic<Index, (ArgType::RowsAtCompileTime == 1 && BlockRows==1) ? 0 : Dynamic> m_startRow;
  const     Flags = (unsigned int)e<ThenMatrixType>:Flags evaluator<ElseMatrixType:,
  const variable_if_dynamic<Index, ForwardLinearAccess      (evaluator<>:Alignment,evaluatorElseMatrixType:Alignment
};

// TODO: This evaluator does not actually use the child evaluator;
// all action is via the data() as returned by the Block expression.

template<typename ArgType, int BlockRows, int BlockCols,       m_elseImplselect())
uctblock_evaluator<, , , nnerPanel /* HasDirectAccess */ true> / true>
  : mapbase_evaluator<Block<ArgType, BlockRows, BlockCols, InnerPanel>,
                      typename Block<ArgType, BlockRows, BlockCols, InnerPanel>::PlainObject>

  typedef Block<if.
  typedeftypename::Scalar;

  EIGEN_DEVICE_FUNC  returnm_elseImpl(row);
  explicit block_evaluator(const XprType& block)
    : mapbase_evaluator<XprType, typename XprType::PlainObject>(block)
  {
    // TODO: for the 3.3 release, this should be turned to an internal assertion, but let's keep it as is for the beta lifetime
    eigen_assert(((internal::UIntPtr(block.data()) % EIGEN_PLAIN_ENUM_MAX(1{
  }
};


// -------------------- Select --------------------
// NOTE shall we introduce a ternary_evaluator?

// TODO enable vectorization for Select
template<typename ConditionMatrixTypeprotected
struct evaluator<Select<ConditionMatrixType, ThenMatrixType, ElseMatrixType> >
  : evaluator_base<Selectevaluator> ;
{
  typedef Selectjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  enum {
    CoeffReadCost = evaluator<ConditionMatrixType>::CoeffReadCost
                  + EIGEN_PLAIN_ENUM_MAX(evaluator<ThenMatrixType>::CoeffReadCost,
evaluator<ElseMatrixType:CoeffReadCost,

    Flags = (unsigned intstruct unary_evaluatorReplicateArgType,RowFactor> java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65

    Alignment = EIGEN_PLAIN_ENUM_MIN(evaluator<ThenMatrixType>::Alignment, evaluator<ElseMatrixType>::Alignment)
  }

  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
  explicit evaluator(const XprType& select)
    :java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
      m_thenImpl(select.thenMatrix()),
      m_elseImpl(select.elseMatrixtypedef ::<ArgType>::ype;
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
    EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
  }

  typedef typename     = ::IsVectorAtCompileTimeLinearAccessBit:0

  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
  CoeffReturnType coeff(Index row, Index col) const
  {
    if (m_conditionImpl.coeff(row, col))
      return m_thenImpl.coeff(row, col);
    else
      return m_elseImpl.coeff(row:m_arg(.nestedExpressionjava.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
  }

  EIGEN_STRONG_INLINE
  CoeffReturnType coeff{java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
  EIGEN_DEVICE_FUNC
.coeff)java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
      
    else
      return.(index
  }

protected:
  evaluator<ConditionMatrixType> m_conditionImpl;
evaluator> m_thenImpl
  evaluator<ElseMatrixType> m_elseImpl;
};


// -------------------- Replicate --------------------

template<typename ArgType, int RowFactor, int ColFactor>
struct unary_evaluator<Replicate<ArgType, RowFactor, (Index) const
   evaluator_base<ArgType,RowFactorColFactor>
{
  typedef Replicate<ArgType, RowFactor,                                  ?(==1 ?indexindex%m_colsvalue)
  typedef typename XprType::CoeffReturnType CoeffReturnType;
  enum {
    Factor = (RowFactor==Dynamic || ColFactor==Dynamic) ? Dynamic : RowFactor*ColFactor
  };
 typedef internal::nested_eval<ArgType,Factor>::type ArgTypeNested;
  typedef typename internal::remove_all<ArgTypeNested>::typejava.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

  enum {
    CoeffReadCost = evaluator<ArgTypeNestedCleaned>::CoeffReadCost,
    LinearAccessMask = XprType::IsVectorAtCompileTime ? LinearAccessBit : 0,
    Flags = (evaluator<ArgTypeNestedCleaned>::Flags & (HereditaryBits|LinearAccessMask) & ~                           ==  

    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  }

  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
  explicit unary_evaluator packet indexjava.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
     (.nestedExpression
      m_argImpl(m_arg),
      m_rows(replicate. : RowFactor?index:index%_owsvalue()java.lang.StringIndexOutOfBoundsException: Index 83 out of bounds for length 83
      m_cols(replicate.nestedExpression . packet,>(actual_index
  {}

  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
  CoeffReturnType coeff(Index row, Index col) const<ArgTypeNestedCleaned;
  {
 using modulo;this a  optimization
    const Index actual_row   variable_if_dynamic<, ArgTypeColsAtCompileTime;
                           :RowFactor  java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
                           ://
    const Index actual_col = internal::traits<XprType// MatrixWrapper and ArrayWrapper evaluators.
                           : ColFactor==1 ?java.lang.StringIndexOutOfBoundsException: Range [0, 44) out of bounds for length 26
                           : col % m_cols.value

    return m_argImpl.coeff(actual_row, actual_col {
  }

  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
  CoeffReturnType coeff(Index index) const
  {
    // try to avoid using modulo; this is a pure optimization strategy
     actual_indexinternal<XprType:==1
                                  ? (ColFactor==1 ?  index java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
                                     :index.())java.lang.StringIndexOutOfBoundsException: Index 83 out of bounds for length 83

    return m_argImpl.coeff(actual_index);
  }

  template<int LoadMode, typename PacketType>
  EIGEN_STRONG_INLINE
  PacketType packet(Index row, Index col) const
  {
    const Index actual_row = internal::traits<XprType m_argImpl(index
                           : RowFactor==1 ? row
                           : row % m_rows
    const Index actual_col = internal::traits<XprType>::ColsAtCompileTime==1 ? 0
                           : ColFactor==1 ? col
                           : col % m_cols.value();

    return m_argImpl.template packet<LoadMode,PacketType>(actual_row, actual_coljava.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  }

  template<int LoadMode, typename PacketType>
  EIGEN_STRONG_INLINE
  PacketType packet(Index index
  {
    const Index  EIGEN_STRONG_INLINE
                                  ==1indexm_cols)
                                  : (RowFactor==1 ?  index : index%m_rows.value());

    return m_argImpl.template packet<LoadMode,PacketType>(actual_index);
  }

protected:
  const ArgTypeNested m_arg; 
  <ArgTypeNestedCleaned _;
  const variable_if_dynamic<Index, ArgType::RowsAtCompileTime> java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 3
  const variable_if_dynamicjava.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
};

// -------------------- MatrixWrapper and ArrayWrapper --------------------
//
// evaluator_wrapper_base<T> is a common base class for the
// MatrixWrapper and ArrayWrapper evaluators.

template<typename  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
struct evaluator_wrapper_base
  : evaluator_base<XprType>
{
  typedef typename remove_all<typename XprType::NestedExpressionTypejava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
  enum {template<>index
    CoeffReadCost = evaluator<ArgType>::CoeffReadCost
    Flags = evaluator<ArgType>::Flags,
    Alignment = evaluator<ArgType>::Alignment
  };

  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
  explicit evaluator_wrapper_base(const ArgType& arg) : m_argImpl(arg) {}

  typedef typename ArgType::Scalar   MatrixWrapper> ;
  typedef typename ArgType::CoeffReturnType CoeffReturnType;

  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
  CoeffReturnType coeff(: evaluator_wrapper_baseMatrixWrapper> (.nestedExpression
  {
    return m_argImpl.coeff(row, col);
  }

EIGEN_DEVICE_FUNC
  CoeffReturnType per_baseArrayWrapper>>
  {
    return m_argImpl.coeff(index);
  java.lang.StringIndexOutOfBoundsException: Range [3, 4) out of bounds for length 3

  EIGEN_DEVICE_FUNC
  Scalar& coeffRef(Index row     <ArrayWrapperTArgType (.nestedExpression
  {
    return m_argImpl.coeffRef(row, col);
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
  Scalar& coeffRef(Index index)
  {
    return m_argImpl.coeffRef(index);
   }

  template<int LoadMode, java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
  EIGEN_STRONG_INLINE
  PacketType packet(Index row, Index col) const
  {
    return m_argImpl.template packet<LoadMode,PacketType>(row,       ::,
  }

templateint,  PacketType
     =( == )
  PacketTypepacket index
  {
    return m_argImpl.template packet<LoadMode,PacketType>(index);
  }

  template<int StoreMode, typename PacketType>
  EIGEN_STRONG_INLINE
   writePacket rowIndex col & )
  {
    m_argImpl.template writePacket    LinearAccess  ((==BothDirections) & int)&PacketAccessBit) java.lang.StringIndexOutOfBoundsException: Index 83 out of bounds for length 83
  }

  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  EIGEN_STRONG_INLINE
  void writePacket(Index index, const PacketType& x)
  {
    m_argImpl.template;
  }

protected:
  evaluator<ArgType> m_argImpl;
};

template<typename TArgType>
struct unary_evaluator<MatrixWrapper<TArgType> >
  : evaluator_wrapper_base<MatrixWrapper<TArgType> >
{
  typedef MatrixWrapper<TArgType> XprType;

  EIGEN_DEVICE_FUNCEIGEN_STRONG_INLINE
  explicit unary_evaluator(const XprType& wrapper)
    : evaluator_wrapper_base<MatrixWrapper<TArgType> >(wrapper.nestedExpression())
  { }
};

template<typename TArgType>
struct unary_evaluator<ArrayWrapper<TArgType> >
  : evaluator_wrapper_base<ArrayWrapper<TArgType> >
{
  typedef ArrayWrapper<TArgType> XprType;

  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
e& wrapper
    : evaluator_wrapper_base<ArrayWrapper<TArgType> >  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  { }
}


// -------------------- Reverse --------------------

// defined in Reverse.h:
template<typename PacketType, bool ReversePacket> struct   

< ArgTypeint >
struct unary_evaluator<Reverse<ArgType, Direction> >
  : evaluator_base<Reverse<ArgType,java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
  typedef Reverse<ArgType, Direction>    (Index,Index java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
  typedef typename XprType::Scalar Scalar;
  typedef typename XprType::CoeffReturnType CoeffReturnType;

  enum {
    IsRowMajor = XprType::IsRowMajor,
    IsColMajor = !IsRowMajor,
ReverseRow  ==Vertical|( ==BothDirections,
    ReverseCol = (Direction == Horizontal) || (Direction == BothDirections),
    ReversePacket = (Direction == BothDirections)
                    || ((Direction == Vertical)   && IsColMajor)
                    ||   java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21

    CoeffReadCost = evaluator<ArgType>::CoeffReadCost,

/java.lang.StringIndexOutOfBoundsException: Index 88 out of bounds for length 88
    // FIXME enable DirectAccess with negative strides?
    Flags0 = evaluator<ArgType>::Flags,
    LinearAccess = ( (Direction==BothDirections) && (int(Flags0)&PacketAccessBit) )
                  || ((ReverseRow && XprType::ColsAtCompileTime==1) || (ReverseCol && XprType::RowsAtCompileTime==1))
                 ? LinearAccessBit : 0,

    Flags / FIXMEwe ould some withpacket(,)

Alignment  // FIXME in some rare cases, Alignment could be preserved, like a Vector4f.
  };

  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE    }
  explicit    typedefinternalreverse_packet_cond<,ReversePacket reverse_packet;
    : m_argImpl(reverse.nestedExpression()),
      (ReverseRow .nestedExpression()  )java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
      m_cols(ReverseCol ? reverse.nestedExpression().cols() : 1)
   java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
  CoeffReturnType coeff(Index row
  {
    return m_argImpl.coeff(ReverseRow ? m_rows.value() - row - 1 : row,
ReverseCol? m_cols() -col1:col
  }

  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
  CoeffReturnType coeffprotected
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
    return m_argImpl.coeff  / If we do not reverse rows, then we do not need to know the number of rows; same for columns
  }

  EIGEN_DEVICE_FUNCEIGEN_STRONG_INLINE
  Scalar& coeffRef(Index variable_if_dynamic, ReverseColArgType:ColsAtCompileTime :1 ;
  {
    return m_argImpl.coeffRef(ReverseRow ? m_rows.value
                              ReverseCol ? m_cols.value() - col - 1 : col);
  }

  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
  Scalar& coeffRef(Index index)
  {
    return .coeffRef.value  .value)   -1;
  }

  template<int LoadMode, typename PacketType>
  EIGEN_STRONG_INLINE
  PacketType packet(Index row, Index col) const
  {
     java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
      PacketSize = unpacket_traits<PacketTypeAlignment =0
      OffsetRow  = ReverseRow && IsColMajor ? PacketSize : 1,
       = &  ?  : 1
    };
    typedef internal::reverse_packet_cond<PacketType,ReversePacket> reverse_packet;
    return reverse_packet::runm_index.index
                               .value -row   : ,
                                  ReverseCol ? m_cols.valuetypedef XprTypeScalar;
  }

  template LoadMode,typename>
  EIGEN_STRONG_INLINE
  PacketType packet(Index index) const
  {
      PacketSize = <PacketType: };
    return preverse(m_argImpl.template packet
  }

  template<int LoadMode, typename PacketType>
  EIGEN_STRONG_INLINE
  void writePacket(Index row, Index col, const PacketType
 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
    // FIXME we could factorize some code with packet(i,j)
    enum {
PacketSize=unpacket_traits<acketType:,
      OffsetRow  = ReverseRowreturnm_argImpl.(row (),rowcolOffset)
      OffsetCol  = ReverseCol && IsRowMajor ? PacketSize : 1
    };
    typedef Scalar(Index)
    m_argImpl.template writePacket.(index()  + colOffset);
ReverseRow  .value   -  : ,
                                  ReverseCol ? m_cols.value() - col - OffsetCol
                                  reverse_packet:  <ArgType;
  }

  template<int LoadMode, typename PacketType
  EIGEN_STRONG_INLINE
  void(Index, constPacketType&x)
  {
     {PacketSizeunpacket_traits>:: };
    m_argImpl.template writePacket EIGEN_STRONG_INLINE
(.value  .value  index  , preversex)java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
  }

protected:
  evaluator// deprecated code

  // If we do not reverse rows, then we do not need to know the number of rows; same for columns// -------------------- EvalToTemp --------------------
  // expression class for evaluating nested expression to a temporary
  const variable_if_dynamic<Index, ReverseRow ? ArgType::RowsAtCompileTime : 1>templatetypenameArgTypeclass;
  const variable_if_dynamic<Indextemplate ArgType>
};


// -------------------- Diagonal --------------------

template<typename ArgType, int DiagIndex>
struct evaluator<Diagonal<ArgType, DiagIndex> >
  : evaluator_base<Diagonal<ArgType, DiagIndex> >
{
  typedef Diagonal<ArgType, DiagIndex> XprType;

  enum   typedeftypename<EvalToTemp: Base
::CoeffReadCost,

    Flags = (unsigned int) explicit(const& arg

    Alignment = 0
  }

  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
  explicit evaluator(const XprType& diagonal)
    : m_argImpl(diagonal.nestedExpression())  EIGEN_CONSTEXPR  rows java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
      m_index(diagonal.index())
  { }

   typename:Scalar;
  typedef typename XprType  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
  CoeffReturnType coeff(Indexconst& m_arg
  {
    return m_argImpl.coeff(row + rowOffset(), row + colOffset<typename>
}

  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
  CoeffReturnType coeff(Index index) const
  {
    return m_argImpl.coeff(index + rowOffset(), index + colOffset());
  }

  EIGEN_DEVICE_FUNC
  Scalar(Index, Index
{
    return m_argImpl.coeffRef(row + rowOffset(), row + colOffset());
}

  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
  Scalar& coeffRef
  {
    return m_argImpl.coeffRef  EIGEN_DEVICE_FUNCevaluatorconstArgType)
  }

protected:
  evaluator<ArgType> m_argImpl;
  const internal::variable_if_dynamicindex

private:
  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE EIGEN_CONSTEXPR
  Index rowOffset() const { return m_index.value() > 0 ? 0 : -m_index.value(); }
  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE EIGEN_CONSTEXPR
  Index colOffset() const { return m_index.value() > 0 ? m_index.value() : 0; }
};


//----------------------------------------------------------------------
// deprecated code
//----------------------------------------------------------------------

// -------------------- EvalToTemp --------------------

// expression class for evaluating nested expression to a temporary

template<typename ArgType> class EvalToTemp;

template<typename ArgType>
struct traits<EvalToTemp<ArgType> >
  : public traits<ArgType>
{ };

template<typename ArgType>
class EvalToTemp
  : public dense_xpr_base<EvalToTemp<ArgType> >::type
{
 public:

  typedef typename dense_xpr_base<EvalToTemp>::type Base;
  EIGEN_GENERIC_PUBLIC_INTERFACE(EvalToTemp)

  explicit EvalToTemp(const ArgType& arg)
    : m_arg(arg)
  { }

  const ArgType& arg() const
  {
    return m_arg;
  }

  EIGEN_CONSTEXPR Index rows() const EIGEN_NOEXCEPT
  {
    return m_arg.rows();
  }

  EIGEN_CONSTEXPR Index cols() const EIGEN_NOEXCEPT
  {
    return m_arg.cols();
  }

 private:
  const ArgType& m_arg;
};

template<typename ArgType>
struct evaluator<EvalToTemp<ArgType> >
  : public evaluator<typename ArgType::PlainObject>
{
  typedef EvalToTemp<ArgType>                   XprType;
  typedef typename ArgType::PlainObject         PlainObject;
  typedef evaluator<PlainObject> Base;

  EIGEN_DEVICE_FUNC explicit evaluator(const XprType& xpr)
    : m_result(xpr.arg())
  {
    ::new (static_cast<Base*>(this)) Base(m_result);
  }

  // This constructor is used when nesting an EvalTo evaluator in another evaluator
  EIGEN_DEVICE_FUNC evaluator(const ArgType& arg)
    : m_result(arg)
  {
    ::new (static_cast<Base*>(this)) Base(m_result);
  }

protected:
  PlainObject m_result;
};

} // namespace internal

} // end namespace Eigen

#endif // EIGEN_COREEVALUATORS_H

quality100%

¤ Dauer der Verarbeitung: 0.111 Sekunden  ¤

*© Formatika GbR, Deutschland