Namespaces
namespace	Eigen::Architecture
Enumerations
enum	{ Eigen::Lower = 0x1, Eigen::Upper = 0x2, Eigen::UnitDiag = 0x4, Eigen::ZeroDiag = 0x8, Eigen::UnitLower = UnitDiag\|Lower, Eigen::UnitUpper = UnitDiag\|Upper, Eigen::StrictlyLower = ZeroDiag\|Lower, Eigen::StrictlyUpper = ZeroDiag\|Upper, Eigen::SelfAdjoint = 0x10, Eigen::Symmetric = 0x20 }
enum	{ Eigen::Unaligned = 0, Eigen::Aligned8 = 8, Eigen::Aligned16 = 16, Eigen::Aligned32 = 32, Eigen::Aligned64 = 64, Eigen::Aligned128 = 128, Eigen::AlignedMask = 255, Eigen::Aligned = 16, Eigen::AlignedMax = Unaligned }
enum	Eigen::CornerType { Eigen::TopLeft, Eigen::TopRight, Eigen::BottomLeft, Eigen::BottomRight }
enum	Eigen::DirectionType { Eigen::Vertical, Eigen::Horizontal, Eigen::BothDirections }
enum	{ Eigen::DefaultTraversal, Eigen::LinearTraversal, Eigen::InnerVectorizedTraversal, Eigen::LinearVectorizedTraversal, Eigen::SliceVectorizedTraversal, Eigen::InvalidTraversal, Eigen::AllAtOnceTraversal }
enum	{ Eigen::NoUnrolling, Eigen::InnerUnrolling, Eigen::CompleteUnrolling }
enum	{ Eigen::Specialized, Eigen::BuiltIn }
enum	{ Eigen::ColMajor = 0, Eigen::RowMajor = 0x1, Eigen::AutoAlign = 0, Eigen::DontAlign = 0x2 }
enum	{ Eigen::OnTheLeft = 1, Eigen::OnTheRight = 2 }
enum	{ Eigen::IsDense = 0, Eigen::IsSparse }
enum	Eigen::AccessorLevels { Eigen::ReadOnlyAccessors, Eigen::WriteAccessors, Eigen::DirectAccessors, Eigen::DirectWriteAccessors }
enum	Eigen::DecompositionOptions { Eigen::Pivoting = 0x01, Eigen::NoPivoting = 0x02, Eigen::ComputeFullU = 0x04, Eigen::ComputeThinU = 0x08, Eigen::ComputeFullV = 0x10, Eigen::ComputeThinV = 0x20, Eigen::EigenvaluesOnly = 0x40, Eigen::ComputeEigenvectors = 0x80, Eigen::EigVecMask = EigenvaluesOnly \| ComputeEigenvectors, Eigen::Ax_lBx = 0x100, Eigen::ABx_lx = 0x200, Eigen::BAx_lx = 0x400, Eigen::GenEigMask = Ax_lBx \| ABx_lx \| BAx_lx }
enum	Eigen::QRPreconditioners { Eigen::NoQRPreconditioner, Eigen::HouseholderQRPreconditioner, Eigen::ColPivHouseholderQRPreconditioner, Eigen::FullPivHouseholderQRPreconditioner }
enum	Eigen::ComputationInfo { Eigen::Success = 0, Eigen::NumericalIssue = 1, Eigen::NoConvergence = 2, Eigen::InvalidInput = 3 }
enum	Eigen::TransformTraits { Eigen::Isometry = 0x1, Eigen::Affine = 0x2, Eigen::AffineCompact = 0x10 \| Affine, Eigen::Projective = 0x20 }
enum	{ Eigen::DefaultProduct = 0, Eigen::LazyProduct, Eigen::AliasFreeProduct, Eigen::CoeffBasedProductMode, Eigen::LazyCoeffBasedProductMode, Eigen::OuterProduct, Eigen::InnerProduct, Eigen::GemvProduct, Eigen::GemmProduct }
enum	Eigen::Action { Eigen::GetAction, Eigen::SetAction }

Detailed Description

Various enumerations used in Eigen. Many of these are used as template parameters.

Enumeration Type Documentation

anonymous enum

Enum containing possible values for the Mode or UpLo parameter of MatrixBase::selfadjointView() and MatrixBase::triangularView(), and selfadjoint solvers.

Enumerator:

Lower	View matrix as a lower triangular matrix.
Upper	View matrix as an upper triangular matrix.
UnitDiag	Matrix has ones on the diagonal; to be used in combination with Lower or Upper.
ZeroDiag	Matrix has zeros on the diagonal; to be used in combination with Lower or Upper.
UnitLower	View matrix as a lower triangular matrix with ones on the diagonal.
UnitUpper	View matrix as an upper triangular matrix with ones on the diagonal.
StrictlyLower	View matrix as a lower triangular matrix with zeros on the diagonal.
StrictlyUpper	View matrix as an upper triangular matrix with zeros on the diagonal.
SelfAdjoint	Used in BandMatrix and SelfAdjointView to indicate that the matrix is self-adjoint.
Symmetric	Used to support symmetric, non-selfadjoint, complex matrices.

Definition at line 202 of file Constants.h.

     {
  Lower=0x1,                      
  Upper=0x2,                      
  UnitDiag=0x4, 
  ZeroDiag=0x8,
  UnitLower=UnitDiag|Lower, 
  UnitUpper=UnitDiag|Upper,
  StrictlyLower=ZeroDiag|Lower, 
  StrictlyUpper=ZeroDiag|Upper,
  SelfAdjoint=0x10,
  Symmetric=0x20
};

anonymous enum

Enum for indicating whether a buffer is aligned or not.

Enumerator:

Unaligned	Data pointer has no specific alignment.
Aligned8	Data pointer is aligned on a 8 bytes boundary.
Aligned16	Data pointer is aligned on a 16 bytes boundary.
Aligned32	Data pointer is aligned on a 32 bytes boundary.
Aligned64	Data pointer is aligned on a 64 bytes boundary.
Aligned128	Data pointer is aligned on a 128 bytes boundary.
AlignedMask
Aligned	Deprecated: Synonym for Aligned16.
AlignedMax

Definition at line 227 of file Constants.h.

     {
  Unaligned=0,        
  Aligned8=8,         
  Aligned16=16,       
  Aligned32=32,       
  Aligned64=64,       
  Aligned128=128,     
  AlignedMask=255,
  Aligned=16,         
#if EIGEN_MAX_ALIGN_BYTES==128
  AlignedMax = Aligned128
#elif EIGEN_MAX_ALIGN_BYTES==64
  AlignedMax = Aligned64
#elif EIGEN_MAX_ALIGN_BYTES==32
  AlignedMax = Aligned32
#elif EIGEN_MAX_ALIGN_BYTES==16
  AlignedMax = Aligned16
#elif EIGEN_MAX_ALIGN_BYTES==8
  AlignedMax = Aligned8
#elif EIGEN_MAX_ALIGN_BYTES==0
  AlignedMax = Unaligned
#else
#error Invalid value for EIGEN_MAX_ALIGN_BYTES
#endif
};

anonymous enum

Enum to specify how to traverse the entries of a matrix.

Enumerator:

DefaultTraversal	Default traversal, no vectorization, no index-based access
LinearTraversal	No vectorization, use index-based access to have only one for loop instead of 2 nested loops
InnerVectorizedTraversal	Equivalent to a slice vectorization for fixed-size matrices having good alignment and good size
LinearVectorizedTraversal	Vectorization path using a single loop plus scalar loops for the unaligned boundaries
SliceVectorizedTraversal	Generic vectorization path using one vectorized loop per row/column with some scalar loops to handle the unaligned boundaries
InvalidTraversal	Special case to properly handle incompatible scalar types or other defecting cases
AllAtOnceTraversal	Evaluate all entries at once

Definition at line 276 of file Constants.h.

     {
  DefaultTraversal,
  LinearTraversal,
  InnerVectorizedTraversal,
  LinearVectorizedTraversal,
  SliceVectorizedTraversal,
  InvalidTraversal,
  AllAtOnceTraversal
};

anonymous enum

Enum to specify whether to unroll loops when traversing over the entries of a matrix.

Enumerator:

NoUnrolling	Do not unroll loops.
InnerUnrolling	Unroll only the inner loop, but not the outer loop.
CompleteUnrolling	Unroll both the inner and the outer loop. If there is only one loop, because linear traversal is used, then unroll that loop.

Definition at line 298 of file Constants.h.

     {
  NoUnrolling,
  InnerUnrolling,
  CompleteUnrolling
};

anonymous enum

Enum to specify whether to use the default (built-in) implementation or the specialization.

Enumerator:

Specialized
BuiltIn

Definition at line 310 of file Constants.h.

     {
  Specialized,
  BuiltIn
};

anonymous enum

Enum containing possible values for the _Options template parameter of Matrix, Array and BandMatrix.

Enumerator:

ColMajor	Storage order is column major (see TopicStorageOrders).
RowMajor	Storage order is row major (see TopicStorageOrders).
AutoAlign	Align the matrix itself if it is vectorizable fixed-size
DontAlign	Don't require alignment for the matrix itself (the array of coefficients, if dynamically allocated, may still be requested to be aligned)

Definition at line 318 of file Constants.h.

     {
  ColMajor = 0,
  RowMajor = 0x1,  // it is only a coincidence that this is equal to RowMajorBit -- don't rely on that
  AutoAlign = 0, // FIXME --- clarify the situation
  DontAlign = 0x2
};

anonymous enum

Enum for specifying whether to apply or solve on the left or right.

Enumerator:

OnTheLeft	Apply transformation on the left.
OnTheRight	Apply transformation on the right.

Definition at line 331 of file Constants.h.

     {
  OnTheLeft = 1,  
  OnTheRight = 2  
};

anonymous enum

Used in AmbiVector.

Enumerator:

IsDense
IsSparse

Definition at line 356 of file Constants.h.

     {
  IsDense         = 0,
  IsSparse
};

anonymous enum

Enum used as template parameter in Product and product evalautors.

Enumerator:

DefaultProduct
LazyProduct
AliasFreeProduct
CoeffBasedProductMode
LazyCoeffBasedProductMode
OuterProduct
InnerProduct
GemvProduct
GemmProduct

Definition at line 483 of file Constants.h.

{ DefaultProduct=0, LazyProduct, AliasFreeProduct, CoeffBasedProductMode, LazyCoeffBasedProductMode, OuterProduct, InnerProduct, GemvProduct, GemmProduct };

enum Eigen::AccessorLevels

Used as template parameter in DenseCoeffBase and MapBase to indicate which accessors should be provided.

Enumerator:

ReadOnlyAccessors	Read-only access via a member function.
WriteAccessors	Read/write access via member functions.
DirectAccessors	Direct read-only access to the coefficients.
DirectWriteAccessors	Direct read/write access to the coefficients.

Definition at line 364 of file Constants.h.

                    {
  ReadOnlyAccessors, 
  WriteAccessors, 
  DirectAccessors, 
  DirectWriteAccessors
};

enum Eigen::Action

Enum used in experimental parallel implementation.

Enumerator:

GetAction
SetAction

Definition at line 487 of file Constants.h.

{GetAction, SetAction};

enum Eigen::ComputationInfo

Enum for reporting the status of a computation.

Enumerator:

Success	Computation was successful.
NumericalIssue	The provided data did not satisfy the prerequisites.
NoConvergence	Iterative procedure did not converge.
InvalidInput	The inputs are invalid, or the algorithm has been improperly called. When assertions are enabled, such errors trigger an assert.

Definition at line 430 of file Constants.h.

                     {
  Success = 0,        
  NumericalIssue = 1, 
  NoConvergence = 2,
  InvalidInput = 3
};

enum Eigen::CornerType

Enum used by DenseBase::corner() in Eigen2 compatibility mode.

Enumerator:

TopLeft
TopRight
BottomLeft
BottomRight

Definition at line 257 of file Constants.h.

{ TopLeft, TopRight, BottomLeft, BottomRight };

enum Eigen::DecompositionOptions

Enum with options to give to various decompositions.

Enumerator:

Pivoting	Not used (meant for LDLT?).
NoPivoting	Not used (meant for LDLT?).
ComputeFullU	Used in JacobiSVD to indicate that the square matrix U is to be computed.
ComputeThinU	Used in JacobiSVD to indicate that the thin matrix U is to be computed.
ComputeFullV	Used in JacobiSVD to indicate that the square matrix V is to be computed.
ComputeThinV	Used in JacobiSVD to indicate that the thin matrix V is to be computed.
EigenvaluesOnly	Used in SelfAdjointEigenSolver and GeneralizedSelfAdjointEigenSolver to specify that only the eigenvalues are to be computed and not the eigenvectors.
ComputeEigenvectors	Used in SelfAdjointEigenSolver and GeneralizedSelfAdjointEigenSolver to specify that both the eigenvalues and the eigenvectors are to be computed.
EigVecMask
Ax_lBx	Used in GeneralizedSelfAdjointEigenSolver to indicate that it should solve the generalized eigenproblem $Ax = \lambda B x$ .
ABx_lx	Used in GeneralizedSelfAdjointEigenSolver to indicate that it should solve the generalized eigenproblem $ABx = \lambda x$ .
BAx_lx	Used in GeneralizedSelfAdjointEigenSolver to indicate that it should solve the generalized eigenproblem $BAx = \lambda x$ .
GenEigMask

Definition at line 377 of file Constants.h.

                          {
  Pivoting            = 0x01, 
  NoPivoting          = 0x02, 
  ComputeFullU        = 0x04,
  ComputeThinU        = 0x08,
  ComputeFullV        = 0x10,
  ComputeThinV        = 0x20,
  EigenvaluesOnly     = 0x40,
  ComputeEigenvectors = 0x80,
  EigVecMask = EigenvaluesOnly | ComputeEigenvectors,
  Ax_lBx              = 0x100,
  ABx_lx              = 0x200,
  BAx_lx              = 0x400,
  GenEigMask = Ax_lBx | ABx_lx | BAx_lx
};

enum Eigen::DirectionType

Enum containing possible values for the Direction parameter of Reverse, PartialReduxExpr and VectorwiseOp.

Enumerator:

Vertical	For Reverse, all columns are reversed; for PartialReduxExpr and VectorwiseOp, act on columns.
Horizontal	For Reverse, all rows are reversed; for PartialReduxExpr and VectorwiseOp, act on rows.
BothDirections	For Reverse, both rows and columns are reversed; not used for PartialReduxExpr and VectorwiseOp.

Definition at line 262 of file Constants.h.

                   { 
  Vertical, 
  Horizontal, 
  BothDirections 
};

enum Eigen::QRPreconditioners

Possible values for the QRPreconditioner template parameter of JacobiSVD.

Enumerator:

NoQRPreconditioner	Do not specify what is to be done if the SVD of a non-square matrix is asked for.
HouseholderQRPreconditioner	Use a QR decomposition without pivoting as the first step.
ColPivHouseholderQRPreconditioner	Use a QR decomposition with column pivoting as the first step.
FullPivHouseholderQRPreconditioner	Use a QR decomposition with full pivoting as the first step.

Definition at line 413 of file Constants.h.

                       {
  NoQRPreconditioner,
  HouseholderQRPreconditioner,
  ColPivHouseholderQRPreconditioner,
  FullPivHouseholderQRPreconditioner
};

enum Eigen::TransformTraits

Enum used to specify how a particular transformation is stored in a matrix.

See also:: Transform, Hyperplane::transform().

Enumerator:

Isometry	Transformation is an isometry.
Affine	Transformation is an affine transformation stored as a (Dim+1)^2 matrix whose last row is assumed to be [0 ... 0 1].
AffineCompact	Transformation is an affine transformation stored as a (Dim) x (Dim+1) matrix.
Projective	Transformation is a general projective transformation stored as a (Dim+1)^2 matrix.

Definition at line 445 of file Constants.h.

                     {
  Isometry      = 0x1,
  Affine        = 0x2,
  AffineCompact = 0x10 | Affine,
  Projective    = 0x20
};

Namespaces

Enumerations

Detailed Description

Enumeration Type Documentation