Constants.h

// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// Copyright (C) 2008-2015 Gael Guennebaud <gael.guennebaud@inria.fr>
// Copyright (C) 2007-2009 Benoit Jacob <jacob.benoit.1@gmail.com>
// Copyright (C) 2020, Arm Limited and Contributors
//
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
// SPDX-License-Identifier: MPL-2.0
 
#ifndef EIGEN_CONSTANTS_H
#define EIGEN_CONSTANTS_H
 
// IWYU pragma: private
#include "../InternalHeaderCheck.h"
 
namespace Eigen {

constexpr int Dynamic = -1;

constexpr int DynamicIndex = 0xffffff;

constexpr int Undefined = 0xfffffe;

constexpr int Infinity = -1;

constexpr int HugeCost = 10000;


constexpr unsigned int RowMajorBit = 0x1;

constexpr unsigned int EvalBeforeNestingBit = 0x2;

EIGEN_DEPRECATED constexpr unsigned int EvalBeforeAssigningBit = 0x4;

constexpr unsigned int PacketAccessBit = 0x8;
 
#ifdef EIGEN_VECTORIZE
constexpr unsigned int ActualPacketAccessBit = PacketAccessBit;
#else
constexpr unsigned int ActualPacketAccessBit = 0x0;
#endif

constexpr unsigned int LinearAccessBit = 0x10;

constexpr unsigned int LvalueBit = 0x20;

constexpr unsigned int DirectAccessBit = 0x40;

EIGEN_DEPRECATED constexpr unsigned int AlignedBit = 0x80;
 
constexpr unsigned int NestByRefBit = 0x100;

constexpr unsigned int NoPreferredStorageOrderBit = 0x200;

constexpr unsigned int CompressedAccessBit = 0x400;
 
// list of flags that are inherited by default
constexpr unsigned int HereditaryBits = RowMajorBit | EvalBeforeNestingBit;


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

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

enum DirectionType {
  Vertical,
  Horizontal,
  BothDirections
};

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

enum UnrollingType {
  NoUnrolling,
  InnerUnrolling,
  CompleteUnrolling
};

enum SpecializedType { Specialized, BuiltIn };

enum StorageOptions {
  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 SideType {
  OnTheLeft = 1,
  OnTheRight = 2
};

enum NaNPropagationOptions {
  PropagateFast = 0,
  PropagateNaN,
  PropagateNumbers
};
 
/* the following used to be written as:
 *
 *   struct NoChange_t {};
 *   namespace {
 *     EIGEN_UNUSED NoChange_t NoChange;
 *   }
 *
 * on the ground that it feels dangerous to disambiguate overloaded functions on enum/integer types.
 * However, this leads to "variable declared but never referenced" warnings on Intel Composer XE,
 * and we do not know how to get rid of them (bug 450).
 */
 
// NoChange is set to -1 (rather than 0) so that calls like resize(NoChange, n)
// that land in a generic resize(Index, Index) overload — missing the NoChange_t
// overload — trip the rows/cols >= 0 assertion instead of silently producing a
// 0-sized dimension. See issue #656.
enum NoChange_t { NoChange = -1 };
enum Sequential_t { Sequential };
enum Default_t { Default };

enum AmbiVectorMode { IsDense = 0, IsSparse };

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

enum DecompositionOptions {
  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 QRPreconditioners {
  ColPivHouseholderQRPreconditioner = 0x0,
  NoQRPreconditioner = 0x40,
  HouseholderQRPreconditioner = 0x80,
  FullPivHouseholderQRPreconditioner = 0xC0,
  DisableQRDecomposition = NoQRPreconditioner,
  PreconditionSquareMatrix = 0x800
};
 
// JacobiSVD and BDCSVD combine QR preconditioner flags with decomposition flags in a single template bitmask.
constexpr int operator|(QRPreconditioners qr_preconditioner, DecompositionOptions decomposition_option) {
  return static_cast<int>(qr_preconditioner) | static_cast<int>(decomposition_option);
}
 
constexpr int operator|(DecompositionOptions decomposition_option, QRPreconditioners qr_preconditioner) {
  return static_cast<int>(decomposition_option) | static_cast<int>(qr_preconditioner);
}
 
#ifdef Success
#error The preprocessor symbol 'Success' is defined, possibly by the X11 header file X.h
#endif

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

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

namespace Architecture {
enum Type {
  Generic = 0x0,
  SSE = 0x1,
  AltiVec = 0x2,
  VSX = 0x3,
  NEON = 0x4,
  MSA = 0x5,
  SVE = 0x6,
  HVX = 0x7,
  LSX = 0x8,
  RVV10 = 0x9,
  SME = 0xa,
#if defined EIGEN_VECTORIZE_SSE
  Target = SSE
#elif defined EIGEN_VECTORIZE_ALTIVEC
  Target = AltiVec
#elif defined EIGEN_VECTORIZE_VSX
  Target = VSX
#elif defined EIGEN_VECTORIZE_SME
  Target = SME
#elif defined EIGEN_VECTORIZE_NEON
  Target = NEON
#elif defined EIGEN_VECTORIZE_SVE
  Target = SVE
#elif defined EIGEN_VECTORIZE_MSA
  Target = MSA
#elif defined EIGEN_VECTORIZE_HVX
  Target = HVX
#elif defined EIGEN_VECTORIZE_LSX
  Target = LSX
#elif defined EIGEN_VECTORIZE_RVV10
  Target = RVV10
#else
  Target = Generic
#endif
};
}  // namespace Architecture

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

enum Action { GetAction, SetAction };

struct Dense {};

struct Sparse {};

struct SolverStorage {};

struct PermutationStorage {};

struct TranspositionsStorage {};

struct MatrixXpr {};

struct ArrayXpr {};
 
// An evaluator must define its shape. By default, it can be one of the following:
struct DenseShape {
  static std::string debugName() { return "DenseShape"; }
};
struct SolverShape {
  static std::string debugName() { return "SolverShape"; }
};
struct HomogeneousShape {
  static std::string debugName() { return "HomogeneousShape"; }
};
struct DiagonalShape {
  static std::string debugName() { return "DiagonalShape"; }
};
struct SkewSymmetricShape {
  static std::string debugName() { return "SkewSymmetricShape"; }
};
struct BandShape {
  static std::string debugName() { return "BandShape"; }
};
struct TriangularShape {
  static std::string debugName() { return "TriangularShape"; }
};
struct SelfAdjointShape {
  static std::string debugName() { return "SelfAdjointShape"; }
};
struct PermutationShape {
  static std::string debugName() { return "PermutationShape"; }
};
struct ScaledPermutationShape {
  static std::string debugName() { return "ScaledPermutationShape"; }
};
struct TranspositionsShape {
  static std::string debugName() { return "TranspositionsShape"; }
};
struct SparseShape {
  static std::string debugName() { return "SparseShape"; }
};
 
namespace internal {
 
// random access iterators based on coeff*() accessors.
struct IndexBased {};
 
// evaluator based on iterators to access coefficients.
struct IteratorBased {};

enum ComparisonName : unsigned int {
  cmp_EQ = 0,
  cmp_LT = 1,
  cmp_LE = 2,
  cmp_UNORD = 3,
  cmp_NEQ = 4,
  cmp_GT = 5,
  cmp_GE = 6
};
}  // end namespace internal
 
}  // end namespace Eigen
 
#endif  // EIGEN_CONSTANTS_H