Variables
Flags

Variables

const unsigned int Eigen::AlignedBit = 0x80
 
const unsigned int Eigen::DirectAccessBit = 0x40
 
const unsigned int Eigen::EvalBeforeAssigningBit = 0x4
 
const unsigned int Eigen::EvalBeforeNestingBit = 0x2
 
const unsigned int Eigen::LinearAccessBit = 0x10
 
const unsigned int Eigen::LvalueBit = 0x20
 
const unsigned int Eigen::PacketAccessBit = 0x8
 
const unsigned int Eigen::RowMajorBit = 0x1
 

Detailed Description

These are the possible bits which can be OR'ed to constitute the flags of a matrix or expression.

It is important to note that these flags are a purely compile-time notion. They are a compile-time property of an expression type, implemented as enum's. They are not stored in memory at runtime, and they do not incur any runtime overhead.

See also
MatrixBase::Flags

Variable Documentation

const unsigned int Eigen::AlignedBit = 0x80

means the first coefficient packet is guaranteed to be aligned

Definition at line 147 of file eigen3/Eigen/src/Core/util/Constants.h.

const unsigned int Eigen::DirectAccessBit = 0x40

Means that the underlying array of coefficients can be directly accessed as a plain strided array. The memory layout of the array of coefficients must be exactly the natural one suggested by rows(), cols(), outerStride(), innerStride(), and the RowMajorBit. This rules out expressions such as Diagonal, whose coefficients, though referencable, do not have such a regular memory layout.

See the comment on LvalueBit for an explanation of how LvalueBit and DirectAccessBit are mutually orthogonal.

Definition at line 142 of file eigen3/Eigen/src/Core/util/Constants.h.

const unsigned int Eigen::EvalBeforeAssigningBit = 0x4

means the expression should be evaluated before any assignment

Definition at line 63 of file eigen3/Eigen/src/Core/util/Constants.h.

const unsigned int Eigen::EvalBeforeNestingBit = 0x2

means the expression should be evaluated by the calling expression

Definition at line 58 of file eigen3/Eigen/src/Core/util/Constants.h.

const unsigned int Eigen::LinearAccessBit = 0x10

Short version: means the expression can be seen as 1D vector.

Long version: means that one can access the coefficients of this expression by coeff(int), and coeffRef(int) in the case of a lvalue expression. These index-based access methods are guaranteed to not have to do any runtime computation of a (row, col)-pair from the index, so that it is guaranteed that whenever it is available, index-based access is at least as fast as (row,col)-based access. Expressions for which that isn't possible don't have the LinearAccessBit.

If both PacketAccessBit and LinearAccessBit are set, then the packets of this expression can be accessed by packet(int), and writePacket(int) in the case of a lvalue expression.

Typically, all vector expressions have the LinearAccessBit, but there is one exception: Product expressions don't have it, because it would be troublesome for vectorization, even when the Product is a vector expression. Thus, vector Product expressions allow index-based coefficient access but not index-based packet access, so they don't have the LinearAccessBit.

Definition at line 117 of file eigen3/Eigen/src/Core/util/Constants.h.

const unsigned int Eigen::LvalueBit = 0x20

Means the expression has a coeffRef() method, i.e. is writable as its individual coefficients are directly addressable. This rules out read-only expressions.

Note that DirectAccessBit and LvalueBit are mutually orthogonal, as there are examples of expression having one but note the other:

  • writable expressions that don't have a very simple memory layout as a strided array, have LvalueBit but not DirectAccessBit
  • Map-to-const expressions, for example Map<const Matrix>, have DirectAccessBit but not LvalueBit

Expressions having LvalueBit also have their coeff() method returning a const reference instead of returning a new value.

Definition at line 131 of file eigen3/Eigen/src/Core/util/Constants.h.

const unsigned int Eigen::PacketAccessBit = 0x8

Short version: means the expression might be vectorized

Long version: means that the coefficients can be handled by packets and start at a memory location whose alignment meets the requirements of the present CPU architecture for optimized packet access. In the fixed-size case, there is the additional condition that it be possible to access all the coefficients by packets (this implies the requirement that the size be a multiple of 16 bytes, and that any nontrivial strides don't break the alignment). In the dynamic-size case, there is no such condition on the total size and strides, so it might not be possible to access all coeffs by packets.

Note
This bit can be set regardless of whether vectorization is actually enabled. To check for actual vectorizability, see ActualPacketAccessBit.

Definition at line 81 of file eigen3/Eigen/src/Core/util/Constants.h.

const unsigned int Eigen::RowMajorBit = 0x1

for a matrix, this means that the storage order is row-major. If this bit is not set, the storage order is column-major. For an expression, this determines the storage order of the matrix created by evaluation of that expression.

See also
TopicStorageOrders

Definition at line 53 of file eigen3/Eigen/src/Core/util/Constants.h.



acado
Author(s): Milan Vukov, Rien Quirynen
autogenerated on Mon Jun 10 2019 12:35:22