Eigen::Stride< OuterStrideAtCompileTime_, InnerStrideAtCompileTime_ > Class Template Reference

Holds strides information for Map. More...

Public Types

enum  {
  InnerStrideAtCompileTime ,
  OuterStrideAtCompileTime
}
 
typedef Eigen::Index Index
 

Public Member Functions

EIGEN_CONSTEXPR Index inner () const
 
EIGEN_CONSTEXPR Index outer () const
 
 Stride ()
 
 Stride (const Stride &other)
 
 Stride (Index outerStride, Index innerStride)
 

Protected Attributes

internal::variable_if_dynamic< Index, InnerStrideAtCompileTimem_inner
 
internal::variable_if_dynamic< Index, OuterStrideAtCompileTimem_outer
 

Detailed Description

template<int OuterStrideAtCompileTime_, int InnerStrideAtCompileTime_>
class Eigen::Stride< OuterStrideAtCompileTime_, InnerStrideAtCompileTime_ >

Holds strides information for Map.

This class holds the strides information for mapping arrays with strides with class Map.

It holds two values: the inner stride and the outer stride.

The inner stride is the pointer increment between two consecutive entries within a given row of a row-major matrix or within a given column of a column-major matrix.

The outer stride is the pointer increment between two consecutive rows of a row-major matrix or between two consecutive columns of a column-major matrix.

These two values can be passed either at compile-time as template parameters, or at runtime as arguments to the constructor.

Indeed, this class takes two template parameters:

Template Parameters
OuterStrideAtCompileTime_the outer stride, or Dynamic if you want to specify it at runtime.
InnerStrideAtCompileTime_the inner stride, or Dynamic if you want to specify it at runtime.

Here is an example:

int array[24];
for(int i = 0; i < 24; ++i) array[i] = i;
cout << Map<MatrixXi, 0, Stride<Dynamic,2> >
(array, 3, 3, Stride<Dynamic,2>(8, 2))
<< endl;
std::array< T, N > array
Definition: EmulateArray.h:256

Output:

 0  8 16
 2 10 18
 4 12 20

Both strides can be negative. However, a negative stride of -1 cannot be specified at compile time because of the ambiguity with Dynamic which is defined to -1 (historically, negative strides were not allowed).

Note that for compile-time vectors (ColsAtCompileTime==1 or RowsAtCompile==1), the inner stride is the pointer increment between two consecutive elements, regardless of storage layout.

See also
class InnerStride, class OuterStride, Storage orders

Definition at line 54 of file Stride.h.

Member Typedef Documentation

◆ Index

template<int OuterStrideAtCompileTime_, int InnerStrideAtCompileTime_>
typedef Eigen::Index Eigen::Stride< OuterStrideAtCompileTime_, InnerStrideAtCompileTime_ >::Index
Deprecated:
since Eigen 3.3

Definition at line 57 of file Stride.h.

Member Enumeration Documentation

◆ anonymous enum

template<int OuterStrideAtCompileTime_, int InnerStrideAtCompileTime_>
anonymous enum
Enumerator
InnerStrideAtCompileTime 
OuterStrideAtCompileTime 

Definition at line 58 of file Stride.h.

58  {
59  InnerStrideAtCompileTime = InnerStrideAtCompileTime_,
60  OuterStrideAtCompileTime = OuterStrideAtCompileTime_
61  };
@ InnerStrideAtCompileTime
Definition: Stride.h:59
@ OuterStrideAtCompileTime
Definition: Stride.h:60

Constructor & Destructor Documentation

◆ Stride() [1/3]

template<int OuterStrideAtCompileTime_, int InnerStrideAtCompileTime_>
Eigen::Stride< OuterStrideAtCompileTime_, InnerStrideAtCompileTime_ >::Stride ( )
inline

Default constructor, for use when strides are fixed at compile time

Definition at line 65 of file Stride.h.

67  {
68  // FIXME: for Eigen 4 we should use DynamicIndex instead of Dynamic.
69  // FIXME: for Eigen 4 we should also unify this API with fix<>
71  }
#define eigen_assert(x)
Definition: Macros.h:902
internal::variable_if_dynamic< Index, InnerStrideAtCompileTime > m_inner
Definition: Stride.h:95
internal::variable_if_dynamic< Index, OuterStrideAtCompileTime > m_outer
Definition: Stride.h:94
const int Dynamic
Definition: Constants.h:24

◆ Stride() [2/3]

template<int OuterStrideAtCompileTime_, int InnerStrideAtCompileTime_>
Eigen::Stride< OuterStrideAtCompileTime_, InnerStrideAtCompileTime_ >::Stride ( Index  outerStride,
Index  innerStride 
)
inline

Constructor allowing to pass the strides at runtime

Definition at line 75 of file Stride.h.

76  : m_outer(outerStride), m_inner(innerStride)
77  {
78  }

◆ Stride() [3/3]

template<int OuterStrideAtCompileTime_, int InnerStrideAtCompileTime_>
Eigen::Stride< OuterStrideAtCompileTime_, InnerStrideAtCompileTime_ >::Stride ( const Stride< OuterStrideAtCompileTime_, InnerStrideAtCompileTime_ > &  other)
inline

Copy constructor

Definition at line 82 of file Stride.h.

83  : m_outer(other.outer()), m_inner(other.inner())
84  {}

Member Function Documentation

◆ inner()

template<int OuterStrideAtCompileTime_, int InnerStrideAtCompileTime_>
EIGEN_CONSTEXPR Index Eigen::Stride< OuterStrideAtCompileTime_, InnerStrideAtCompileTime_ >::inner ( ) const
inline
Returns
the inner stride

Definition at line 91 of file Stride.h.

91 { return m_inner.value(); }

◆ outer()

template<int OuterStrideAtCompileTime_, int InnerStrideAtCompileTime_>
EIGEN_CONSTEXPR Index Eigen::Stride< OuterStrideAtCompileTime_, InnerStrideAtCompileTime_ >::outer ( ) const
inline
Returns
the outer stride

Definition at line 88 of file Stride.h.

88 { return m_outer.value(); }

Member Data Documentation

◆ m_inner

template<int OuterStrideAtCompileTime_, int InnerStrideAtCompileTime_>
internal::variable_if_dynamic<Index, InnerStrideAtCompileTime> Eigen::Stride< OuterStrideAtCompileTime_, InnerStrideAtCompileTime_ >::m_inner
protected

Definition at line 95 of file Stride.h.

◆ m_outer

template<int OuterStrideAtCompileTime_, int InnerStrideAtCompileTime_>
internal::variable_if_dynamic<Index, OuterStrideAtCompileTime> Eigen::Stride< OuterStrideAtCompileTime_, InnerStrideAtCompileTime_ >::m_outer
protected

Definition at line 94 of file Stride.h.


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