Eigen::RefBase< Derived > Class Template Reference

#include <Ref.h>

Inheritance diagram for Eigen::RefBase< Derived >:

Public Types
typedef MapBase< Derived >	Base

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

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

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

Static Protected Member Functions
static EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR Index	resolveInnerStride (Index inner)
static EIGEN_DEVICE_FUNC 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

Member Typedef Documentation

Base

template<typename Derived >

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

PlainObjectType

template<typename Derived >

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

private

StrideBase

template<typename Derived >

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

protected

StrideType

template<typename Derived >

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

private

Constructor & Destructor Documentation

RefBase()

template<typename Derived >

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

inline

      : 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 >

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

inlineprotected

                                                     {
    // 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;
  }

References cols, Eigen::internal::construct_at(), Eigen::Dynamic, eigen_assert, EIGEN_PREDICATE_SAME_MATRIX_SIZE, EIGEN_STATIC_ASSERT, Eigen::RefBase< Derived >::m_stride, Eigen::RefBase< Derived >::resolveInnerStride(), Eigen::RefBase< Derived >::resolveOuterStride(), Eigen::RowMajorBit, rows, and anonymous_namespace{skew_symmetric_matrix3.cpp}::transpose().

Referenced by Eigen::Ref< const TPlainObjectType, Options, StrideType >::construct(), Eigen::Ref< const SparseMatrix< MatScalar, MatOptions, MatIndex >, Options, StrideType >::construct(), Eigen::Ref< const SparseVector< MatScalar, MatOptions, MatIndex >, Options, StrideType >::construct(), Eigen::Ref< PlainObjectType, Options, StrideType >::Ref(), Eigen::Ref< const TPlainObjectType, Options, StrideType >::Ref(), Eigen::Ref< SparseMatrix< MatScalar, MatOptions, MatIndex >, Options, StrideType >::Ref(), and Eigen::Ref< SparseVector< MatScalar, MatOptions, MatIndex >, Options, StrideType >::Ref().

innerStride()

template<typename Derived >

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

inline

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

References Eigen::Stride< OuterStrideAtCompileTime_, InnerStrideAtCompileTime_ >::inner(), and Eigen::RefBase< Derived >::m_stride.

outerStride()

template<typename Derived >

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

inline

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

References cols, int(), Eigen::RefBase< Derived >::m_stride, Eigen::Stride< OuterStrideAtCompileTime_, InnerStrideAtCompileTime_ >::outer(), rows, and size.

resolveInnerStride()

template<typename Derived >

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

inlinestaticprotected

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

Referenced by Eigen::RefBase< Derived >::construct().

resolveOuterStride()

template<typename Derived >

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

inlinestaticprotected

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

References cols, and rows.

Referenced by Eigen::RefBase< Derived >::construct().

Member Data Documentation

m_stride

template<typename Derived >

StrideBase Eigen::RefBase< Derived >::m_stride

protected

Referenced by Eigen::RefBase< Derived >::construct(), Eigen::RefBase< Derived >::innerStride(), and Eigen::RefBase< Derived >::outerStride().

---

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

• Ref.h