Eigen::RefBase< Derived > Class Template Reference

Inheritance diagram for Eigen::RefBase< Derived >:

Public Types
typedef MapBase< Derived >	Base

Public Member Functions
EIGEN_CONSTEXPR Index	innerStride () const
EIGEN_CONSTEXPR Index	outerStride () const
	RefBase ()

Protected Types
typedef Stride< StrideType::OuterStrideAtCompileTime, StrideType::InnerStrideAtCompileTime >	StrideBase

Protected Member Functions
template<typename Expression >
bool	construct (Expression &expr)

Static Protected Member Functions
static EIGEN_CONSTEXPR Index	resolveInnerStride (Index inner)
static EIGEN_CONSTEXPR Index	resolveOuterStride (Index inner, Index outer, Index rows, Index cols, bool isVectorAtCompileTime, bool isRowMajor)

Protected Attributes
StrideBase	m_stride

Private Types
typedef internal::traits< Derived >::PlainObjectType	PlainObjectType
typedef internal::traits< Derived >::StrideType	StrideType

Detailed Description

template<typename Derived>
class Eigen::RefBase< Derived >

Definition at line 61 of file Ref.h.

Member Typedef Documentation

Base

template<typename Derived >

typedef MapBase<Derived> Eigen::RefBase< Derived >::Base

Definition at line 69 of file Ref.h.

PlainObjectType

template<typename Derived >

typedef internal::traits<Derived>::PlainObjectType Eigen::RefBase< Derived >::PlainObjectType

private

Definition at line 64 of file Ref.h.

StrideBase

template<typename Derived >

typedef Stride<StrideType::OuterStrideAtCompileTime,StrideType::InnerStrideAtCompileTime> Eigen::RefBase< Derived >::StrideBase

protected

Definition at line 96 of file Ref.h.

StrideType

template<typename Derived >

typedef internal::traits<Derived>::StrideType Eigen::RefBase< Derived >::StrideType

private

Definition at line 65 of file Ref.h.

Constructor & Destructor Documentation

RefBase()

template<typename Derived >

Eigen::RefBase< Derived >::RefBase ( )

inline

Definition at line 85 of file Ref.h.

    : Base(0,RowsAtCompileTime==Dynamic?0:RowsAtCompileTime,ColsAtCompileTime==Dynamic?0:ColsAtCompileTime),
      // Stride<> does not allow default ctor for Dynamic strides, so let' initialize it with dummy values:
      m_stride(StrideType::OuterStrideAtCompileTime==Dynamic?0:StrideType::OuterStrideAtCompileTime,
               StrideType::InnerStrideAtCompileTime==Dynamic?0:StrideType::InnerStrideAtCompileTime)
  {}

Member Function Documentation

construct()

template<typename Derived >

template<typename Expression >

bool Eigen::RefBase< Derived >::construct ( Expression &  expr )

inlineprotected

Definition at line 111 of file Ref.h.

  {
    // Check matrix sizes.  If this is a compile-time vector, we do allow
    // implicitly transposing.
    EIGEN_STATIC_ASSERT(
      EIGEN_PREDICATE_SAME_MATRIX_SIZE(PlainObjectType, Expression)
      // If it is a vector, the transpose sizes might match.
      || ( PlainObjectType::IsVectorAtCompileTime
            && ((int(PlainObjectType::RowsAtCompileTime)==Eigen::Dynamic
              || int(Expression::ColsAtCompileTime)==Eigen::Dynamic
              || int(PlainObjectType::RowsAtCompileTime)==int(Expression::ColsAtCompileTime))
            &&  (int(PlainObjectType::ColsAtCompileTime)==Eigen::Dynamic
              || int(Expression::RowsAtCompileTime)==Eigen::Dynamic
              || int(PlainObjectType::ColsAtCompileTime)==int(Expression::RowsAtCompileTime)))),
      YOU_MIXED_MATRICES_OF_DIFFERENT_SIZES
    )
 
    // Determine runtime rows and columns.
    Index rows = expr.rows();
    Index cols = expr.cols();
    if(PlainObjectType::RowsAtCompileTime==1)
    {
      eigen_assert(expr.rows()==1 || expr.cols()==1);
      rows = 1;
      cols = expr.size();
    }
    else if(PlainObjectType::ColsAtCompileTime==1)
    {
      eigen_assert(expr.rows()==1 || expr.cols()==1);
      rows = expr.size();
      cols = 1;
    }
    // Verify that the sizes are valid.
    eigen_assert(
      (PlainObjectType::RowsAtCompileTime == Dynamic) || (PlainObjectType::RowsAtCompileTime == rows));
    eigen_assert(
      (PlainObjectType::ColsAtCompileTime == Dynamic) || (PlainObjectType::ColsAtCompileTime == cols));
 
 
    // If this is a vector, we might be transposing, which means that stride should swap.
    const bool transpose = PlainObjectType::IsVectorAtCompileTime && (rows != expr.rows());
    // If the storage format differs, we also need to swap the stride.
    const bool row_major = ((PlainObjectType::Flags)&RowMajorBit) != 0;
    const bool expr_row_major = (Expression::Flags&RowMajorBit) != 0;
    const bool storage_differs =  (row_major != expr_row_major);
 
    const bool swap_stride = (transpose != storage_differs);
 
    // Determine expr's actual strides, resolving any defaults if zero.
    const Index expr_inner_actual = resolveInnerStride(expr.innerStride());
    const Index expr_outer_actual = resolveOuterStride(expr_inner_actual,
                                                       expr.outerStride(),
                                                       expr.rows(),
                                                       expr.cols(),
                                                       Expression::IsVectorAtCompileTime != 0,
                                                       expr_row_major);
 
    // If this is a column-major row vector or row-major column vector, the inner-stride
    // is arbitrary, so set it to either the compile-time inner stride or 1.
    const bool row_vector = (rows == 1);
    const bool col_vector = (cols == 1);
    const Index inner_stride =
        ( (!row_major && row_vector) || (row_major && col_vector) ) ?
            ( StrideType::InnerStrideAtCompileTime > 0 ? Index(StrideType::InnerStrideAtCompileTime) : 1)
            : swap_stride ? expr_outer_actual : expr_inner_actual;
 
    // If this is a column-major column vector or row-major row vector, the outer-stride
    // is arbitrary, so set it to either the compile-time outer stride or vector size.
    const Index outer_stride =
      ( (!row_major && col_vector) || (row_major && row_vector) ) ?
          ( StrideType::OuterStrideAtCompileTime > 0 ? Index(StrideType::OuterStrideAtCompileTime) : rows * cols * inner_stride)
          : swap_stride ? expr_inner_actual : expr_outer_actual;
 
    // Check if given inner/outer strides are compatible with compile-time strides.
    const bool inner_valid = (StrideType::InnerStrideAtCompileTime == Dynamic)
        || (resolveInnerStride(Index(StrideType::InnerStrideAtCompileTime)) == inner_stride);
    if (!inner_valid) {
      return false;
    }
 
    const bool outer_valid = (StrideType::OuterStrideAtCompileTime == Dynamic)
        || (resolveOuterStride(
              inner_stride,
              Index(StrideType::OuterStrideAtCompileTime),
              rows, cols, PlainObjectType::IsVectorAtCompileTime != 0,
              row_major)
            == outer_stride);
    if (!outer_valid) {
      return false;
    }
 
    internal::construct_at<Base>(this, expr.data(), rows, cols);
    internal::construct_at(&m_stride,
      (StrideType::OuterStrideAtCompileTime == 0) ? 0 : outer_stride,
      (StrideType::InnerStrideAtCompileTime == 0) ? 0 : inner_stride );
    return true;
  }

innerStride()

template<typename Derived >

EIGEN_CONSTEXPR Index Eigen::RefBase< Derived >::innerStride ( ) const

inline

Definition at line 72 of file Ref.h.

  {
    return StrideType::InnerStrideAtCompileTime != 0 ? m_stride.inner() : 1;
  }

outerStride()

template<typename Derived >

EIGEN_CONSTEXPR Index Eigen::RefBase< Derived >::outerStride ( ) const

inline

Definition at line 77 of file Ref.h.

  {
    return StrideType::OuterStrideAtCompileTime != 0 ? m_stride.outer()
         : IsVectorAtCompileTime ? this->size()
         : int(Flags)&RowMajorBit ? this->cols()
         : this->rows();
  }

resolveInnerStride()

template<typename Derived >

static EIGEN_CONSTEXPR Index Eigen::RefBase< Derived >::resolveInnerStride ( Index  inner )

inlinestaticprotected

Definition at line 99 of file Ref.h.

                                                                                 {
    return inner == 0 ? 1 : inner;
  }

resolveOuterStride()

template<typename Derived >

static EIGEN_CONSTEXPR Index Eigen::RefBase< Derived >::resolveOuterStride ( Index  inner, Index  outer, Index  rows, Index  cols, bool  isVectorAtCompileTime, bool  isRowMajor  )

inlinestaticprotected

Definition at line 104 of file Ref.h.

                                                                                                                                                                   {
    return outer == 0 ? isVectorAtCompileTime ? inner * rows * cols : isRowMajor ? inner * cols : inner * rows : outer;
  }

Member Data Documentation

m_stride

template<typename Derived >

StrideBase Eigen::RefBase< Derived >::m_stride

protected

Definition at line 209 of file Ref.h.

---

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

• Ref.h