/home/hauberg/Dokumenter/Capture/humim-tracker-0.1/src/ntk/geometry/Eigen/src/Core/util/Constants.h

Go to the documentation of this file.

// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// Copyright (C) 2008-2009 Gael Guennebaud <gael.guennebaud@inria.fr>
// Copyright (C) 2007-2009 Benoit Jacob <jacob.benoit.1@gmail.com>
//
// Eigen is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 3 of the License, or (at your option) any later version.
//
// Alternatively, you can redistribute it and/or
// modify it under the terms of the GNU General Public License as
// published by the Free Software Foundation; either version 2 of
// the License, or (at your option) any later version.
//
// Eigen is distributed in the hope that it will be useful, but WITHOUT ANY
// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
// FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License or the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License and a copy of the GNU General Public License along with
// Eigen. If not, see <http://www.gnu.org/licenses/>.

#ifndef EIGEN_CONSTANTS_H
#define EIGEN_CONSTANTS_H

const int Dynamic = -1;

const int Infinity = -1;

const unsigned int RowMajorBit = 0x1;

const unsigned int EvalBeforeNestingBit = 0x2;

const unsigned int EvalBeforeAssigningBit = 0x4;

const unsigned int PacketAccessBit = 0x8;

#ifdef EIGEN_VECTORIZE

const unsigned int ActualPacketAccessBit = PacketAccessBit;
#else
const unsigned int ActualPacketAccessBit = 0x0;
#endif

const unsigned int LinearAccessBit = 0x10;

const unsigned int LvalueBit = 0x20;

const unsigned int DirectAccessBit = 0x40;

const unsigned int AlignedBit = 0x80;

const unsigned int NestByRefBit = 0x100;

// list of flags that are inherited by default
const unsigned int HereditaryBits = RowMajorBit
                                  | EvalBeforeNestingBit
                                  | EvalBeforeAssigningBit;

// Possible values for the Mode parameter of triangularView()
enum {
  Lower=0x1, Upper=0x2, UnitDiag=0x4, ZeroDiag=0x8,
  UnitLower=UnitDiag|Lower, UnitUpper=UnitDiag|Upper,
  StrictlyLower=ZeroDiag|Lower, StrictlyUpper=ZeroDiag|Upper,
  SelfAdjoint=0x10};

enum { Unaligned=0, Aligned=1 };
enum { ConditionalJumpCost = 5 };

// FIXME after the corner() API change, this was not needed anymore, except by AlignedBox
// TODO: find out what to do with that. Adapt the AlignedBox API ?
enum CornerType { TopLeft, TopRight, BottomLeft, BottomRight };

enum DirectionType { Vertical, Horizontal, BothDirections };
enum ProductEvaluationMode { NormalProduct, CacheFriendlyProduct };

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

enum {
  NoUnrolling,
  InnerUnrolling,
  CompleteUnrolling
};

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

enum {
  OnTheLeft = 1,  
  OnTheRight = 2  
};

/* the following could as well be written:
 *   enum NoChange_t { NoChange };
 * but it feels dangerous to disambiguate overloaded functions on enum/integer types.
 * If on some platform it is really impossible to get rid of "unused variable" warnings, then
 * we can always come back to that solution.
 */
struct NoChange_t {};
namespace {
  EIGEN_UNUSED NoChange_t NoChange;
}

struct Sequential_t {};
namespace {
  EIGEN_UNUSED Sequential_t Sequential;
}

struct Default_t {};
namespace {
  EIGEN_UNUSED Default_t Default;
}

enum {
  IsDense         = 0,
  IsSparse
};

enum AccessorLevels {
  ReadOnlyAccessors, WriteAccessors, DirectAccessors, DirectWriteAccessors
};

enum DecompositionOptions {
  Pivoting            = 0x01, // LDLT,
  NoPivoting          = 0x02, // LDLT,
  ComputeFullU        = 0x04, // SVD,
  ComputeThinU        = 0x08, // SVD,
  ComputeFullV        = 0x10, // SVD,
  ComputeThinV        = 0x20, // SVD,
  EigenvaluesOnly     = 0x40, // all eigen solvers
  ComputeEigenvectors = 0x80, // all eigen solvers
  EigVecMask = EigenvaluesOnly | ComputeEigenvectors,
  Ax_lBx              = 0x100,
  ABx_lx              = 0x200,
  BAx_lx              = 0x400,
  GenEigMask = Ax_lBx | ABx_lx | BAx_lx
};

enum QRPreconditioners {
  NoQRPreconditioner,
  HouseholderQRPreconditioner,
  ColPivHouseholderQRPreconditioner,
  FullPivHouseholderQRPreconditioner
};

enum ComputationInfo {
  Success = 0,        
  NumericalIssue = 1, 
  NoConvergence = 2   
};

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

namespace Architecture
{
  enum Type {
    Generic = 0x0,
    SSE = 0x1,
    AltiVec = 0x2,
#if defined EIGEN_VECTORIZE_SSE
    Target = SSE
#elif defined EIGEN_VECTORIZE_ALTIVEC
    Target = AltiVec
#else
    Target = Generic
#endif
  };
}

enum { CoeffBasedProductMode, LazyCoeffBasedProductMode, OuterProduct, InnerProduct, GemvProduct, GemmProduct };

enum Action {GetAction, SetAction};

struct Dense {};

struct MatrixXpr {};

struct ArrayXpr {};

#endif // EIGEN_CONSTANTS_H